text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Mac Mini на M1: взгляд изнутри
Ранее мы говорили про [Mac Mini в дата-центрах](https://habr.com/ru/company/selectel/blog/540494/). В этой статье мы заглянем «под капот» новейшего mac на базе SoC M1 в прямом и переносном смыслах.
Как известно, гостей встречают по одежке. Наш сегодняшний гость, новый Mac Mini, минимально отличается от своего предшественника 2018 года. Первое отличие заключается в предоставляемых интерфейсах ThunderBolt. Старое поколение имеет 4 порта, а новое — всего 2. Второе заметное отличие касается окраса Mac Mini. Устройства с процессорами Intel поставляются в цвете Space Gray, а c M1 — в цвете Silver.
Вероятно, Apple таким образом смещает акцент в сторону внутреннего содержимого Mac Mini. Минимальные различия во внешнем виде разных поколений побуждают уделить больше внимания их производительности. Бонусом — снижение рисков, сроков и расходов на разработку новых комплектующих.
Мы пойдем на поводу у желания посмотреть внутрь Mac Mini и разберем его.
Внутренний мир
--------------
*Mac Mini 2020*
*Mac Mini 2018 (источник [ifixit.com](https://ru.ifixit.com/Teardown/Mac+mini+Late+2018+Teardown/115210))*
«Ключами» к внутреннему миру Mac Mini являются отвертки Torx: T5, T6 и T8. Как и в предыдущем поколении, за пластиковой заглушкой находится алюминиевая крышка, прикрученная шестью болтами. Легко заметить, что в новом Mac Mini очень много пустого пространства. Снимаем вентилятор.
*Mac Mini 2020 без вентилятора*
На соединение материнской платы наклеена черная полоска, похожая на изоленту. **Снятие данной наклейки лишает гарантии**. В новом Mac Mini нет модернизируемых частей, поэтому поводов извлекать основную плату из корпуса тоже нет.
*Основная плата вне корпуса*
*Материнская плата без передней панели и динамика*
Материнская плата без корпуса, передней панели и динамика выглядит невероятно миниатюрной. На переднем плане видно два железных компонента без опознавательных знаков, которые, скорее всего, являются накопителем. Самое интересное ждет под воздуховодом и радиатором. Откручиваем оставшиеся 8 болтов и получаем доступ к сердцу Mac Mini.
Под радиатором можно увидеть сразу три чипа, помеченных логотипом Apple. Однако известный M1 узнается сразу. Рядом с основным кристаллом процессора находятся два модуля оперативной памяти LPDDR4X. Множество чипов не маркированы, тем не менее, узнаются следующие:
* MegaChips MCDP2920A4, конвертер DisplayPort 1.4 в HDMI 2.0;
* Broadcom BCM57782, гигабитный Ethernet-контроллер;
* 2x [Intel JHL8040R](https://ark.intel.com/content/www/us/en/ark/products/186251/intel-jhl8040r-thunderbolt-4-retimer.html), ретаймер ThunderBolt 4;
* Apple 1096 и 1097.
Микросхемы на обратной стороне материнской платы:
* 2x Texas Instruments CD3217B12;
* Renesas 501CR0B;
* Fresco Logic FL1100SX, контроллер PCIe-to-USB;
Близкое расположение всех компонентов способствует повышению скорости обмена информацией, но это лишь теория. Протестируем Mac Mini на практике и сделаем собственные выводы.
Производительность
------------------
Процессор M1 состоит из 8 ядер на архитектуре ARM64. Однако это не обычные ядра. Половина из них — высокопроизводительные ядра FireStorm, а остальные — энергоэффективные IceStorm. Официальной информации по TDP процессора нет, но по оценкам тепловыделение не превышает 21 ватта.
*Установка транслятора Rosetta 2*
Первый тест в нашем плане — GeekBench5, быстрый тест производительности процессоров. На Mac с M1 бенчмарк можно запустить нативно и через транслятор x86 в arm64. Последний по умолчанию отсутствует в системе, но его можно легко установить с помощью следующей команды:
```
softwareupdate --install-rosetta
```
Операционная система также предложит установить транслятор при запуске старого приложения.
*Главное окно GeekBench5*
При наличии Rosetta 2 в GeekBench5 можно выбрать архитектуру Intel. Это позволит измерить производительность Mac Mini на неадаптированных «классических» приложениях.
| Архитектура приложения | Single-Core Score | Multi-Core Score |
| --- | --- | --- |
| [Apple Silicon](https://browser.geekbench.com/v5/cpu/6145079) | 1742 | 7577 |
| [Intel](https://browser.geekbench.com/v5/cpu/6145122) | 1297 | 6012 |
| Intel Core i5-10500 | 1176 | 5979 |
| Intel Core i9-9900 | 1246 | 7687 |
Производительность приложений x86\_64 на M1 ниже нативных всего на 20%. Если оценивать по архитектуре Intel, то Apple M1 показывает результат на уровне 65-ваттного Intel Core i5-10500, а в исполнении нативного кода немного отстает от Intel Core i9-9900.
| Графический ускоритель | OpenCL Compute Score |
| --- | --- |
| [Apple M1](https://browser.geekbench.com/v5/compute/2427265) | 19465 |
| GeForce GTX 970M | 19743 |
| Графический ускоритель | Metal Compute Score |
| --- | --- |
| [Apple M1](https://browser.geekbench.com/v5/compute/2310082) | 22022 |
| NVIDIA GeForce GTX 980 | 21820 |
В GeekBench есть секция Compute, которая измеряет производительность графического ускорителя. В этом Mac Mini графическим ускорителем выступают ядра процессора. Мы провели тесты на доступных для M1 технологиях: OpenCL и Metal. Процессор Apple показывает хороший результат, даже в сравнении с внешними видеокартами.
В Apple M1 присутствует [16-ядерная система Neural Engine](https://www.apple.com/ru/mac/m1/) для работы с нейронными сетями и машинным обучением. Нам хотелось провести тестирование с помощью [AI Benchmark](https://ai-benchmark.com/), однако данный тест не запускается из-за ошибки определения процессора.
Поэтому мы выбрали более простой тест — обучение сверточной нейронной сети (CNN) для классификации рукописных цифр на датасете MNIST. Мы применили [скрипт](https://github.com/apple/tensorflow_macos/issues/25), адаптированный для использования с форком Tensorflow для macOS. В данном тесте три ключевых параметра:
* среднее время прохождения эпохи;
* среднее время прохождения шага эпохи;
* точность полученной модели.
Мы провели тесты не только на подопытном Mac Mini, но и на некоторых видеокартах и процессорах для дата-центров. Вот что у нас получилось:
| Устройство | Среднее время эпохи, с | Среднее время шага, мс | Точность модели |
| --- | --- | --- | --- |
| Apple M1 (CPU) | 15 | 33 | 99.81% |
| Apple M1 (GPU) | 19 | 40 | 99.36% |
| Nvidia GeForce GTX1080 | 3 | 6 | 99.85% |
| Intel® Xeon® Gold 6240 | 9 | 17 | 99.86% |
| Nvidia Tesla A100 | 3 | 3 | 99.87% |
| Nvidia Tesla V100 | 3 | 3 | 99.94% |
| Nvidia Tesla P40 | 3 | 5 | 99.89% |
Настольный компьютер не может «порвать» видеокарты из серверного сегмента, но если взять во внимание низкое энергопотребление, Apple M1 показывает себя как серьезного конкурента.
Заключение
----------
Новый Mac Mini на M1 навевает мысли о том, что скоро настольные компьютеры перейдут на архитектуру ARM64. Apple сделала устройство, которое преподносит пользователю что-то новое и непривычное, но не отбирает старое и привычное, позволяя запускать приложения, созданные под другую архитектуру.
Как вы думаете, сможет ли архитектура ARM полностью вытеснить x64?
[](https://slc.tl/lmXW3) | https://habr.com/ru/post/544378/ | null | ru | null |
# Это мог быть очередной JavaScript-фреймворк
Прошлым летом, в процессе подготовки [статьи](https://habr.com/ru/company/lanit/blog/462855/) для Хабра, я не поленился упаковать свой шаблон для бэкэнд-приложений на Node.js в npm-пакет, сделав из него cli-утилиту для быстрого старта.
Никаких надежд на то, что этим пакетом будет пользоваться кто-то, кроме меня, не было изначально. Однако, когда я решил обновить шаблон, внедрив в него нужные мне фичи, я обратил внимание на то, что у npm-пакета есть несколько десятков скачиваний в неделю, а у проекта на гитхабе 12 звёзд. Поставленные по доброте хорошими людьми, наверняка, чтобы поддержать меня, а не проект. Всего 12 звёзд, но мне этого хватило, чтобы решить, что karcass я буду развивать так, как будто он нужен не только мне.
Несмотря на то, что изначально я решил сделать легковесный фреймворк для бэкэнд-приложений, в процессе разработки мне удалось себя убедить в том, что этот велосипед не нужен. И что karcass должен стать не фреймворком, а универсальным инструментом для создания приложений из шаблонов.
В первой версии логика работы cli-скрипта была примитивной.
1. Пользователь указывает настройки.
2. karcass копирует содержимое своей же директории template в созданную под новый проект директорию.
3. В процессе копирования каждый файл проходит через обработчик, который может изменить содержимое файла (заменить какой-то текст, удалить строки) или блокировать копирование (файл не попадёт в результирующую директорию).
4. После копирования шаблона, установщик выполняет `npm install`.
Для пользователя этот процесс выглядел так:
Обработка исходников шаблона в соответствии с настройками была реализована набором условий и реплэйсов. Поддерживать это было невозможно, [посмотрите сами](https://github.com/karcass-ts/karcass/blob/v0.0.8/src/Create/Service/MorphyService.ts).
Сам шаблон представлял из себя сплошной антипаттерн, позволявший быстро писать монолиты: класс Application являлся контейнером, доступным в любом сервисе, контроллере или консольной команде. Что угодно могло обращаться к чему угодно без указания конкретных зависимостей, например:
**Application.ts**
```
import Express from 'express'
import { AbstractConsoleCommand } from './Base/Console/AbstractConsoleCommand'
import { DbService } from './Database/Service/DbService'
import { HelpCommand } from './Base/Console/HelpCommand'
import { LoggerService } from './Logger/Service/LoggerService'
import { IssueService } from './Project/Service/IssueService'
import { GitlabService } from './Gitlab/Service/GitlabService'
import { LocalCacheService } from './Base/Service/LocalCacheService'
import { ProjectService } from './Project/Service/ProjectService'
import { GroupService } from './Project/Service/GroupService'
import { UserService } from './User/Service/UserService'
import { UpdateProjectsCommand } from './Gitlab/Console/UpdateProjectsCommand'
import { CreateMigrationCommand } from './Database/Console/CreateMigrationCommand'
import { MigrateCommand } from './Database/Console/MigrateCommand'
import { MigrateUndoCommand } from './Database/Console/MigrateUndoCommand'
import IssueController from './Project/Controller/IssueController'
import fs from 'fs'
export class Application {
public http!: Express.Express
// Services
public localCacheService!: LocalCacheService
public loggerService!: LoggerService
public dbService!: DbService
public gitlabService!: GitlabService
public issueService!: IssueService
public projectService!: ProjectService
public groupService!: GroupService
public userService!: UserService
// Commands
public helpCommand!: HelpCommand
public createMigrationCommand!: CreateMigrationCommand
public migrateCommand!: MigrateCommand
public migrateUndoCommand!: MigrateUndoCommand
public updateProjectsCommand!: UpdateProjectsCommand
// Controllers
public issueController!: IssueController
public constructor(public readonly config: IConfig) {
if (config.columns.length < 2) {
throw new Error('There are too few columns :-(')
}
}
public async run() {
this.initializeServices()
if (process.argv[2]) {
this.initializeCommands()
for (const command of Object.values(this)
.filter((c: any) => c instanceof AbstractConsoleCommand) as AbstractConsoleCommand[]
) {
if (command.name === process.argv[2]) {
await command.execute()
process.exit()
}
}
await this.helpCommand.execute()
process.exit()
} else {
this.runWebServer()
}
}
protected runWebServer() {
this.initCron()
this.http = Express()
this.http.use('/', Express.static('vue/dist'))
this.http.use((req, res, next) => {
if (req.url.indexOf('/api') === -1) {
res.header('Cache-Control', 'private, no-cache, no-store, must-revalidate')
res.header('Expires', '-1')
res.header('Pragma', 'no-cache')
return res.send(fs.readFileSync('vue/dist/index.html').toString())
}
next()
})
this.http.use(Express.urlencoded())
this.http.use(Express.json())
this.http.listen(this.config.listen, () => console.log(`Listening on port ${this.config.listen}`))
this.initializeControllers()
}
protected initCron() {
if (this.config.gitlab.updateInterval) {
setInterval(async () => {
if (!this.updateProjectsCommand) {
this.updateProjectsCommand = new UpdateProjectsCommand(this)
}
await this.updateProjectsCommand.execute()
}, this.config.gitlab.updateInterval * 1000)
}
}
protected initializeServices() {
this.localCacheService = new LocalCacheService(this)
this.gitlabService = new GitlabService(this)
this.loggerService = new LoggerService(this)
this.dbService = new DbService(this)
this.issueService = new IssueService(this)
this.projectService = new ProjectService(this)
this.groupService = new GroupService(this)
this.userService = new UserService(this)
}
protected initializeCommands() {
this.helpCommand = new HelpCommand(this)
this.createMigrationCommand = new CreateMigrationCommand(this)
this.migrateCommand = new MigrateCommand(this)
this.migrateUndoCommand = new MigrateUndoCommand(this)
this.updateProjectsCommand = new UpdateProjectsCommand(this)
}
protected initializeControllers() {
this.issueController = new IssueController(this)
}
}
```
**ProjectService.ts**
```
import { AbstractService } from '../../Base/Service/AbstractService'
import { Project } from '../Entity/Project'
export class ProjectService extends AbstractService {
public get projectRepository() {
return this.app.dbService.connection.getRepository(Project)
}
public async updateProjects(allTime = false) {
await this.app.groupService.updateGroups()
for (const data of await this.app.gitlabService.getProjects()) {
let project = await this.getProject(data.id)
if (!project) {
project = this.projectRepository.create({ id: data.id })
}
project.name = data.name
project.url = data.web_url
project.updatedTimestamp = Math.round(new Date(data.last_activity_at).getTime() / 1000)
project.groupId = data.namespace && data.namespace.kind === 'group' ? data.namespace.id : null
await this.projectRepository.save(project)
await this.app.issueService.updateProjectIssues(project, allTime)
}
}
public async getProject(id: number): Promise {
return id ? this.app.localCacheService.get(`project.${id}`, () => this.projectRepository.findOne(id)) : undefined
}
}
```
Разумеется, в новой версии шаблона, который предназначался бы уже не только для меня, предлагать такую архитектуру было бы просто неприлично. Поэтому я посвятил некоторое время разработке простенького, но функционального [DI-контейнера](https://github.com/karcass-ts/container), а на его основе сделал [класс для работы с cli](https://github.com/karcass-ts/cli).
Теперь в `Application.ts` появился контейнер, который может инициализировать зависимости по запросу или «на месте». При этом контейнер может создавать экземпляр зависимости сам или получать его из коллбэка.
**Application.ts**
```
import CreateExpress, { Express } from 'express';
import { TwingEnvironment, TwingLoaderFilesystem } from 'twing';
import { Container } from '@karcass/container';
import { Cli } from '@karcass/cli';
import { Connection, createConnection } from 'typeorm';
import { CreateMigrationCommand, MigrateCommand, MigrateUndoCommand } from '@karcass/migration-commands';
import { createLogger } from './routines/createLogger';
import { Logger } from 'winston';
import { FrontPageController } from './SampleBundle/Controller/FrontPageController';
import { Message } from './SampleBundle/Entity/Message';
import { MessagesService } from './SampleBundle/Service/MessagesService';
export class Application {
private container = new Container();
private console = new Cli();
private controllers: object[] = [];
private http!: Express;
public constructor(public readonly config: IConfig) { }
public async run() {
await this.initializeServices();
if (process.argv[2]) {
this.initializeCommands();
await this.console.run();
} else {
this.runWebServer();
}
}
protected runWebServer() {
this.http = CreateExpress();
this.http.use('/public', CreateExpress.static('public'));
this.http.use(CreateExpress.urlencoded());
this.http.listen(this.config.listen, () => console.log(`Listening on port ${this.config.listen}`));
this.container.add('express', () => this.http);
this.container.add(TwingEnvironment, () => new TwingEnvironment(new TwingLoaderFilesystem('src')));
this.initializeControllers();
}
protected async initializeServices() {
await this.container.addInplace('logger', () => createLogger(this.config.logdir));
const typeorm = await this.container.addInplace(Connection, () => createConnection({
type: 'sqlite',
database: 'db/sample.sqlite',
entities: ['build/\*\*/Entity/\*.js'],
migrations: ['build/\*\*/Migrations/\*.js'],
logging: ['error', 'warn', 'migration'],
}));
this.container.add('Repository', () => typeorm.getRepository(Message));
this.container.add(MessagesService);
}
protected initializeCommands() {
this.console.add(CreateMigrationCommand, () => new CreateMigrationCommand());
this.console.add(MigrateCommand, async () => new MigrateCommand(await this.container.get(Connection)));
this.console.add(MigrateUndoCommand, async () => new MigrateUndoCommand(await this.container.get(Connection)));
}
protected async initializeControllers() {
this.controllers.push(
await this.container.inject(FrontPageController),
);
}
}
```
Использование TypeScript позволяет указывать зависимости с помощью декоратора:
**FrontPageController.ts**
```
import { Express } from 'express';
import { Dependency } from '@karcass/container';
import { TwingEnvironment } from 'twing';
import { AbstractController, QueryData } from './AbstractController';
import { MessagesService } from '../Service/MessagesService';
export class FrontPageController extends AbstractController {
public constructor(
@Dependency('express') protected express: Express,
@Dependency(TwingEnvironment) protected twing: TwingEnvironment,
@Dependency(MessagesService) protected messagesService: MessagesService,
) {
super(express);
this.onQuery('/', 'get', this.frontPageAction);
this.onQuery('/', 'post', this.sendMessageAction);
}
public async sendMessageAction(data: QueryData) {
await this.messagesService.addMessage(data.params.text);
data.res.redirect('/');
}
public async frontPageAction() {
if (await this.messagesService.isEmpty()) {
await this.messagesService.createSampleMessages();
}
return this.twing.render('SampleBundle/Views/front.twig', {
messages: await this.messagesService.getMessages(),
});
}
}
```
В случае с JavaScript, экземпляр придётся создавать «вручную»:
```
protected async initializeControllers() {
this.controllers.push(
new FrontPageController(
await this.container.get('express'),
await this.container.get(TwingEnvironment),
await this.container.get(MessagesService),
),
);
}
```
Если раньше шаблон располагался в директории `template` самого karcass, то теперь я решил вынести шаблон в отдельный проект: так разработка и отладка становится проще. Соответственно, появилась необходимость в интерфейсе общения между установщиком и самим шаблоном.
После нескольких недель вечерних изысканий я пришёл к следующему варианту реализации: в корне любого шаблона должен быть файл `TemplateReducer.ts` или `TemplateReducer.js`, который должен экспортировать класс `TemplateReducer`, реализующий такой интерфейс:
```
interface TemplateReducerInterface {
getConfigParameters(): Promise
getConfig(): Record
setConfig(config: Record): void
getDirectoriesForRemove(): Promise
getFilesForRemove(): Promise
getDependenciesForRemove(): Promise
getFilesContentReplacers(): Promise
finish(): Promise
getTestConfigSet(): Promise[]>
}
```
На этом этапе меня, наконец, осенило, что я работаю не над реализацией какого-то скелета приложения, что karcass не должен стать очередным ненужным никому фреймворком, но он может стать хорошим инструментом для работы с шаблонами приложений на JavaScript/TypeScript. Это могут быть шаблоны бэкэнд-приложений. Кто-то сможет его использовать для создания приложений на основе своей выстраданной конфигурации webpack. Возможно, какой-то шаблон может стать хорошей альтернативой `create-react-app` ~~с блекдж...~~ с настройками на этапе установки, как у `vue create`.
Не буду нудить описанием каждого метода `TemplateReducerInterface`, тем более, что пример реализации можно [посмотреть](https://github.com/karcass-ts/default-template/blob/master/TemplateReducer.ts) на гитхабе. Вместо этого предлагаю небольшой туториал по созданию простейшего шаблона для karcass:
В пустую директорию `hello` поместим файл `index.js` незатейливого содержания:
```
console.log('Hello, [replacethisname]!')
```
Рядом с ним кладём файл `TemplateReducer.js`, который расскажет karcass'у как настроить шаблон и выполнит соответствующие изменения в процессе установки:
```
const reducer = require('@karcass/template-reducer')
const Type = reducer.ConfigParameterType
class TemplateReducer extends reducer.AbstractTemplateReducer {
getConfigParameters() {
return [
{ name: 'name', description: 'Please enter your name', type: Type.string },
]
}
async getFilesContentReplacers() {
return [
{ filename: 'index.js', replacer: (content) => {
return content.replace('[replacethisname]', this.config.name)
} },
]
}
async finish() {
console.log(`Application installed, to launch it execute\n cd ${this.directoryName} && node index.js`)it.`)
}
}
module.exports = { TemplateReducer }
```
Как можно заметить, у любого шаблона есть, как минимум, одна зависимость — `@karcass/template-reducer`, нужно не забыть её установить, создав перед этим `package.json`:
```
npm init && npm install @karcass/template-reducer
```
Не нужно беспокоиться о том, чтобы убрать эту зависимость в методе `getDependenciesForRemove`, её karcass уберёт сам.
Теперь можно посмотреть как karcass справится с созданием приложения из нашего шаблона. Делать это нужно не в директории шаблона, иначе неизбежна рекурсия при копировании директории шаблона саму в себя.
Всё это было бы бессмысленно, если бы кроме установки из локальной директории karcass не мог устанавливать приложения из общедоступных источников. Пока поддерживается только github.com, можете попробовать:
```
npx karcass create helloworld https://github.com/karcass-ts/hello-world
```
Ненавязчиво предложу попробовать и мой дефолтный шаблон, который устанавливается по-умолчанию, если не указать путь до шаблона:
```
npx karcass create ooohhhh-ok-show-it
```
Тестирование? У шаблона есть возможность задавать пресеты конфигурации для тестирования, в `TemplateReducer` нашего helloworld-шаблона можно было бы добавить такой метод:
```
getTestConfigSet() {
return [
{ name: 'testname1' },
{ name: 'testname2' },
]
}
```
Само тестирование запускается так:
```
npx karcass test www/karcass/hello
```
Процесс тестирования — это просто поочерёдная установка шаблона с заданной конфигурацией. Примитивно, но ничего лучше я не придумал, по крайней мере, пока:
Я решил не делать лонгрид с описанием всех особенностей karcass, а сделать небольшую ознакомительную заметку с целью презентации и сбора фидбека: любой отзыв будет мне полезен, чтобы понять, куда двигаться дальше и стоит ли. Пока же в приоритете написание документации.
[Репозиторий karcass на github](https://github.com/karcass-ts/karcass); | https://habr.com/ru/post/487648/ | null | ru | null |
# #2 Блок управления видеослайдером
Привет, хабравчане! Помните мой [моторизованный видеослайдер](https://geektimes.ru/post/259040/) из мебельной фурнитуры, строительного правило и оргстекла?)
Сегодня я вам покажу новую штуку, чуть попроще, чем предыдущий проект. На этот раз без рельсы, только электрическая часть.
Читаем ниже!
…
**Предыстория.**
Свой [моторизованный видеослайдер](https://geektimes.ru/post/259040/) я сложил в конце июля прошлого года, когда оставался всего месяц до учёбы и сложилась ситуация «ни туда, ни сюда». Я отснял всего несколько шестисекундных сцен на свой слайдер и на этом всё. Затем первый курс в университете, вливание в студенческую жизнь и т.д. Вообщем не до слайдера мне было. На выходных ездил домой. Если было время, доставал слайдер. Выходил на природу пару раз для теста. Но это не то, что надо. Заснять красоту — нужно выбираться далеко на машине да и не на выходной день, а на подольше)
Осень, зима, весна…
**Май.** Как-то мне приходит сообщение: «Привет! Посмотрел твою статью про [моторизованный видеослайдер](https://geektimes.ru/post/259040/) на „Гигтаймсе“, понравилось! Я занимаюсь видеосъёмкой, и давно хочу моторизовать свой слайдер, но человека в [Минске](https://geektimes.ru/search/?q=%D0%BC%D0%B8%D0%BD%D1%81%D0%BA) так и не нашёл, кто бы изготавливал приводы к ним. Поможешь?)»
«Конечно!» — ответил я.
Приехал домой к заказчику, посмотрели его слайдер (промышленный, система **IGUS**), поговорили о том о сём, обсудили, что он хочет от привода. Сергей, заказчик, захотел моторизовать только одну каретку слайдера, для начала.
«Хорошо, как пожелаешь), — говорю я. — Предоплату вперед! 2-3 недели, и привезу.»
Сначала принялся за изготовление корпуса блока управления. Материал, как и в первом проекте, **оргстекло**. Хорошо себя зарекомендовало! Прочное, лёгкое, отлично режется (ножовкой по металлу с мелким зубом) и обрабатывается.
Можно клеить!
Итак, железо. За основу взят микроконтроллер **Arduino Nano**.
Мотором управляет **EasyDriver**.
Шаговый двигатель **Nema 17**.
Скоростью управляем при помощи **потенциометра**.
Питание организовал на основе аккумуляторов типоразмера **18650**.
В этот раз коннектор для подключения двигателя был **модернизирован**. Вместо **советского** DIN использовал **MIC 4 PIN**.
**Функционал**.
Заказчик попросил только один режим работы — каретка бесконечно ездит туда-обратно, скорость можно изменять **потенциометром** в любой момент времени. Тумблером останавливаем каретку, когда нужно.
**Скетч:**
```
#define xy A0
int Distance = 0;
int x = 0;
void setup() {
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
digitalWrite(2, LOW);
digitalWrite(3, LOW);
pinMode(xy, INPUT);
}
void loop()
{
x = analogRead(xy);
x = map(x, 20, 700, 10, 4000);
digitalWrite(3, HIGH);
delayMicroseconds(x);
digitalWrite(3, LOW);
delayMicroseconds(x);
Distance = Distance + 1;
if (Distance == 1600*13.8)
{
if (digitalRead(2) == LOW)
{
digitalWrite(2, HIGH);
}
else
{
digitalWrite(2, LOW);
}
Distance = 0;
delay(2500);
}
}
```
**Вот, что получилось в итоге!)**
Получился надёжный блок управления. Свою задачу он выполняет на все сто процентов! В этот раз я использовал матовую крышку из оргстекла. Мне так больше нравится, нежели глянец и [безобразие](https://habrastorage.org/files/913/402/fc0/913402fc0ffa44fd9c813fb8bae5a006.jpg) проводов внутри корпуса. Думаю, вы согласитесь со мной) Также можно матировать и весь корпус.
**ИТАК, что мы имеем?** Мы имеем **отличное решение моторизовать свой видеослайдер менее чем за 100$.**
Сергей хорошо оценил привод) Желаю ему удачи в его видео проектах! Ну а вам, форумчане, я также желаю исполнения задуманных идей!) | https://habr.com/ru/post/395557/ | null | ru | null |
# Каламбуры на css
Хабровчане, всех с пятницей! Сейчас у подавляющего большинства читателей хабра рабочий день уже закончился, поэтому можно расслабиться и немного отвлечься от серьезных тем. Вы знали, что на css можно каламбурить? На кдпв один из примеров, а под катом небольшая простыня специфических css шуток.
```
#big-bang::before {
content: "";
}
.lego {
display: block;
}
.autobots {
transform: translate3d();
}
.ninja {
color: black;
visibility: hidden;
animation-duration:0.00001s;
}
#china {
border-top-style: solid;
}
#tower-of-pisa {
font-style: italic;
}
#australia {
transform: rotateY(180deg);
}
.kkk {
color: white !important;
}
.ikea {
display: table
}
.moonwalk {
transition: .2s ease-in-out; transform: translateX(-300px);
}
.rich-people {
top: 1%;
}
.working-class {
bottom: 99%;
}
.slimshady {
vertical-align: top;
}
.sith {
position:absolute;
}
.delorean {
z-index: -1955;
}
.illuminati {
position: absolute;
visibility: hidden;
}
.twins {
flex-grow:1;
}
.gangsta-rap {
word-spacing: 0;
}
* {
position: relative;
}
.beer { float: right; float: left; float: right; float: left; float: right; float: left; float: right; float: none; }
```
Если тема интересна — стоит гуглить «CSS Puns», если же хорошо работает фантазия — пишите свои каламбуры в комментариях. | https://habr.com/ru/post/261769/ | null | ru | null |
# test.it — не опять, а снова
Добрый день хабр.
После моей [статьи](http://habrahabr.ru/post/188268/) о **test.it** прошла ~~вечность~~ неделя. И как я не планировал растянуть этот срок хотя бы на месяц, но пришло время для новой публикации.
Картинка для привлечения внимания:
С того времени библиотека *(во многом благодаря хабравчанам)* обросла новым функционалом.
А ввиду того, что синтаксис, приведённый в прошлой статье, в текущей версии работает не полностью, откладывать эту статью ещё на 3 недели у меня нету права.
Кто не любит много слов — [Сайт](http://titulus.github.io/testit/) на котором можно увидеть код в действии, [GitHub](https://github.com/titulus/testit), [Wiki](https://github.com/titulus/testit/wiki)
Появились цепочные вызовы
```
test.it(some)
.comment('comment to test')
.callback(function(){alert('test has been passed')})
.arguments(); // -> [some]
test.group('group', function(){ ... })
.comment('comment to group')
.result(); // -> true/false
```
и новый механизм вложенности
```
test.group('first group',function(){
...
test.group('second group', function(){
...
});
...
});
test.group('first group').group('second group',function(){ ... });
```
Новый способ отображения ошибок
И два дополнительных метода **test.typeof()** и **test.trace()**.
А также 3 [Wiki](https://github.com/titulus/testit/wiki)-страницы.
### А теперь обо всём этом поподробнее.
И так. Разберём пример, приведённый в [wiki](https://github.com/titulus/testit/wiki/etc#example):
Пока мы ещё не приступили к тестам, воспользуемся методом **test.typeof()**.
```
console.log(
test.typeof(1)
,test.typeof("text")
,test.typeof([1,2,3])
,test.typeof({a:1,b:2})
,test.typeof()
,test.typeof(document)
,test.typeof(document.getElementsByTagName("body"))
,test.typeof(window)
,test.typeof(/yes it is RegExp/) // and many many more ...
);
```
[test.typeof()](https://github.com/titulus/testit/wiki/API#wiki-test.typeof) — определяет тип переданного ему значения.
Он умеет различать: *Array*, *Boolean*, *Date*, *Error* (*EvalError*, *RangeError*, *ReferenceError*, *SyntaxError*, *TypeError*, *UriError*), *Function*, *NaN* и *Number*, *Object*, *RegExp*, *String*, *Window*, *HTML*, *NodeList*. А ещё он пустую переменную определит как *'undefined'* но в отличие от стандартного **typeof** не сможет получить в качестве аргумента не объявленную переменную. За то ответит *'undefined'* на несуществующее свойство объявленного и непустого объекта. Но это уже специфика языка.
Если мы обновим страницу, то в консоли появится строка:
Теперь взглянем на метод **test.trace()**.
```
(function firstFunction() {
(function secondFunction() {
(function lastFunction() {
console.log(test.trace());
})();
})();
})();
```
[test.trace()](https://github.com/titulus/testit/wiki/API#wiki-test.trace) — возвращает список *(собранный в строки разделённые "\n")* строк кода, которые были выполнены для вызова этого метода.
На самом деле, это не настоящий **trace()** *(которого, к сожалению, нету в JavaScript)*, потому что из него были вырезаны все упоминания о вызовах внутри библиотеки.
К выводу в консоль теперь добавится:
Здесь и далее не значащие части вывода консоли на скриншотах будут опускаться, что бы не увеличивать бессмысленно размер изображений.
### Давайте приступим к тестам.
Для начала создадим объект для тестов, переменную с целочисленным значением и пустую переменную.
```
var Family = {
name: "Desiderio",
pet: {
type: "dog",
name: "google"
},
members: [
{
name: "Titulus",
age: 23
},
{
name: "Dude",
age: Infinity
}
]
}
var myIQ = 100;
var Nothing;
```
Думаю вопросов касательно этого кода возникнуть не должно.
Поехали дальше.
Следующий шаг — первый тест.
### Тест на не-ложность.
Тут всё как и раньше.
```
test.it("hello world");
test.done();
```
[test.it( value )](https://github.com/titulus/testit/wiki/API#wiki-test.it-nonfalse) — создаёт новый тест, проверяя *value* на не-ложность.
[test.done()](https://github.com/titulus/testit/wiki/API#wiki-test.done) — завершает тесты и выводит результат в консоль.
Далее будет предполагаться, что **test.done()** идёт последней строкой нашего кода. В примерах я буду его опускать.
В консоли мы видим:
Где:
* **root** — имя группы нулевого уровня.
* pass — статус группы, означающий что все тесты/группы в ней пройдены успешно.
* 1/0/0 — количество соответственно пройденных/проваленных/ошибочных тестов/групп.
* (9 ms) — время в миллисекундах потраченное на тесты.
Если раскрыть эту группу, то можно увидеть список тестов/групп в ней.
Прежде чем разбирать наш единственный тест, давайте раскроем и его:
И так:
* pass — статус теста означающий что он пройден
* argument is not false — описание типа теста и его результата
* *[«hello world»]* — массив аргументов переданных тесту
### Попробуем воспользоваться механизмом [цепочности](https://github.com/titulus/testit/wiki/API#chaining).
Самый элементарный случай — добавление комментария:
```
test.it(2+2==5)
.comment("i badly taught algebra at school");
```
[.comment( text )](https://github.com/titulus/testit/wiki/API#wiki-.comment) — добавляет комментарий к тесту/группе, в чьей цепочке он был вызван. При этом продолжая цепочку, но об этом чуть позже.
Этот код можно было бы записать и в виде:
```
test.it(2+2==5).comment("i badly taught algebra at school");
```
Но, для случаев с более длинными цепочками, запись в столбик удобнее и нагляднее.
Теперь *root* (раскрытый автоматически, потому что содержит непройденный тест) выглядит так:
В счётчиках в первой строке можно заметить увеличение второго числа с 0 до 1, что означает увеличение колличества проваленных тестов/групп.
Обратим своё внимание на, раскрытый по умолчанию *(потому что не был пройден)*, тест.
Он отличается от предыдущего только статусом fail — означающим что тест провален, и комментарием «i badly taught algebra at school», который мы добавили.
Очевидно что в **test.it( value )** можно передавать не только строки, но и переменные, и выражения, и вызовы функций и т.п. Впринципе, что бы мы не передали, сначала будет выполненно, получен результат, а этот результат уже и пойдёт в тест. Таков уж JavaScript.
Проверим только что сказанное. Протестируем выражение:
```
test.it(Infinity>Infinity-1)
.comment("philosophically is not it?");
```
Можете подумать об этом выражении за рюмочкой кофе, мы здесь для другого собрались. Результат теста выглядит как и результат предыдущего, что очевидно.
Пока не мы не ушли в дебри цепочных вызовов, *а мы обязательно уйдём,* посмотрим на другой вариант теста **test.it()**.
### Тест на равенство
Давайте сравним, объявленную ранее переменную с другим значением.
```
test.it(myIQ,"genious")
.comment("is I'm genious?");
test.it(myIQ,(1+10)*12 - 34 + 5*5*5 - 123)
.comment("check my IQ to be a normal");
```
[test.it( value1, value2 )](https://github.com/titulus/testit/wiki/API#wiki-test.it-equality) — проверяет равенство двух переданных ей значений.
В консоли эти 2 теста будут выглядеть следующим образом:
Ничего необычного, но стоит обратить внимание на описание первого (проваленного) теста. "**arguments has different types**" — в этом тексте содержится подсказка, поясняющая нам почему тест был провален — переданные аргументы разного типа.
А теперь попробуем более сложные цепи.
Давайте выполним какое-нибудь действие, в зависимости от результата теста.
```
if (test.it(Family)
.comment("Is Family exist? Is it not empty?")
.result()) {
console.info("by if: ","Yep! Here it is!");
} else {
console.warn("by if: ","ALARM! there are no Family");
}
```
[.result()](https://github.com/titulus/testit/wiki/API#wiki-.result) — завершает цепочку и возвращает результат теста.
В этом коде, мы проверяем *Family* на не-ложность, и в зависимости от результата выводим в консоль разные фразы.
Вывод консоли теперь выглядит так:
Правда такую задачу предпочтительнее выполнять при помощи другого цепочного вызова:
```
test.it(Nothing)
.comment("Is Nothing exist? Is it not empty?")
.callback(
function(){console.info("by callback: ","Yep! Here it is!");}
,function(){console.warn("by callback: ","ALARM! there are no Nothing");});
```
[.callback( function(){ /\* funcIfpass \*/}[, function(){ /\* funcIffail \*/}[, function(){ /\* funcIferror \*/}]])](https://github.com/titulus/testit/wiki/API#wiki-.callback) — выполняет одну из трёх функций, в зависимости от результата прохождения теста или группы. При этом продолжая цепочку.
В результате в консоли мы видим:
Эта конструкция предпочтительней, потому что не завершает цепочку.
### Группы
Теперь создадим первую группу.
```
test.group("Empty group",function(){});
```
[test.group( name, function(){… } )](https://github.com/titulus/testit/wiki/API#wiki-test.group-new) — создаёт новую группу *или обращается к уже существующей*, и заполняет её тестами, находящимися в функции, переданной вторым аргументом.
Но так как тестов переданно ен было, группа создаётся пустой, но со статусом pass — потому как в ней нету ниодного проваленного теста.
Перед тем как сделать скриншот, я расскрыл группу — это видно по повороту стрелки вниз, и двум серым пикселам, означающим её конец. Но так как группа пустая, она выглядит практически как закрытая.
Что ж. Приступим к более осмысленным действиям. Создадим группу с двумя тестами внутри и комментарием.
```
test.group('Family tests',function(){
test.it(Family.name,"Zukerberg")
.comment("Are we test Zukerberg's family?");
test.it(Family.name,"Desiderio")
.comment("Or Desiderio's?");
}).comment("unite!");
```
Вот видите — ничего сложного!
Тут стоит лишь обратить внимание на добавленный нами комментарий **unite!** — в заголовке группы.
А теперь провернём финт ушами, и добавим несколько тестов в уже созданную группу. И не просто тестов, а тестов которые инициируют новые тесты в зависимости от своего результата.
Добавим следующий код:
```
test.group("Family tests",function(){
test.it(Family.pet)
.comment("Do we have a pet?")
.callback(function(){
// I add test in your test, so you can test while you testing
test.it(Family.pet,{type:"dog", name:"google"})
.comment("Is it right pet?");
});
test.it(Family.house)
.comment("Do we have a House?")
.callback(function(){
// next test will not be executed
test.it(Family.pet,{type:"Huge", color:"green"})
.comment("Is it right House?");
});
});
```
Учитывая прошлые 2 теста в этой группе и, описанные только что, ещё 4 теста, всего их будет = 5(sic!). Можете проверить на калькуляторе.
Вон видите в заголовке? 3 пройденных, 2 проваленных — всего 5.
### Новые тесты
Пора взглянуть на парочку необычных тестов. Для начала в группе **«here comes strange tests»** создадим следующие два теста:
```
test.them([Family.pet, Family.members])
.comment("There must be memebers with pet, to call it a 'Family'");
test.types([Family.pet.name, Family.name],"string")
.comment("Is names are string type");
```
[test.them( values )](https://github.com/titulus/testit/wiki/API#wiki-test.them) — аналог **test.it( value )**, только в качестве первого аргумента берёт массив, в котором уже проверяет элементы на не-ложность.
[test.types( values [, type] )](https://github.com/titulus/testit/wiki/API#wiki-test.types) — как и **test.them( values )** проверяет элементы массива, переданного первым аргументом. Но проверяет их на совпадение типов, а если передан второй аргумент **type** — то берёт этот тип в качестве образца.
У этого теста есть упрощённый аналог, но о нём чуть-чуть позже.
Вот так они выглядят в консоли:
Я раскрыл тесты вместе с их массивами аргументов для наглядности, но что-то мне кажется, наглядность от этого только уменьшалась.
А вот вам и ещё одна цепочная магия:
```
var numberOfMembers = test.type(Family.members,"Array")
.comment("Is it a several members, nor a single member?")
.arguments()[0].length;
test.it(numberOfMembers>5)
.comment("Is it big family?");
```
[.arguments()](https://github.com/titulus/testit/wiki/API#wiki-.arguments) — завершает цепочку вызовов и возвращает аргументы переданные в тест (**не в группу!**).
Поясню — первый тест, проверил значение **Family.members** на не ложность. Так как это массив из двух элементов — тест пройден.
*arguments()[0]* == *Family.members*. Следовательно в переменную **numberOfMembers** заносится количество элементов массива **Family.members** то бишь 2. Второй тест проваливается из-за того что 2 не больше 5.
### Вложенность
Вы ведь ещё помните, что мы находимся в группе "**here comes strange tests**"?
Добавим сюда ещё одну группу, и сразу воспользуемся конструкцией **for** для того что бы создать несколько однотипных тестов.
```
test.group("Members age",function(){
for (i=0;i25)
.comment("Is "+Family.members[i].name+" older then 25?");
}
});
```
Теперь эта новая группа "**Members age**" располагается в старой "**here comes strange tests**".
### Ошибки
Добавим в эту же группу "**Members age**" ещё один тест:
```
test.it()
.comment("yep, here is error");
```
Такой код приведёт к ошибке, потому как **test.it()** ожидает получить от 1 до 2 аргументов.
В заголовке ошибки:
* RangeError — тип ощибки
* at least one argument expected — описание, помогающее понять причину её возникновения.
Затем идёт результат **test.trace()** что бы легче было найти её в коде. И сам объект ошибки, в данном случае **RangeError** — это если кому-то захочется покопаться в нём глубже.
### Ссылки на группы
Вернёмся на уровень **root**.
На всякий случай напомню, что группа "**here comes strange tests**" сейчас выглядит так:
В ней есть ещё одна группа "**Members age**". Вот в неё тест мы сейчас и добавим.
```
test.group("here comes strange tests").group("Members age",function(){
test.it("bye")
.comment("good");
});
```
[test.group( name )](https://github.com/titulus/testit/wiki/API#wiki-test.group-link) — возвращает ссылку на группу, после чего её можно использовать как начало цепи, для добавления новой группы тестов или для добавления тестов в уже существующую подгруппу.
Вот последнее мы только что и сделали. Теперь в консоли видим:
И на последок, для закрепления всего выше сказанного:
**полный листинг со всем выводом в консоль**
```
console.log( // look how do test.typeof() work
test.typeof(1)
,test.typeof("text")
,test.typeof([1,2,3])
,test.typeof({a:1,b:2})
,test.typeof()
,test.typeof(document)
,test.typeof(document.getElementsByTagName("body"))
,test.typeof(window)
,test.typeof(/yes it is RegExp/));
(function firstFunction() { // look how do test.trace() work
(function secondFunction() {
(function lastFunction() {
console.log(test.trace());
})();
})();
})();
var Family = { // Here some complex object
name: "Desiderio",
pet: {
type: "dog",
name: "google"
},
members: [
{
name: "Titulus",
age: 23
},
{
name: "Dude",
age: Infinity
}
]
}
var myIQ = 100; // and value
var Nothing; // and empty value
test.it("hello world"); // Let"s add some simple tests
test.it(2+2==5).comment("i badly taught algebra at school"); // with comment
test.it(Infinity>Infinity-1).comment("philosophically is not it?"); // with expression
// check equalence
test.it(myIQ,"genious").comment("is I'm genious?");
test.it(myIQ,(1+10)*12 - 34 + 5*5*5 - 123).comment("check my IQ to be a normal");
// try some chain staff
if (test.it(Family).comment("Is Family exist? Is it not empty?").result()) {
console.info("by if: ","Yep! Here it is!");
} else {
console.warn("by if: ","ALARM! there are no Family");
}
// do it again in better way
test.it(Nothing).comment("Is Nothing exist? Is it not empty?").callback(
function(){console.info("by callback: ","Yep! Here it is!");}
,function(){console.warn("by callback: ","ALARM! there are no Nothing");});
test.group("Empty group",function(){}); // try to make a group
test.group('Family tests',function(){ // let's unite it!
test.it(Family.name,"Zukerberg").comment("Are we test Zukerberg's family?");
test.it(Family.name,"Desiderio").comment("Or Desiderio's?");
}).comment("unite!");
test.group("Family tests",function(){ // and add some test after
test.it(Family.pet).comment("Do we have a pet?")
.callback(function(){
// I add test in your test, so you can test while you testing
test.it(Family.pet,{type:"dog", name:"google"}).comment("Is it right pet?");
});
test.it(Family.house).comment("Do we have a House?")
.callback(function(){
// next test will not be executed
test.it(Family.pet,{type:"Huge", color:"green"}).comment("Is it right House?");
});
});
test.group("here comes strange tests",function(){
// test existance of most important Family properties
test.them([Family.pet, Family.members])
.comment("There must be memebers with pet, to call it a 'Family'");
// test types of names
test.types([Family.pet.name, Family.name],"string")
.comment("Is names are string type");
// here some magic
var numberOfMembers = test.type(Family.members,"Array")
.comment("Is it a several members, nor a single member?")
.arguments()[0].length;
test.it(numberOfMembers>5).comment("Is it big family?");
// So if we know how many members there, lets check their age
test.group("Members age",function(){
for (i=0;i25)
.comment("Is "+Family.members[i].name+" older then 25?");
}
test.it().comment("yep, here is error"); // add some error to see the trace
});
});
// add final test deep in group
test.group("here comes strange tests").group("Members age",function(){
test.it("bye").comment("good");
});
test.done();
```
### root
Ах да. **test.root** всё ещё лежит на своём месте. Его всё также можно исползовать для создания новых вариантов отображения результатов. Он слегка упростился (у групп счётчики перестали разделять группы и тесты).
Пустой **root** выглядит так:
```
{
"type": "group",
"name": "root",
"time": 0,
"result": {
"pass": 0,
"fail": 0,
"error": 0,
"total": 0
},
"stack": []
}
```
### Заключение
Очень хотелось бы поблагодарить:
* [camelos](http://habrahabr.ru/users/camelos/) и [zorro1211](http://habrahabr.ru/users/zorro1211/) за идеи цепочных вызовов
* [camelos](http://habrahabr.ru/users/camelos/) отдельно за идею **.callback**
* [Anonym](http://habrahabr.ru/users/anonym/) за идею доступа к группе извне. в том числе и из других файлов.
Всё ещё остались минусы приведённые в прошлой стате. Но уже есть весьма интересные мысли по методам их решений.
[Сайт](http://titulus.github.io/testit/) на котором можно увидеть весь приведённый выше код в действии, [GitHub](https://github.com/titulus/testit), [Wiki](https://github.com/titulus/testit/wiki) | https://habr.com/ru/post/189216/ | null | ru | null |
# Восстанавливаем старые часы «Электроника-7»
Доброго времени суток, уважаемые хабражители!
Началась эта история так. Во время работы на объекте, разместившимся в здании бывшего завода (кажется, металлоконструкций) с длинным названием (и, конечно же, имени очередного великого лидера партии) я увидел в куче хлама, предназначавшейся на выброс, одну вещь. Каковая вещь ударила по мне страшным приступом ностальгии, ибо точно такая же висела в холле СКБ (с не менее длинным и многосложным названием, чем вышеупомянутый завод), где работала когда-то моя мама, и где прошло немало времени из моего детства. Встречайте — часы «Электроника 7-06».
Конечно же, я не мог устоять от соблазна восстановить (а может быть, и доработать?) их. Кому интересен процесс, а равно и конечный результат — прошу под кат (осторожно, некоторое количество схем и фото!).
1. Немного теории
=================
Схема часов свободно доступна в интернете. Элементной базой является 176 серия микросхем. Индикаторы — газоразрядные типа ИВ-26. Ниже представлен оригинал схемы.
[](https://habrastorage.org/files/4b2/505/a48/4b2505a4808140919f09fcc590b3a912.png)
Рис. 1. Оригинальная схема, часть 1
[](https://habrastorage.org/files/280/1e6/06e/2801e606e7374f3395747e37dec08c32.png)
Рис. 2. Оригинальная схема, часть 2
2. Начнем-с
===========
Часы были извлечены из кучи мусора, отвезены домой и препарированы. После очистки от мусора, накопившегося внутри, моим глазам предстало вот что.
[](http://habrastorage.org/files/1f4/441/d9a/1f4441d9a2d147aca8163571e52e046c.JPG)
[](http://habrastorage.org/files/55b/98e/12f/55b98e12ffcb4aceb3eaa4eaae550b05.JPG)
[](http://habrastorage.org/files/86e/109/c8b/86e109c8bcfd43839162bc634bb7258a.JPG)
[](http://habrastorage.org/files/465/faf/240/465faf240b424281a06fc2ae11286fe2.JPG)
[](http://habrastorage.org/files/ca5/513/6e3/ca55136e3fe540b7a760f314aa6b79b4.JPG)
Включаем. В принципе, всё работает. Но: индикаторы выгорели. Достать такие же ИВ-26 уже негде. Гугл дает множество ссылок, повествующих нам, как заменить эти ИВ-26 на светодиоды, а то и на готовые семисегментные сборки. Да только вот же незадача — это выглядит уже совсем не так… осовремененно и оттого попсово выглядит, я бы сказал. Поэтому моя задача номер один: восстановить индикаторы на светодиодах, максимально сохранив при этом внешний вид.
3. Табло
========
При взгляде на расчески из проводов, ведущие к табло, а также на схемы этих табло с сумматорами на диодах, мне становится несколько неуютно. Сложновато в наладке, запросто можно провода перепутать. Да и слабоваты выходы 176-й серии, чтобы напрямую светодиодами управлять. Плюс хотелось бы иметь возможность регулировки яркости индикации, желательно по сценарию тоже — ночью высокая яркость не совсем уместна дома. Стабильность опорного генератора на 25-тилетней давности компонентах мне тоже никто не гарантирует. Прикинув так и этак, я решил видоизменить схему полностью.
Каждый индикатор — светодиодная матрица 7 х 11, так выходит по количеству точек на оригинальных ИВ-26. Управляет ей хорошо всем известная ATtiny2313. Она же хранит в себе образы символов для отображения, таблицу знакогенератора, говоря иначе. Даже без всяких оптимизаций по 11 байт на символ в нее сотня символов точно влезет — значит, потенциально можно не только цифры писать на табло. И таких матриц у меня будет 4. А что отображать, они пусть получают по UART. Ну а собственно что будет считать время и отправлять по этому интерфейсу данные для табло — это позже. Я подумаю об этом позже (с). Зато к каждой матрице подходит всего 3 провода — GND, +5V и Data. Я посчитал, что однонаправленной линии передачи для данной задачи вполне достаточно.
Индикация динамическая, для выбора строк используется узел на регистрах 74HC595, а для выбора столбца — дешифратор 74HC238. Конструкция AVR + 74HC595 хорошо описана и интереса не представляет. К сожалению, SPI у tiny2313 какой-то порезанный, поэтому загрузка данных в регистры выполняется программно. Плюс к тому при попытке использовать SPI возникли проблемы с разводкой платы, поэтому я отказался от этой идеи. Дешифратор подключен через транзисторную сборку ULN2003 для увеличения мощности.
Изначально я планировал использовать для регулировки яркости светодиодов дополнительный транзистор, управляемый посредством аппаратного ШИМа на таймере T0, но возникла проблема: ШИМ, накладываясь на динамическую индикацию (их частоты, конечно, не совпадали), порождал неприятное мерцание светодиодов. Поэтому ШИМ программный, а реализован он с помощью дешифратора выбора столбца. Как видно, индикатор-то имеет 7 столбцов, а выходов у дешифратора 8, и последний выход не подключен. Выбирая его, мы гасим всю матрицу.
Ток светодиодов ограничен сопротивлениями. Исходя из документации на примененные LED-5213-PGC-6cd, на них падает 3 — 3,5В при токе 20 мА, примем в среднем 3,2В. Плюс еще 1В падения на ULN2003. Итого (5 — 3,2 — 1) / 0,02 = 40 Ом. Я взял на 39 Ом.
Переключателями SA1 задается адрес платы. Такой подход позволяет сделать все 4 платы одинаковыми.
К сожалению, металлизацию отверстий в домашних условиях я пока не осилил. Поэтому плата однослойная и количество перемычек на ней может ужаснуть, хоть и сводилось к минимуму всему усилиями.
Принципиальная схема приведена ниже.
[](https://habrastorage.org/files/a1e/6bf/bd0/a1e6bfbd05c348e1b0bf58b0732be7b1.GIF)
Рис. 3. Принципиальная схема индикатора
[](https://habrastorage.org/files/07d/e81/554/07de81554b37438dbd8a04dacfcb7e5c.jpg)
А вот фото платы на одном из этапов изготовления (только что нанесен и проявлен фоторезист).
Протокол обмена очень простой:
Первый байт всегда FF, это заголовок пакета.
Второй байт — адрес платы.
Третий байт — данные для отображения, код символа согласно ASCII.
Четвертый — желаемая яркость в диапазоне 00 — FE.
В конце — младшие 8 бит от суммы всех байт пакета, проверка целостности. Если сумма равна FF, заменяем на FE. Пример пакета:
FF 01 32 80 B2 — вывести символ «2» на плате с адресом 1, яркость — половина от максимума.
В процессе написания кода мне также пришла идея сделать так, что плата индикации в момент старта до получения первых данных отображает свой адрес. Оказалось удобно при отладке.
4. Блок питания
===============
Родной блок содержит в себе трансформатор с двумя обмотками: одна выдает 22В, которые применялись для питания анодов индикаторов, и 3,8В для питания их накалов. Конденсаторы, конечно, свою емкость потеряли, к тому же нам потребуются +5В. Значит, схему придется пересмотреть. Кроме того, предусматривается возможность питать логику от 6 батареек по 1,5В, чтобы не сбивалось время при обесточивании. Батарейки — это как-то несерьезно, требуют регулярной замены, так что я переделал этот узел на работу со стандартным аккумулятором 6В, 4.5 А\*ч.
Однако ж, 22 \* 1,41 = 31В. Нда, обычной 7805 тут не обойдешься, разве что мы хотим прикрутить сюда еще и функцию комнатного обогревателя. Непродолжительный гуглинг, и на помощь приходит LM2576-5.0 — интегральный импульсный стабилизатор с выходным током до 3А, которая даже нашлась в местном магазине радиодеталей.
Поиск, где бы мне ~~спереть~~ безвозмездно позаимствовать схему зарядного устройства с целью уменьшения количества созданных велосипедов, привел меня [сюда](http://www.simbike.ru/view_post.php?id=10) (вообще, сайт посвящен именно велосипедам, что в контексте фразы несколько улыбает). Однако, схемка-то на линейных стабилизаторах… впрочем, существует версия вышеупомянутой LM2576 с перестраиваемым выходным напряжением. Фактически, нужно сваять источник с ограничением вида «выходное напряжение примерно 6 — 14В (с подстройкой, чтобы можно было и на 12В аккумулятор подцепить), выходной ток не выше 0,5А (тоже с подстройкой)». После некоторых раздумий получилось нечто такое.
[](https://habrastorage.org/files/c63/fb4/eba/c63fb4ebad3c43f5a5e9d6dd7be119ad.GIF)
Рис. 4. Схема источника питания
Переключение режима «зарядка / работа от аккумулятора» производится обычным механическим реле с обмоткой на 220В, подключенной параллельно первичной обмотке силового трансформатора. Несколько наивно, но, как ни парадоксально, вполне работает.
5. Сердце системы
=================
Вот и настало то самое «позже», в котором я обещал себе подумать о том, что же будет собственно время считать, и управлять индикаторами. А еще лучше, если оно еще и синхронизировать его будет с мировым. По NTP, например. Или DAYTIME. Благо, что Wi-Fi в доме имеется. И самое главное, да. Чуть не забыл. В этих часах таки остался один родной элемент индикации, который такой трогательный, что я счел кощунственным его менять. Ибо воссоздать такое же не смогу, да и рабочий он вполне. Мигающая секундная точка на индикаторе ИВ-4! Вот еще ей надо мигать.
Я долго ковырял форумы на предмет сопряжения AVR и Wi-Fi, смотрел, как это делали на Arduino… но цена меня удручает. И тут мой взгляд упал на купленную с целью изучения с последующим созданием торрентокачалки «малинку», лежащую на полке…
Нет, ну это даже не пушкой по воробьям. Это просто удар главного калибра Звезды Смерти с целью уничтожения злых бактерий под ободком унитаза. А с другой стороны — не всё ли равно, где эта торрентокачалка будет стоять? Места под USB-HDD в корпусе часов более чем достаточно. Кроме того, мой опыт работы с \*nix-системами пока не очень значителен — отличный повод расширить кругозор. Примерно эти мысли пролетели у меня в голове, и судьба малинки была решена. Ну пусть тогда еще уличную температуру показывает, что-ли… раз уж такими мощностями разжился. Да и знакогенератор табло теперь позволяет плюсы-минусы рисовать.
Как прикрутить к rPi часы реального времени, а также как ее вообще включить, провести начальную настройку, установить туда торрент-клиент — сказано много раз до меня. Впрочем, некоторое количество ссылок, показавшихся мне полезными, я все же приведу ниже.
Уличную температуру я беру с Рамблера. Выбор обусловлен предпочтениями моей второй половинки.
Итак, поэтапно все действия с «малинкой»:
Вот [тут](http://www.raspberrypi.org/forums/viewtopic.php?p=462982#p462982) читаем, как подружить ее с Wi-Fi-адаптером TP-Link TL-WN725N.
А вот [тут](http://www.armlinux.ru/%D0%BD%D0%B0%D1%81%D1%82%D1%80%D0%B0%D0%B8%D0%B2%D0%B0%D0%B5%D0%BC-vnc/) — как установить VNC-сервер, может пригодиться.
[Здесь](http://habrahabr.ru/post/149890/) доходчиво расписано, как поднять Samba.
А вот [тут](http://www.raspberry-projects.com/pi/programming-in-c/uart-serial-port/using-the-uart), как работать со встроенным UART.
Вот такой скрипт синхронизирует время с мировым с помощью NTP.
**timesync.sh**
```
#!/bin/bash
sudo service ntp stop
sleep 5
sudo ntpdate time.nist.gov time.windows.com
sleep 5
sudo service ntp start
```
Этот скрипт читает с Рамблера погоду, складывая принятые данные в файл
**getweather.sh**
```
##!/bin/bash
URL="http://api.rambler.ru/weather/informer?content_type=xml"
FILENAME=/home/pi/clock/weather.dat
WEATHER=$(curl ${URL} | grep -o -E "()[\+\-]?[0-9]{1,2}(<\/temp>)" | grep -o -E "[\+\-]?[0-9]{1,2}")
if [ -z ${WEATHER} ]
then
echo "Get weather failed!"
else
echo -ne " " > ${FILENAME}
echo -ne $(printf "%+03d" ${WEATHER}) >> ${FILENAME}
fi
```
Основной скрипт, передает данные через UART для отображения:
**send.sh**
```
#!/bin/bash
DATAPATH=/home/pi/clock/weather.dat
declare -i LOW_BRIGHT=5
declare -i HIGH_BRIGHT=100
send_data ()
{
DATA=$1
LEN=${#DATA}
stty -F /dev/ttyAMA0 cs8 -cstopb raw speed 19200 > /dev/null
for((i=0; i<$LEN; i++));
do
ADDRESS=$(printf "%d" $(($i+1)))
CHAR=$(printf "%d" ${DATA:$i:1})
if [ "$CHAR" = "0" ]
then
CHAR=32
fi
HOUR=$(date | cut -c 12-13)
if (("$HOUR" > "20")) || (("$HOUR" < "7"))
then
BRIGHTNESS=$(printf "%d" $LOW_BRIGHT)
else
BRIGHTNESS=$(printf "%d" $HIGH_BRIGHT)
fi
CHECKSUM=$((($ADDRESS+$CHAR+$BRIGHTNESS-1)%256))
if [ "$CHECKSUM" = "255" ]
then
CHECKSUM=254
fi
ADDRESS=$(printf "%o" $ADDRESS)
CHAR=$(printf "%o" $CHAR)
BRIGHTNESS=$(printf "%o" $BRIGHTNESS)
CHECKSUM=$(printf "%o" $CHECKSUM)
MESSAGE="\0377\0$ADDRESS\0$CHAR\0$BRIGHTNESS\0$CHECKSUM"
echo -ne "$MESSAGE$MESSAGE" > /dev/ttyAMA0
done
}
if [ "$1" = "time" ]
then
HOUR=$(date | cut -c 12-13)
MINUTE=$(date | cut -c 15-16)
TIME="${HOUR}${MINUTE}"
send_data $TIME
exit 0
fi
if [ "$1" = "weather" ]
then
WEATHER=$(cat ${DATAPATH})
if [ -z ${WEATHER} ]
then
echo "No weather info found"
exit 0
fi
send_data "$WEATHER"
exit 0
fi
if [ "$1" = "startup" ]
then
send_data "HELO"
sleep 5
send_data "HABR"
sleep 5
send_data " "
exit 0
fi
echo "Usage: send.sh time | weather | startup"
exit 0
```
И — да. Точкой секундной мигаем.
**blink.sh**
```
#!/bin/bash
sudo echo "25" > /sys/class/gpio/export
sudo echo "out" > /sys/class/gpio/gpio25/direction
while true
do
echo "1" > /sys/class/gpio/gpio25/value
sleep 0.5
echo "0" > /sys/class/gpio/gpio25/value
sleep 0.5
done
```
Теперь добавим все это хозяйство в cron:
```
# m h dom mon dow command
0/15 * * * * /home/pi/clock/timesync.sh
0/15 * * * * /home/pi/clock/getweather.sh
* * * * * sleep 00; /home/pi/clock/send.sh time
* * * * * sleep 10; /home/pi/clock/send.sh weather
* * * * * sleep 15; /home/pi/clock/send.sh time
* * * * * sleep 25; /home/pi/clock/send.sh weather
* * * * * sleep 30; /home/pi/clock/send.sh time
* * * * * sleep 40; /home/pi/clock/send.sh weather
* * * * * sleep 45; /home/pi/clock/send.sh time
* * * * * sleep 55; /home/pi/clock/send.sh weather
```
И… и всё. Вешаем на стену, наслаждаемся, ностальгируем. Фото процесса (кликабельно), а также традиционное приветствие жителям Хабра можно увидеть ниже.
**Внимание! Автору статьи при рождении вырезали художественное чувство, как будущему инженеру не нужное. Ценителям незаваленных горизонтов, композиции кадра и всякого прочего баланса белого просьба на этом месте прекратить чтение и перейти сразу к комментариям, во избежание получения серьезных душевных травм.**
[](http://habrastorage.org/files/30a/7e9/f66/30a7e9f66497477fa446b2184e58e81e.JPG)
Крепление плат индикации на шасси. Рядом лежит плата блока питания.
[](http://habrastorage.org/files/936/15c/f49/93615cf4990b42b1ad064f3933a668de.JPG)
Красим проржавевшие задние крышки.
[](http://habrastorage.org/files/24a/d3e/730/24ad3e73060f4153a26369184d471f70.JPG)
Первое включение в собранном виде. Платы отображают свои адреса.
[](http://habrastorage.org/files/9e8/9bc/909/9e89bc9098f140669b5b8eae604f4092.JPG)
Все элементы установлены на шасси.
[](http://habrastorage.org/files/cf1/412/ab8/cf1412ab86e44298bf5c79b955cb0243.JPG)
Покрупнее, та же стадия.
[](http://habrastorage.org/files/30b/5dc/a88/30b5dca881154b399dfdec0af10e2c6b.JPG)
Упаковываем в корпус.
И — логическое завершение!
==========================
[](http://habrastorage.org/files/3cd/41e/89e/3cd41e89e3314dbd9d23b6e79c139732.JPG)
Время.
[](http://habrastorage.org/files/53e/3b8/e8b/53e3b8e8b8004235851bc72b936d6fcc.JPG)
Температура за бортом.
[](http://habrastorage.org/files/1c5/7c1/153/1c57c115304c46d1947acb3a10123996.JPG)
[](http://habrastorage.org/files/63a/d6d/a39/63ad6da392eb4554b205519b6ef3729b.JPG)
Все схемы, печатные платы и прошивки можно взять [здесь](https://drive.google.com/file/d/1mZfSgoKNqULgxlxcnEmS4j8f5JU5aEIx/view?usp=sharing). | https://habr.com/ru/post/242263/ | null | ru | null |
# Small Basic — для тех, кто только начинает
Всем привет, а особенный привет тем, кто хочет начать программировать, и не знает на чем начать и какую среду разработки предпочесть.
Сегодня я расскажу о такой замечательной вещи как **Small Basic.**
И все же, для кого Small Basic? Логично — для тех кто хочет начать программировать. Для того что бы начать программировать опыт совершенно не нужен, но если есть — это даже лучше.
Весьма не плохо было-бы, если попутно, на уроках информатики старших классов школы или студентов, помимо паскаля и турбо-бейсика выделяли часы на Small Basic, было бы полезно.
#### Первый запуск.
Очень хорошее окошко, ничего лишнего.
#### Приятные моменты.
Вот за это отдельное спасибо, это очень удобная вещь. Управление стрелками, русское описание. Ваши назначенные переменные так-же поддерживаются. Процесс становиться очень приятным.
#### Аппендикс.
На сайте microsoft, и при установке так же ставиться начальная документация, которая очень понятным языком познакомит вас с Small Basic и самим процессом программирования в целом.
К сожалению у SB не очень большие возможности. Но это позволяет ученику, после достаточного усвоения SB перейти на более профессиональный уровень.
SB поддерживает подключение внешних библиотек, которые значительно расширяют возможности.
Для русских есть официальное русскоязычное сообщество начинающих программистов. Там-же доступна версия 0.8
Преимущества очевидны, если для всеми известного «первого приложения» Hello Word в Small Basic'е достаточно:
`TextWindow.WriteLine("hello word")`
C++
`main()
{
cout << "Hello World!" << endl;
return 0;
}`
На языке pascal
`program HelloWorld(output);
begin
WriteLn('Hello World!');
end.`
Выбирать конечно Вам, но разница ощутима, хотя я никак не сравниваю C++ программирование с Small Basic, но на чем *изучать*
#### Небольшой пример, разлетающиеся шарики.
Самое интересное то, что программа всего в 15 строчек:
`For i = 1 To 100
balls[i] = Shapes.AddEllipse(10, 10)
EndFor
While "True"
For i = 1 To 100
ball = balls[i]
x = Math.GetRandomNumber(640)
y = Math.GetRandomNumber(480)
Shapes.Animate(ball, x, y, 2000)
EndFor
Program.Delay(1900)
EndWhile`
#### А теперь разберем код.
Исходный код можно поделить на 2 части.
Первая операция For — цикл, с помощью этого цикла мы зададим нашей переменной начальное и конечное значение, прирост переменной будет делаться автоматически, компьютером.
В цикл мы добавим переменную, назовем ее «balls», и внутри переменной дадим команду SB «Shapes», она позволяет добавлять, двигать и вращать фигуры, к объекту (Shapes) добавим операцию «AddEllipse» которая служит для добавления эллипса с заданной высотой и шириной. Цикл заканчиваем командой EndFor.
Во второй части кода мы опять же используем цикл, но другой конструкции. Другая конструкция необходима в том случае, если переменная счетчика-цикла не известна заранее, если цикл For выполняется столько раз, сколько мы зададим, то цикл While выполняется до тех пор, пока не выполнит условие.
В цикл While мы включаем цикл For, в котором мы создадим переменную ball равную balls[i] (i — все значения от 1 до 100).
Добавим переменные для координат x и y. Для этого воспользуемся классом Math, который предоставляет множество математических операций. К классу припишем операцию GetRandomNumber, которая дает случайное число в заданном параметре maxNumber, который в свою очередь мы укажем в скобках.
Далее опять даем команду SB «Shapes», но на этот раз приписываем операцию Animate, которая перемещает фигуру (ball) с помощью анимации на новую позицию (x,y) и поставим время анимации в секундах 2000. Заканчиваем цикл For командой EndFor.
Используем класс Program, который служит для контроля самого приложения, приписываем к нему операцию Delay, которая задерживает выполнение программы на 1900 мс. И в конце останавливаем цикл While командой EndWhile.
Запускаем программу кнопкой F5. Действия примерно такие:
Цикл Loop от 1 до 100 для переменной balls, которая рисует эллипс 10х10, конец цикла. Рисование кучи эллипсов.
Так, нарисовали эллипсы, так — программная задержка (Program.Delay (1900) мс). Цикл While, который раскидывает эллипсы по координатам x,y (которые задаются случайно, вспоминаем Math.GetRandomNumber), время анимации — 2000 мс. Ждем — повторяем. Ждем — повторяем.
Единственная проблема — это размер, размер даже такой небольшой программы 236 КБ, но это за счет того, что для запуска \*.exe — необходима dll-библиотека SmallBasicLibrary.dll, без нее размер программы всего 3кб. | https://habr.com/ru/post/87447/ | null | ru | null |
# Моделирование доходов от подписки
Если вы являетесь аналитиком данных в SaaS-компании или предприятии электронной коммерции с компонентом подписки, вас обязательно попросят проанализировать такие метрики, как отток, апгрейды и даунгрейды. Данные показатели помогают бизнесу понять состояние вашей базы подписчиков:
* Состояние вашей абонентской базы независимо от сезонности продлений (поскольку вы амортизируете доходы по месяцам).
* Источник изменения доходов: новые клиенты, апгрейды, даунгрейды, оттоки или реактивации.
* Ценность клиента, основанная на том, насколько долго данный пользователь продолжает платить вам деньги: пожизненная ценность клиента, средняя сумма контракта.
Часто такой анализ называют **анализом регулярного ежемесячного дохода (Monthly Recurring Revenue, MRR)**, и его результаты выглядят примерно так:
Иногда аналитики создают MRR-дашборд путем написания запросов на основе необработанных данных. Со временем эти запросы могут стать слишком сложными и громоздкими, а логика будет повторяться в нескольких местах. В нашем дашборде вместо этого выбирается следующая модель: [таблица](https://docs.getdbt.com/terms/table), содержащая преобразованные данные, готовые к анализу. Поэтому запросы в нашем дашборде очень просты — вот один из них для расчета количества клиентов и общего MRR за каждый месяц:
```
select
date_month,
sum(is_active::integer) as customers,
sum(mrr) as mrr,
from analytics.fct_mrr
group by 1
```
Построение дашборда на основе модели данных, вместо необработанной информации, дает ряд преимуществ:
* **Ваша бизнес-логика кодифицирована:** Каждый бизнес уникален. То, как в вашей компании определяют отток, скорее всего, будет незначительно отличаться от другой организации. Построив модель данных, содержащую эту бизнес-логику, вы сможете гарантировать, что в вашей деятельности все используют одинаковые формулировки.
* **Вам придется преобразовывать данные только в одном месте**: Скорее всего, ваши исходные данные для подписок не идеальны. Вам может понадобиться их подчистить, например, преобразовать пустые строки в значения NULL. Или вам может потребуется изменить [свойство](https://docs.getdbt.com/terms/grain) (grain) таблиц, например, преобразовать таблицу с одной записью на подписку с датами начала и окончания в таблицу в виде одной записи на текущий месяц. Выполнив эту работу в модели данных, вам не придется делать ее повторно при построении аналогичных анализов или в различных BI-инструментах.
* **Ваши предложения относительно модели данных могут быть проверены**: Создавая модели в dbt, вы можете явно указать и затем проверить любые предположения, которые вы делаете о своих данных. Например, если ваша бэкенд-команда сообщает, что клиент не может иметь две активные подписки одновременно, неплохо было бы добавить тест для подтверждения этого ([вот](https://github.com/dbt-labs/mrr-playbook/blob/master/models/schema.yml#L6) пример).
* **Бизнес-пользователи могут более простым способом изучать данные:** Если в этом месяце количество оттоков выглядело несколько выше обычного, бизнес-пользователи могут зайти в систему и написать простой SQL, чтобы понять, *какие* именно клиенты ушли, не перегружая себя сложными данными.
### Модель данных MRR
Каждая диаграмма на этом дашборде выбирается из модели данных. Эта модель содержит по одной записи на каждого клиента в месяц (часто это называют "grain" модели). Каждая запись содержит соответствующий регулярный доход за месяц (MRR), а также *категорию изменения*, которые описывают доход клиента по сравнению с прошлым месяцем.
| date\_month | customer\_id | mrr | mrr\_change | change\_category |
| --- | --- | --- | --- | --- |
| 2018-11-01 00:00:00.000 | 1 | 50 | 50 | new |
| 2018-12-01 00:00:00.000 | 1 | 50 | 0 | |
| 2019-01-01 00:00:00.000 | 1 | 50 | 0 | |
| 2019-02-01 00:00:00.000 | 1 | 0 | -50 | churn |
| 2019-03-01 00:00:00.000 | 1 | 0 | 0 | |
| 2019-04-01 00:00:00.000 | 1 | 50 | 50 | reactivation |
| 2019-05-01 00:00:00.000 | 1 | 50 | 0 | |
| 2019-06-01 00:00:00.000 | 1 | 75 | 25 | upgrade |
| 2019-07-01 00:00:00.000 | 1 | 75 | 0 | |
| 2019-08-01 00:00:00.000 | 1 | 0 | -75 | churn |
| … | … | … | … | … |
Следует рассмотреть категории изменений:
* **новый:** клиент - новый клиент, у которого не было предыдущей подпискиф;
* **отток:** в прошлом месяце клиент оплатил подписку, а в этом месяце нет. Клиент может покидать сервис много раз;
* **апгрейд:** клиент прибавил в объеме использования и теперь платит вам больше денег в месяц;
* **даунгрейд:** клиент уменьшил потребление и теперь платит вам меньше денег в месяц;
* **реактивация:** клиент, который ранее отключался, возобновил подписку.
Если вы сразу готовы окунуться в проект dbt, чтобы увидеть, как это делается, посмотрите наш образец MRR-модели [здесь](https://www.getdbt.com/mrr-playbook/#!/overviewhttps://www.getdbt.com/mrr-playbook/#!/overview). Или читайте дальше, для более детального ознакомления.
### Как смоделировать данные по доходам от подписки
#### Шаг 1: Соберите необходимые источники данных
Прежде чем преобразовывать данные, они должны быть в вашем хранилище. Данные о подписке в зависимости от вашей исходной системы могут иметь различную структуру - приведем некоторые из них:
* Таблица периодов подписки с датами начала и окончания.
* Таблица ежемесячных инвойсов, в которой сумма счета представляет собой стоимость подписки.
* Таблица событий изменения, таких как апгрейды, даунгрейды и аннулирования.
Для данного учебного пособия мы будем использовать таблицу периодов подписки.
| subscription\_id | customer\_id | start\_date | end\_date | monthly\_amount |
| --- | --- | --- | --- | --- |
| 1 | 1 | 2018-11-01 | 2019-02-01 | 50 |
| 2 | 1 | 2019-04-01 | 2019-06-01 | 50 |
| 3 | 1 | 2019-06-01 | 2019-08-01 | 75 |
Если у вас данные о подписке выглядят иначе, используйте dbt, чтобы преобразовать их в эту форму.
К счастью, наши данные также оказались абсолютно чистыми:
* Каждый клиент одновременно обладает только одной активной подпиской.
* Дата старта и окончания каждой подписки приходится на начало месяца.
Мы даже подтвердили верность наших предположений, применив некоторые [dbt-тесты](https://github.com/dbt-labs/mrr-playbook/blob/master/models/schema.yml#L4)!
#### Шаг 2: Распределите подписки по датам так, чтобы на каждого клиента приходилось по одной записи в месяц
*Требуемая техника SQL:* [*распределение дат (date spining)*](https://discourse.getdbt.com/t/finding-active-days-for-a-subscription-user-account-date-spining/265) *| Требуемая техника dbt:* [*пакеты*](https://docs.getdbt.com/docs/package-management)
Поскольку мы хотим просмотреть ежемесячные изменения, нам нужно так распределить наши подписки, чтобы иметь одну запись на месяц, а не одну запись на действующую подписку:
| date\_month | customer\_id | monthly\_amount |
| --- | --- | --- |
| 2018-11-01 | 1 | 50 |
| 2018-12-01 | 1 | 50 |
| 2019-01-01 | 1 | 50 |
| 2019-04-01 | 1 | 50 |
| 2019-05-01 | 1 | 50 |
| 2019-06-01 | 1 | 75 |
| 2019-07-01 | 1 | 75 |
| … | … | … |
Обычно мы делаем это за счет добавления к таблице "месяцев":
```
select
months.date_month,
subscriptions.customer_id,
subscriptions.subscription_id,
susbcriptions.monthly_revenue
from subscriptions
inner join months
-- all months after start date
on months.date_month >= customers.date_month_start
-- and before end date
and months.date_month <= customers.date_month_end
```
Мы используем макрос [date\_spine](https://github.com/dbt-labs/dbt-utils#date_spine-source) из [пакета](https://docs.getdbt.com/docs/package-management) dbt-utils для создания таблицы всех месяцев.
Но подождите, у нашего клиента не было подписки с февраля (2019-02-01) по апрель (2019-04-01), и мы хотим зафиксировать это как "отток" и "реактивацию"!
Для MRR-анализа важно "заполнить" все пропущенные месяцы, когда клиент не был активен. Вместо того, чтобы использовать простое распределение даты для разворачивания периода подписки, мы напишем дополнительный SQL, чтобы сначала найти все месяцы между первой и последней активностью клиента, и использовать их в качестве начальной и конечной дат.
```
with customers as (
select
customer_id,
date_trunc('month', min(start_date)) as date_month_start,
date_trunc('month', max(end_date)) as date_month_end
from subscription_periods
group by 1
),
customer_months as (
select
customers.customer_id,
months.date_month
from customers
inner join months
-- all months after start date
on months.date_month >= customers.date_month_start
-- and before end date
and months.date_month < customers.date_month_end
)
-- join the customer_months spine to MRR base model
joined as (
select
customer_months.date_month,
customer_months.customer_id,
coalesce(subscription_periods.monthly_amount, 0) as mrr
from customer_months
left join subscription_periods
on customer_months.customer_id = subscription_periods.customer_id
-- month is after a subscription start date
and customer_months.date_month >= subscription_periods.start_date
-- month is before a subscription end date
and customer_months.date_month < subscription_periods.end_date
)
...
```
#### Шаг 3: Определить первый и последний месяцы активности клиента
*Требуемая SQL-техника: Оконные функции*
Теперь, располагая всеми месяцами по клиенту, можно начать создавать некоторые поля, которые помогут нам классифицировать изменения. В частности, мы собираемся выяснить, какая запись является первым или последним месяцем для клиента.
```
...
final as (
select
date_month,
customer_id,
mrr,
mrr > 0 as is_active,
-- calculate first and last months
min(case when is_active then date_month end) over (
partition by account_id
) as first_active_month,
max(case when is_active then date_month end) over (
partition by account_id
) as last_active_month,
-- calculate if this record is the first or last month
first_active_month = date_month as is_first_month,
last_active_month = date_month as is_last_month
from joined
)
select * from final
```
#### Шаг 4: Создайте месяц "оттока"
Последняя подписка нашего клиента закончилась в июле, следовательно, в августе он должен получить отметку об оттоке. Однако у нас нет записи для августа в нашем распределении дат! Поэтому давайте создадим ее.
Для этого выберите последнюю активную запись для каждого клиента и установите значение месяца на один вперед. Заполните остальные столбцы, чтобы обозначить, что этот месяц не был активным.
```
select
dateadd(month, 1, date_month)::date as date_month,
customer_id,
0::float as mrr,
false as is_active,
first_active_month,
last_active_month,
false as is_first_month,
false as is_last_month
from mrr
where is_last_month
```
Затем, далее, объедините результаты этого запроса с другими записями, чтобы в итоге мы получили все месяцы для клиента.
```
with unioned as (
select * from {{ ref('mrr_xf') }}
union all
select * from {{ ref('mrr_last_churn') }}
)
...
```
#### Шаг 5: Используйте оконные функции для определения MRR за предыдущий месяц
Помните, что наша категория изменений относится к прошлому месяцу, поэтому мы должны использовать какие-то функции lag, чтобы выяснить, сколько клиент заплатил в прошлом месяце, а также относительное изменение курса доллара.
```
select
*,
coalesce(
lag(is_active) over (partition by customer_id order by date_month),
false
) as previous_month_is_active,
coalesce(
lag(mrr) over (partition by customer_id order by date_month),
0
) as previous_month_mrr,
mrr - previous_month_mrr as mrr_change
from unioned
```
#### Шаг 6: Добавьте категорию изменения MRR
Теперь у нас есть все необходимое для категоризации изменений! И как оказалось, SQL в итоге оказался достаточно простым и легким.
```
...
case
when is_first_month
then 'new'
when not(is_active) and previous_month_is_active
then 'churn'
when is_active and not(previous_month_is_active)
then 'reactivation'
when mrr_change > 0 then 'upgrade'
when mrr_change < 0 then 'downgrade' end as change_category
```
#### Шаг 7: Напишите тесты данных и документацию
Мы поместили это здесь в качестве заключительного шага, однако данный процесс должен быть непрерывным, пока вы разрабатываете свои модели. Всякий раз, когда вы делаете предположения о своих данных, добавьте тест, чтобы убедиться, что оно верно (как мы сделали для наших исходных данных). Нам также нравится добавлять тесты на уникальность, и утверждать, какие столбцы не должны быть нулевыми.
Данная модель должна работать как минимум со следующими тестами: Тесты на исходных данных для проверки ваших предположений, Тесты на конечной модели, чтобы убедиться, что вы не допустили ошибок в SQL, в частности: Проверьте ваш [первичный ключ](https://docs.getdbt.com/terms/primary-key), используя тест `unique` и `not_null` (это поможет выявить фанауты!). Включите тесты `not_null` для других столбцов. Кроме того, со временем вы, вероятно, добавите тесты для выявления edge кейсов, которые нельзя предугадать прямо сейчас.
Наконец, добавьте документацию, чтобы ваши стейкхолдеры понимали каждый столбец.
#### Шаг 8: Запускайте!
Ваша первая версия не будет идеальной. Как только вы получите работающий MVP, закоммитите его в свой проект dbt и создайте несколько дашбордов, чтобы ваши стейкхолдеры смогли его получить.
Проведите пользовательское тестирование со стейкхолдерами, чтобы найти все возможные проблемы и понять, достаточно ли они важны для исправления, прежде чем предоставлять дашборд широкой аудитории. Не дожидайтесь, пока ваша работа станет идеальной, прежде чем поделиться ею.
Создание собственного продукта
------------------------------
Хотя методология моделирования выручки от подписки одинакова для всех бизнесов с регулярным доходом, нюансы работы вашего предприятия могут изменить некоторые детали того, как вы это реализуете.
1. Как ваш бизнес относится к цифрам, которые не полностью совпадают с финансовыми отчетами?
2. Позволяет ли ваш бизнес пользователям приостанавливать подписку? Должно ли это отслеживаться иначе, чем отток?
3. Какова ваша базовая единица измерения (т.е. клиент, аккаунт, продукт)?
4. Существуют ли дополнительные расходы, которые полезно добавить в качестве атрибута в эту таблицу?
5. Как следует обрабатывать неполные месяцы?
6. Все ли подписки оплачиваются в один и тот же день, или они оплачиваются в разные дни для каждого клиента? Если последнее, то каково бизнес-правило для месяца, в котором признается доход?
Это может показаться быстрым решением, но основная часть работы будет проделана именно здесь. Многие из перечисленных примеров требуют компромиссов - помните, что MRR-дашборд должен помогать бизнес-пользователям в оценке *состояния* компании, а не использоваться для финансовой сверки. Хотя идеальная сверка может выглядеть как хорошая цель, но в итоге вы можете попасть в черную дыру, пытаясь выяснить, куда делись $0,02.
Мы рекомендуем вам пообщаться со стейкхолдерами, чтобы согласовать, для чего нужно и не следует использовать MRR-дашборд, а также убедиться, что вы понимаете, насколько ваш бизнес допускает незначительные несоответствия в цифрах.
### Посмотрите код
Мы создали проект dbt с некоторыми примерами данных, чтобы увидеть его в действии:
* Ознакомьтесь с примером проекта dbt [здесь](https://www.getdbt.com/mrr-playbook/#!/overview)
* Посмотреть исходный код этого проекта можно [здесь](https://github.com/dbt-labs/mrr-playbook)
---
Сегодня состоится открытое занятие по вопросам оптимизации производительности. На уроке обсудим:
— Какие проблемы с производительностью будоражат хранителей DWH;
— Существующие подходы, ключевые принципы и практики оптимизации;
— Как легко положить базу данных (конечно же, для того, чтобы так не делать).
Регистрация на урок доступна [по ссылке.](https://otus.pw/cDuv/) | https://habr.com/ru/post/704240/ | null | ru | null |
# Автоматизация загрузки только новых серий torrent-раздач (.bat + curl + aria2c) [HowTo]
За ужином интересно посмотреть что-то взрывное престольное или из позднего.
И совсем неприятно, когда стол накрыт, а ты начинаешь лихорадочно проверять по всем раздачам «а не появилось ли чего нового».
И в лучшем случае дальше будет надпись в uTorrent — «Осталось 5-10-15 минут». А стол стынет.
Так дела не делаются.
#### Задача:
* автоматическая загрузка только новых серий/выпусков torrent-раздач с rutracker и rutor
* уведомление о новых загрузках
* обойтись только Windows и сторонними консольными программами
#### Решение:
Создание файла-списка раздач с номерами последних скачанных серий (get.txt).
Запуск по расписанию bat-скрипта (get.bat), который для каждой раздачи:
1. скачивает torrent-файл,
2. проверяет «есть ли новое?»,
3. скачивает только новое (а не всю раздачу целиком),
4. обновляет номер последней серии в файле настроек (get.txt),
5. создает запись в журнале загрузок (log.txt),
6. копирует ярлык на «журнал загрузок» в «панель у пуска»
#### Результат:
Если загружена новая серия, то в панель «Ссылки» будет скопирован ярлык на журнал загрузок (иконка на картинке — желтая звезда).
Если после просмотра всего нового «звездочку» удалять руками, то будет работать примета:
«Есть звездочка — есть новое кино, нет звездочки — нового нет».
 
#### Установка:
1. Создать папку программы (например, d:\AutoTorrent) [#](#wd)
2. Скачать консольную утилиту для загрузки torrent-файлов [curl](http://curl.haxx.se/download.html) [#](#curl)
3. Скачать консольную утилиту для работы с torrent-файлами [aria2c](http://aria2.sourceforge.net/) [#](#aria)
4. Скачать bat-скрипт проверки новых серий ([get.bat](http://pastebin.com/7wyGTs7D)) [#](#bat)
5. Скорректировать настройки bat-скрипта (логин-пароль на rutracker.org) [#](#bat-pref)
6. Создать файл-список отслеживаемых раздач (get.txt) [#](#txt)
7. Создать файл-журнал (log.txt) [#](#log)
8. Создать ярлык для журнала (Новые серии.lnk) [#](#lnk)
9. Запланировать периодическое выполнение скрипта [#](#cron)
#### Подробнее:
##### 1. Папка программы
Так как помимо bat-скрипта создаются-используются еще другие файлы и папки, то удобно все это локализовать в отдельном месте.
##### 2. Утилита curl
Используется для загрузки torrent-файлов.
Чтобы скачать torrent-файл с rutracker, нужно в cookies добавить параметр `bb_dl=%torrent_id%`.
Aria2 тоже может загружать файлы, но подружить с cookies rutracker не получилось.
##### 3. Утилита aria2c
Умеет качать отдельные файлы из раздачи.
Из-за особенностей torrent, при загрузке отдельного файла, частично скачиваются соседние файлы, поэтому в папке раздачи возможно появление кусков соседних файлов.
Также оказалось, что файлы в раздачах могут идти не по порядку. Поэтому для определения новых файлов используется сортировка по названиям файлов-серий.
**Пример не упорядоченной раздачи**\*\*\* BitTorrent File Information \*\*\*
Comment: [rutracker.org/forum/viewtopic.php?t=4400218](http://rutracker.org/forum/viewtopic.php?t=4400218)
Files:
idx|path/length
===+===========================================================================
1|./Игра престолов Сезон 3 (LostFilm)/Game.of.Thrones.s03e10.avi
|609MiB (638,871,552)
---+---------------------------------------------------------------------------
2|./Игра престолов Сезон 3 (LostFilm)/Game.of.Thrones.s03e07.avi
|606MiB (635,699,200)
---+---------------------------------------------------------------------------
3|./Игра престолов Сезон 3 (LostFilm)/Game.of.Thrones.s03e08.avi
|604MiB (634,238,976)
---+---------------------------------------------------------------------------
4|./Игра престолов Сезон 3 (LostFilm)/Game.of.Thrones.s03e02.avi
|602MiB (631,814,144)
---+---------------------------------------------------------------------------
5|./Игра престолов Сезон 3 (LostFilm)/Game.of.Thrones.s03e04.avi
|602MiB (631,265,280)
---+---------------------------------------------------------------------------
6|./Игра престолов Сезон 3 (LostFilm)/Game.of.Thrones.s03e06.avi
|601MiB (631,037,952)
---+---------------------------------------------------------------------------
7|./Игра престолов Сезон 3 (LostFilm)/Game.of.Thrones.s03e03.avi
|601MiB (630,517,760)
---+---------------------------------------------------------------------------
8|./Игра престолов Сезон 3 (LostFilm)/Game.of.Thrones.s03e05.avi
|601MiB (630,310,912)
---+---------------------------------------------------------------------------
9|./Игра престолов Сезон 3 (LostFilm)/Game.of.Thrones.s03e01.avi
|598MiB (627,965,952)
---+---------------------------------------------------------------------------
10|./Игра престолов Сезон 3 (LostFilm)/Game.of.Thrones.s03e09.avi
|557MiB (584,220,672)
---+---------------------------------------------------------------------------
>>> Printing the contents of file 'rutracker\_4400218.torrent'…
##### 4. bat-скрипт get.bat
Написано на bat из спортивного интереса.
Были сложности в работе с кириллицей — с редактированием файла в блокноте, выводом на экран и записью в лог-файл. Поэтому используются многократные финты с `chcp`.
Из-за сложностей с использованием локальных переменных, появилось много подпрограмм `call - exit /b`.
В справке по `if /?` выдается оператор сравнения `EQL`, хотя `bat` на него ругается и воспринимает `EQU`. //Microsoft Windows [Version 6.1.7601]
##### 5. Настройки bat-скрипта get.bat
В тексте скрипта есть группа параметров, для которых необходимо задать актуальные значения:
* **workdir=**\_workdir — Рабочая папка, для сохранения временных файлов и загруженных torrent-файлов, создается автоматически при запуске bat-скрипта.
* **rutracker\_login=**login — Логин на трекере [rutracker.org](http://rutracker.org) .
* **rutracker\_password=**password — Пароль на трекере [rutracker.org](http://rutracker.org) .
* **video\_dir=**d:\video — Папка куда сохранять загружаемые файлы раздачи (при загрузке структура папок раздачи воссоздается как обычно).
* **lnk\_name=**«Новые серии.lnk» — Ярлык на файл журнала загрузок log.txt .
* **lnk\_dest=**«C:\Users\Admin\Favorites\Ссылки» — Путь куда копируется ярлык при загрузке нового файла. В данном примере, это путь до моей панели инструментов возле кнопки «Пуск».
##### 6. Файл-список отслеживаемых раздач (get.txt)
Формат строк:
* **код трекера** — **rutor** или **rutracker**
* **код раздачи** — число из ссылки на раздачу (напр. [rutracker.org/forum/viewtopic.php?t=3192884](http://rutracker.org/forum/viewtopic.php?t=3192884))
* **номер последней скачанной серии** — счетчик будет увеличиваться по мере загрузки новых серий
* **комментарий** — любой текст для понятности списка
Пример файла get.txt:
```
rutor 227513 24 "Теория большого взрыва" (Сезон 6)
rutracker 3799523 19 Познер
rutracker 4400218 10 Игры престолов
```
##### 7. Журнал загрузок (log.txt)
В него заносится информация о скачанных новых файлах. Новые записи добавляются сверху.
При нажатии на «звездочку», открывается этот журнал в блокноте.
**Пример содержимого**21.05.2013 21:16:57.50: [rutracker 3799523 13 Познер] ./Pozner-2\_[rutracker.org]/P2-141\_Maksim\_Kantor.avi
21.05.2013 20:07:44.66: [rutor 227513 24 «Теория большого взрыва» (Сезон 6)] ./The.Big.Bang.Theory.S06.1080p.WEB-DL.Rus.Eng.HDCLUB/The.Big.Bang.Theory.S06E24.1080p.WEB-DL.Rus.Eng.HDCLUB.mkv
21.05.2013 19:03:35.11: [rutracker 86939 46 ###для теста###] ./Брат-1, Брат-2/2001 — Брат 1/13 — Nautilus Pompilius — Люди на холме (demo).mp3
20.05.2013 19:03:35.08: [rutracker 86939 45 ###для теста###] ./Брат-1, Брат-2/2001 — Брат 1/12 — Nautilus Pompilius — Зверь.mp3
##### 8. Ярлык для журнала (.lnk)
Для оповещения о загрузке нового, используется копирование ярлыка в заметное место — «Рабочий стол», панель «Ссылки». Сам ярлык нужно создать в папке bat-скрипта. Если файла журнала еще не существует, то его нужно создать.
##### 9. Планирование задания
Для периодического исполнения bat-скрипта нужно создать задачу в планировщике задач (Панель управления\Все элементы панели управления\Администрирование\Планировщик заданий).
Из необычного — полный путь к скрипту указывается в кавычках, а рабочая папка без. Хотя в пути есть пробелы.
При каждом исполнении скрипта открывается cmd-окно.
Если кириллица не читабельна — для окна cmd нужно в свойствах выбрать шрифт Lucida.
Если нужно выполнение без cmd-окна, то можно вызывать [get.vbs](http://pastebin.com/5v0Nq1ZA).
#### Итого
Все работает без вмешательства уже больше месяца.
Для сидирования достаточно открыть скачанный torrent-файл в uTorrent.
Ссылки:
[habrahabr.ru/sandbox/51123](http://habrahabr.ru/sandbox/51123/)
[ubuntu.opentomsk.net/discussion/viewtopic.php?id=3220](https://ubuntu.opentomsk.net/discussion/viewtopic.php?id=3220)
Файлы:
**get.bat**
```
@echo off
rem
rem 13.05.2013 Tucker56 http://habrahabr.ru/post/180173/
rem
rem Загрузка новых серий/файлов из torrent-раздач
rem
rem Шаги:
rem - создание списка отслеживаемых раздач - файл get.txt (описание ниже)
rem - создание пустого файла журнала загрузок log.txt
rem - создание ярлыка (Новые серии.lnk) на журнал загрузок log.txt
rem - указание внутренних параметров (ниже в этом файле)
rem - создание периодической задачи запуска этого файла в планировщике задач
rem
rem Результат (при появлении новых файлов в отслеживаемых раздачах):
rem - файлы скачиваются в заданную папку (%video_dir%)
rem - в панели Ссылки появляется ярлык на журнал загрузок
rem
rem Особенности:
rem - если в окне выполнения программы вместо кириллицы отображается ЄЁаЁ««Ёж , нужно в свойствах окна выставить шрифт Lucida
@SetLocal EnableDelayedExpansion
rem Сохранение исходной кодировки сеанса CMD, для дальнейшей работы программы в cp1251, что нужно для возможности править этот файл в Блокноте
for /f "tokens=2 delims=:" %%a in ('chcp') do set /a chcp_cmd=%%a
rem Для восприятия кириллицы в параметрах и отображения кириллицы текстов сообщений в консоли
chcp 1251 >nul
rem Сохранение исходной кодировки, для локальных изменений (chcp)
for /f "tokens=2 delims=:" %%a in ('chcp') do set /a chcp=%%a
rem --------------------------------------------------------------
rem - ВНУТРЕННИЕ ПАРАМЕТРЫ ---------------------------------------
rem workdir=_workdir - рабочая папка, для сохранения временных файлов и загруженных torrent-файлов
rem rutracker_login=login - Логин на трекере http://rutracker.org
rem rutracker_password=password - Пароль на трекере http://rutracker.org
rem video_dir=d:\video - Папка куда сохранять загружаемые файлы раздачи (при загрузке создается путь до файла как указано в torrent-файле)
rem lnk_name="Новые серии.lnk" - Ярлык на файл журнала загрузок log.txt
rem lnk_dest="C:\Users\Admin\Favorites\Ссылки" - Путь куда копируется ярлык при загрузке нового файла
set workdir=_workdir
set rutracker_login=login
set rutracker_password=password
set video_dir=d:\Video
set lnk_name="Новые серии.lnk"
set lnk_dest="C:\Users\Admin\Favorites\Ссылки"
rem - ВНЕШНИЕ ПАРАМЕТРЫ ------------------------------------------
rem Файл get.txt - cписок отслеживаемых torrent-ов
rem -----
rem формат записи:
rem идентификатор_трекера{rutracker, rutor} номер_торрента{номер из URL} номер_последней_скаченной_серии{автоматически обновляется после загрузки новых}
rem -----
rem Пример файла get.txt:
rem rutracker 86939 46
rem rutracker 4400218 7
rem rutor 227513 22
rem --------------------------------------------------------------
rem --------------------------------------------------------------
rem Создание рабочей папки, если ее еще не существует
mkdir !workdir! >nul 2>nul
rem Один вход на RuTracker, чтобы получить cookie-файл для последующих загрузок torrent-файлов
curl -s -c "%workdir%\cookie_rutracker.txt" -A "Opera/10.00 (Windows NT 5.1; U; ru)" ^
-d "login_username=!rutracker_login!&login_password=!rutracker_password!&login=%C2%F5%EE%E4" ^
"http://login.rutracker.org/forum/login.php" > nul
del /q !workdir!\~get.txt.new.tmp 2>nul
rem Обход по отслеживаемым раздачам из файла настройки get.txt
for /F "tokens=1,2,3*" %%i in (get.txt) do (
set tracker_id=%%i
set torrent_id=%%j
set last_file_id=%%k
set torrent_comment=%%l
set torrent_file=!tracker_id!_!torrent_id!.torrent
set err=
rem Загрузка torrent-файла с RuTracker или RuTor
echo !tracker_id! !torrent_id! !last_file_id!: Загрузка файла раздачи '!torrent_file!'
if "%%i" == "rutracker" (
curl -s -A "Opera/10.00 (Windows NT 5.1; U; ru)" ^
-b "%workdir%\cookie_rutracker.txt" ^
-b "bb_dl=!torrent_id!" ^
"http://dl.rutracker.org/forum/dl.php?t=!torrent_id!" -o "!workdir!\!torrent_file!"
) else (
if "%%i" == "rutor" (
curl -s -A "Opera/10.00 (Windows NT 5.1; U; ru)" ^
"http://d.rutor.org/download/!torrent_id!" -o "!workdir!\!torrent_file!"
) else (
set err=X
echo !tracker_id! !torrent_id! !last_file_id!: Неизвестный трекер: '!tracker_id!'
)
)
if !err! NEQ X (
rem Обработка torrent-файла через call, чтобы можно было в for in использовать --show-files !workdir!\!torrent_file!
call :process !torrent_file!
)
rem Создание обновленного списка отслеживаемых раздач (формирование нового get.txt)
echo !tracker_id! !torrent_id! !last_file_id! !torrent_comment!>> !workdir!\~get.txt.new.tmp
echo.
)
rem Обновление файла со списком отслеживаемых раздач (get.txt)
move /y !workdir!\~get.txt.new.tmp get.txt >nul 2>nul
rem Удаление технического файла работы aria2c
del /Q !video_dir!\*.aria2 >nul 2>nul
rem Индикация о новых загрузках в панели "Ссылки" - в if /? указан EQL WTF?!
if "!has_new!" EQU "X" copy /Y %lnk_name% %lnk_dest% >nul
rem Возврат кодировки сеанса CMD
chcp !chcp_cmd! >nul
rem Для паузы в конце выполнения программы, нужно раскомментировать следующую строчку
rem pause
exit /b
rem Обработка torrent-файла - анализ, загрузка новых файлов
rem %1 - имя torrent-файла = !torrent_file!, но %1 нужен для использования в for in
:process
echo !tracker_id! !torrent_id! !last_file_id!: Обработка раздачи '!torrent_file!'
rem [доп инфо] в CMD /U тут без chcp 866 не работал find /c "+"
for /f "tokens=1" %%a in ('aria2c.exe --show-files %workdir%^\%1 ^| findstr /R "^---+----*" ^| find /c "+"') do set cnt=%%a
rem Если количество файлов в раздаче больше чем в настройке, то загружаем новые
if !last_file_id! LSS !cnt! (
rem В torrent-файле порядок серий может быть не последовательным (http://rutracker.org/forum/viewtopic.php?t=4400218),
rem поэтому ориентация на сортировку по имени файлов
del /q !workdir!\~sort.tmp 2>nul
for /f "tokens=1,2 delims=|" %%x in ('aria2c.exe --show-files %workdir%^\%1 ^| findstr /BRC:"^[ ]*[0-9][0-9]*"') do echo %%y ^| %%x >> !workdir!\~sort.tmp
set /a skip=last_file_id
rem Загрузка новых файлов. Через call, чтобы работало skip=%skip%
call :download_new_files
) else (
echo !tracker_id! !torrent_id! !last_file_id!: Новых файлов нет
)
exit /b
rem Загрузка новых файлов
:download_new_files
rem 1-3) Список файлов раздачи в кодировке UTF-8, поэтому в ней и читаем
chcp 65001 > nul
rem Новые - это последние в отсортированном по имени списке файлов раздачи
for /f "skip=%skip% tokens=1,2 delims=|" %%o in ('sort %workdir%^\~sort.tmp') do (
rem 2-3) Возврат кодировки после 65001
chcp !chcp! >nul
set /a down=%%p
rem Через call
rem 1) чтобы в echo выводить кириллицу нормально и в заголовке сообщениия, и в имени файла, и в консоль, и в журнал
rem 2) чтобы время %time% обновлялось для каждого нового файла
call :down_file %%o
)
rem 3-3) Возврат кодировки после 65001
chcp !chcp! >nul
rem Удаление временных файлов
del /q !workdir!\~sort.tmp 2>nul
exit /b
rem Загрузка нового файла из раздачи
rem %* = имя нового файла
:down_file
set /a last_file_id=last_file_id+1
echo !tracker_id! !torrent_id! !last_file_id!: Загрузка файла '%*'
aria2c --dir=!video_dir! ^
--seed-time=0 ^
--file-allocation=none ^
--summary-interval=0 ^
--console-log-level=error ^
--max-overall-download-limit=1M ^
--allow-overwrite=true ^
--select-file=!down! ^
!workdir!\!torrent_file!
rem Еще полезно-интересные параметры:
rem --quiet=true ^
rem Параметр, чтобы от процесса загрузки никакого вывода на экран не было
rem --allow-overwrite=true ^
rem Параметр, чтобы удалять файлы torrent-а, все кроме только скаченного
rem Позволяет поддерживать отсутствие недокаченных частей ненужных соседних файлов в torrent-е
rem При скачивании сразу нескольких файлов, останется только последний
rem Ведение журнала загрузок log.txt - новые события сверху
rem Если в %time% непосредственно в for, то для каждого файла время не обновляется, нужно через call
copy log.txt !workdir!\~log.txt.tmp >nul 2>nul
echo %date% %time%: [!tracker_id! !torrent_id! !last_file_id! !torrent_comment!] %* >log.txt
type !workdir!\~log.txt.tmp >>log.txt 2>nul
del /q !workdir!\~log.txt.tmp >nul 2>nul
rem Флаг для оповещения о загрузке новых файлов
set has_new=X
exit /b
```
**get.vbs**
```
Dim oShell
Set oShell = WScript.CreateObject ("WSCript.shell")
oShell.run "get.bat", 0
Set oShell = Nothing
``` | https://habr.com/ru/post/180173/ | null | ru | null |
# Как я делал хардварный чат — а получился всё равно софтварный ¯\\_(ツ)_/¯
[](https://habr.com/ru/company/ruvds/blog/707568/)*Картинка [rawpixel.com, Freepik](https://www.freepik.com/free-photo/cloud-computing-banner-background-smart-city_16016425.htm#query=iot&from_query=mqtt&position=29&from_view=search&track=sph)*
*— Пациент, мучают ли вас навязчивые странные идеи?
— Почему мучают, доктор, я ими наслаждаюсь!*
Ввиду того, что я достаточно часто работаю с протоколом mqtt, мне периодически приходят в голову своеобразные мысли, одна из которых меня и посетила недавно: а что если сделать свой чат на этом протоколе?
Именно этим мы и займёмся в нашей статье.
Вообще говоря, подобная организация чата через mqtt-брокера является достаточно любопытной, так как позволяет разрозненным людям общаться между собой, используя для этого общедоступные сервера в интернете, называемые mqtt-брокерами.
Изначально подобного типа сервера были предназначены для общения машин между собой и построения машинных сетей, частным случаем которых являются и широко распространившиеся в последнее время сетевые устройства, в рамках концепции «умного дома», и Интернета вещей (IoT).
Мы же, попробуем использовать подобные сети для общения людей между собой, то есть, несколько необычным способом, для чего подобные сети изначально не задумывались.
Очевидным плюсом подобного способа коммуникации является то, что мы можем создать произвольное количество каналов для общения, используя для этого общедоступные сервера, находящиеся на разных адресах.
В целом, изучение подобного вопроса мы произведём исключительно «искусства ради», с точки зрения, исследования вопроса «если машины общаются между собой, почему бы людям не общаться также?»
▍ Что такое Mqtt-брокер
-----------------------
Я сейчас достаточно подробно не буду распространяться на всех тонкостях работы брокеров, так как, наверняка многие об этом хорошо знают, просто в двух словах скажу для тех, кто с этим ещё не сталкивался. Ниже вы можете увидеть схему, что представляет собой брокер и схема общения с ним:
*Картинка [r-iot.org](https://riotdotorg.files.wordpress.com/2017/12/mqtt_structure.png)*
Брокер представляет собой сервер со специальным программным обеспечением, которое позволяет подключиться к себе, через определённый порт.
Также программное обеспечение позволяет подключившемся клиенту создавать произвольное количество, с произвольными названиями, так называемых «топиков», которые для лучшего понимания, можно представить себе как отдельные telegram-каналы, в которых можно общаться.
Так же как и в telegram-каналах, можно оставлять сообщения в определённых каналах и подписаться на обновления в ряде каналов, чтобы видеть, что в них происходит (какие сообщения появляются).
Это, так сказать, преамбула, а сейчас будет «амбула» :-)
▍ Пишем свой Mqtt-чат
---------------------
Так как серверную часть вопросов полностью закрывает своим функционалом mqtt-брокер, мы поговорим о клиентской части.
Самым простым способом организации ввода и отсылки сообщений является отправка их в стандартный монитор порта в среде разработки Arduino IDE (хотя если сильно надо, можно попробовать написать и свою графическую часть, то бишь GUI, но, мне кажется, это будет лишним).
> Для последующей работы мы будем использовать побайтное считывание из монитора порта, используя функцию Serial.read(). И это, кстати говоря, даст нам возможность быстро понять, какой символ перед нами: латинский/знак или кириллический (правда, нам это не нужно, ибо есть способ проще. Это просто для сведения). А теперь ниже немного деталей.
Ниже небольшая «познавательная страничка». Кто в курсе — ~~может закрыть страницу браузера~~ листать ниже :-). Для первичного понимания, как происходит ввод и на что это похоже, возьмём простенькую программу, которая будет считывать вводимые нами символы и отображать их в мониторе порта:
```
byte incomingByte;
void setup() {
Serial.begin(115200);
}
void loop() {
if (Serial.available() > 0) {
incomingByte = Serial.read();
Serial.println(incomingByte, DEC);
}
}
```
Так как это у нас чат, необходимо чтобы каждая вводимая строка, отображалась на новой строке (это, помимо того, что подобный вывод должен содержаться ещё и в коде). Для этого нам нужно переключить в мониторе порта режим его работы для отображения вводимых строк, каждой на новой строке:
Кроме того, это сильно поможет нам в анализе отображаемой информации.
Далее, если мы введём, например, английскую букву «М», в мониторе порта покажутся следующие цифры:
Что это за цифры, и откуда они берутся: дело в том, что вся вводимая информация в монитор порта Arduino IDE вводится в кодировке UTF-8 (по крайней мере, это справедливо для версии 1.8.13, которая у меня). Таким образом, если мы обратимся [к таблице кодировки UTF-8](https://wiki.iarduino.ru/page/encoding-arduino/#:~:text=ISO%2D8859%2D5.-,%D0%A2%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D0%B0%20%D1%81%D0%B8%D0%BC%D0%B2%D0%BE%D0%BB%D0%BE%D0%B2%3A,-%D0%92%20%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D0%B5%20%D0%BA%D0%B0%D0%B6%D0%B4%D0%BE%D0%BC%D1%83), то там мы увидим искомый код буквы «М» английской:
Но что же такое вот эта цифра 10, и откуда она взялась? Как можно было видеть по коду выше, мы печатали в монитор порта в десятичном формате (DEC), переключив, как ранее и говорилось, отображение строк — с новой строки. Помимо удобства наблюдения подобных строк в мониторе порта, здесь есть ещё и практическая польза: каждая отправляемая строка будет теперь содержать благодаря нашей настройке дополнительно цифру 10, которая является управляющим символом ASCII, в десятичной системе счисления. То есть, при анализе введённой пользователем строки, мы эту десятку будем учитывать как символ конца строки!
Это что касается ввода большинства символов и латинских букв. А как же обстоят дела с русским языком? Чтобы проверить это, попробуем ввести ту же самую заглавную букву «М», только на русском языке:
Как мы видим, отобразились три цифры, одну из которых мы уже знаем,- это условно говоря, символ конца строки (10), а также ещё какие-то две цифры. Как мы могли уже догадаться, эти цифры также означают кодировку буквы «М» кириллической, в системе UTF-8, в той же самой таблице, которая была приведена выше:
Только почему же цифры здесь две? А дело здесь в том, что буквы кириллицей в этой кодировке, кодируются в виде двух байтов, а буквы латиницей, — в виде одного байта. Ну вот такие правила были приняты когда-то. То есть, если сказать по-другому, для хранения большинства символов латинских букв в этой кодировке требуется для каждой из них сочетание из восьми нулей и единиц, а для кириллических букв — целых 16.
Кроме того, если мы попробуем проанализировать зависимости, то легко обнаружить, что максимальный по цифре латинский символ находится под номером 127, соответственно, все оставшиеся двухбайтные символы находятся под номерами от 128 и выше.
С учётом всего этого напишем свою функцию, которая будет обрабатывать наш ввод в монитор порта (ситуация у нас, на самом деле, довольно простая: «всё, что не 10 — всё наше»).
**Обработчик сообщений**
```
void MyMessageHandler ()
{
byte incomingByte;
String out;
//всё, что ниже - обрабатывает наш ввод букв в монитор порта:
while (Serial.available() > 0)
{
incomingByte = Serial.read();
//пробуем читать надписи - из монитора порта:
//если это не символ конца строки-то выполняем, то что ниже
if ( incomingByte != 10 )
{
char data = incomingByte;
out = out + String (data);
}
else//если это символ конца строки (то есть, пришла десятка (10) )
{
//добавили имя (чтобы все в чате знали,
//кто написал сообщение)
out = MyMQTT_NAME + out;
//отправили на экран в
//монитор порта "накопленную" строку
Serial.print (out);
char arr[out.length()+1];
out.toCharArray(arr, out.length()+1);
publishSerialData(arr);
Serial.println ();
}
}
}
```
Как можно видеть в конце кода, приведённого выше, мы добавляем к выходной строке наше имя, так как будет очень странно, если в общем чате мы будем без имени:
```
out = MyMQTT_NAME + out;
```
Для работы с брокером мы будем использовать известную библиотеку [PubSubClient.h](https://github.com/knolleary/pubsubclient).
До этого для начала нам придётся определить ряд переменных, которые можно видеть в самом начале программы, которым даны достаточно хорошо читаемые названия:
```
#define mqtt_port 1883
#define BROKER_USER "" //в нашем случае не нужно - это с запасом
#define BROKER_PASSWORD "" //в нашем случае не нужно - это с запасом
#define BROKER_CHAT_TOPIC "our_chat"
#define MyMQTT_NAME "Дедушко Морозъ: " //перед сообщением мы будем ставить своё имя
#define WELCOME "Фсем приведы, ох-хо-хо!"
```
Основной код программы состоит из четырёх функций библиотеки, местами модифицированных для достижения наших целей:
```
void setup_wifi()
void reconnect()
void callback(char* topic, byte *payload, unsigned int length)
void publishSerialData(char *serialData)
```
* Функция setup\_wifi() служит для подключения к точке доступа,
* функция reconnect() предназначена для установления соединения с mqtt-брокером,
* функция обратного вызова callback служит для обработки полученного сообщения с брокера,
* publishSerialData — служит для постинга сообщений.
Кроме того, имеется закомментированная строчка с вызовом обработчикаTaskHandler(), — это такой своеобразный бонус в коде от автора статьи (находится внутри функции callback(char\* topic, byte \*payload, unsigned int length) ;-).
Этот обработчик реализован в новом окне, и служит примером, как можно обрабатывать полученные сообщения, если среди них должны быть какие-либо, для управления некими устройствами. В качестве примера в этом коде включается и выключается встроенный в esp32 светодиод:
```
void TaskHandler (String s)
{
//Проверяем, нет ли команды на
//включение встроенного в esp32 светодиода:
for (int i=0; i
```
Из интересного в упомянутом коде можно отметить, что библиотека предоставляет две функции отправки сообщений в топики, одна из которых применена внутри другой функции reconnect():
```
#define BROKER_CHAT_TOPIC "our_chat"
#define MyMQTT_NAME "Дедушко Морозъ: "
#define WELCOME "Фсем приведы, ох-хо-хо!"
//--------------.........-------------------------------
//После подключения - публикуем приветствие:
String temp = String (MyMQTT_NAME) + String (WELCOME);
client.publish(BROKER_CHAT_TOPIC, (char*) temp.c_str());
```
Которая может принять сообщение в виде явной строки ещё вот таким образом:
```
client.publish("our_chat", "фсем приведы");
```
Второй же функцией библиотеки, позволяющей отправлять данные, является использованная в нашем обработчике сообщений MyMessageHandler():
```
//добавили имя (чтобы все в чате знали,
//кто написал сообщение)
out = MyMQTT_NAME + out;
//отправили на экран в
//монитор порта "накопленную" строку
Serial.print (out);
char arr[out.length()+1];
out.toCharArray(arr, out.length()+1);
publishSerialData(arr);
Serial.println ();
```
**Полный код всего проекта** [вы можете найти вот здесь](https://drive.google.com/file/d/13sLWlWeQJ86g54A1Yf33sX4NKVqtoeAT/view?usp=sharing).
Код отлично работает (по крайней мере, на моей версии Arduino IDE 1.8.13) и протестирован.
Для того чтобы проверить работу кода, особенно если у вас не несколько esp32, а всего лишь одна, вы можете воспользоваться публичным браузерным клиентом mqtt-брокера, который находится [вот по этому адресу](http://www.hivemq.com/demos/websocket-client/).
После перехода по ссылке — у вас откроется окно, в котором не нужно изначально ничего вводить, а нужно сразу нажать на кнопку «Connect», после чего у вас произойдёт подключение к брокеру:
После подключения вам нужно нажать на кнопку Add New Topic Subscription:
В появившемся окне вам нужно ввести название топика, который у нас используется esp32 для постинга сообщений (это нужно для того, чтобы мы в принципе видели, что наши сообщения постятся в топике, на брокере):
После того как мы подписались, мы увидим, что наша подписка появилась внизу под кнопкой Add New Topic Subscription.
Теперь нам останется только ввести название топика, куда мы будем постить сообщение (его название совпадает с тем, на который мы подписались) и, собственно, запостить сообщение. Отправленное сообщение появится внизу, в разделе messages:
Попробуем теперь отправить сообщение с той стороны со стороны брокера, а также отсюда, из монитора порта в сторону брокера. Всё отлично работает:
По большому счёту на этом можно было бы и подвести черту, однако есть ещё один интересный момент, он заключается в том, что мы, по сути своей, используем публичный, общедоступный брокер, куда отправляем сообщения в незашифрованном виде, следовательно, незащищённые.
Как [говорит](https://ru.wikipedia.org/wiki/ESP32#:~:text=%D0%9A%D1%80%D0%B8%D0%BF%D1%82%D0%BE%D0%B3%D1%80%D0%B0%D1%84%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5%20%D0%B0%D0%BF%D0%BF%D0%B0%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B5%20%D1%83%D1%81%D0%BA%D0%BE%D1%80%D0%B5%D0%BD%D0%B8%D0%B5%3A%20AES%2C%20SHA%2D2%2C%20RSA%2C%20%D0%BA%D1%80%D0%B8%D0%BF%D1%82%D0%BE%D0%B3%D1%80%D0%B0%D1%84%D0%B8%D0%B8%20%D0%BD%D0%B0%20%D0%BE%D1%81%D0%BD%D0%BE%D0%B2%D0%B5%20%D1%8D%D0%BB%D0%BB%D0%B8%D0%BF%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D1%85%20%D0%BA%D1%80%D0%B8%D0%B2%D1%8B%D1%85%20(%D0%95%D0%A1%D0%A1)%2C%20%D0%B0%D0%BF%D0%BF%D0%B0%D1%80%D0%B0%D1%82%D0%BD%D1%8B%D0%B9%20%D0%B3%D0%B5%D0%BD%D0%B5%D1%80%D0%B0%D1%82%D0%BE%D1%80%20%D1%81%D0%BB%D1%83%D1%87%D0%B0%D0%B9%D0%BD%D1%8B%D1%85%20%D1%87%D0%B8%D1%81%D0%B5%D0%BB%20%D0%BF%D1%80%D0%B8%20%D0%B2%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%BD%D0%BE%D0%BC%20WiFi%20%D0%B8%D0%BB%D0%B8%20Bluetooth%2C%20%D0%B8%D0%BD%D0%B0%D1%87%D0%B5%20%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D1%83%D0%B5%D1%82%D1%81%D1%8F%20%D0%B3%D0%B5%D0%BD%D0%B5%D1%80%D0%B0%D1%82%D0%BE%D1%80%20%D0%BF%D1%81%D0%B5%D0%B2%D0%B4%D0%BE%D1%81%D0%BB%D1%83%D1%87%D0%B0%D0%B9%D0%BD%D1%8B%D1%85%20%D1%87%D0%B8%D1%81%D0%B5%D0%BB) нам спецификация esp32, — плата поддерживает целый ряд протоколов шифрования на аппаратном уровне.
Имеется подозрение, что для наиболее полного раскрытия потенциала платы, необходимо будет использовать в этом смысле родной API [среды разработки от Espressif](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/get-started/index.html) (разработчика платы esp32), а не сторонние решения. Тем не менее задачи у нас скромные, для нас сгодится.
То есть теоретически, мы можем использовать для своих целей даже публичные брокеры и общаться на них вполне себе безопасно, если будем шифровать свой трафик.
Сразу следует оговориться, что эту тему автор статьи не использовал в приведённом здесь коде и ознакомился с ней теоретически, на основе открытых материалов интернета, однако, вы вполне можете изучить эту тему более подробно и применить в своём проекте.
Например, [вот здесь](https://techtutorialsx.com/2018/04/18/esp32-arduino-encryption-using-aes-128-in-ecb-mode/), приводится достаточно подробное описание использования библиотеки mbedtls/aes.h, которая позволяет организовать шифрование с использованием AES алгоритма, с применением 128-битного ключа.
Насколько можно судить, использование библиотеки достаточно простое, в ней используется функция, которая на вход принимает контекст алгоритма, константу, которая означает, что нужно делать с переданной информацией, а также собственно строку на шифрование.
Таким образом, константа у нас может принимать два значения:
* зашифровать данные переданной строки (MBEDTLS\_AES\_ENCRYPT);
* расшифровать данные переданной строки (MBEDTLS\_AES\_DECRYPT).
Как утверждает автор статьи, ссылка на которую дана выше, для обеспечения должного уровня безопасности, необходимо правильным образом сгенерировать ключ AES. Для этого можно воспользоваться алгоритмом, описанным [вот здесь](https://mbed-tls.readthedocs.io/en/latest/kb/how-to/generate-an-aes-key/).
Только при включении шифрования следует иметь в виду, что используемая библиотека для общения с mqtt-брокером, [поддерживает](https://github.com/knolleary/pubsubclient#:~:text=The%20maximum%20message%20size%2C%20including%20header%2C%20is%20256%20bytes%20by%20default.%20This%20is%20configurable%20via%20MQTT_MAX_PACKET_SIZE%20in%20PubSubClient.h%20or%20can%20be%20changed%20by%20calling%20PubSubClient%3A%3AsetBufferSize(size)) максимальную длину сообщения в 256 байт (то есть, грубо говоря, 128 букв для кириллической, двухбайтной кодировки). Однако этот параметр можно менять, как заявляют создатели библиотеки, поэтому в приведённом выше коде чата была оставлена закомментированной строчка:
```
//размер сообщения в байтах (по умолчанию 256,
//но мы можем его менять и поставить свой размер,
//например, 512 и т.д., как здесь):
// client.setBufferSize(512);
```
Которую можно раскомментировать и назначить своё значение, — как однократно, так и динамически, при каждой отправке сообщения (однако с этим могут возникнуть проблемы, так как ваш визави тоже должен знать, какой длины будет сообщение и какой параметр ему выставить). Теоретически может ждать ещё одна засада — ограничение на длину сообщения в бесплатной версии mqtt-брокера, надо изучать этот вопрос, чтобы выяснить. Подобная плата esp32 с шифрованием может выступать как своеобразный hardware usb secure key, например, выполненный в виде флешки, с помощью которого организуется защищённый канал связи (стартап?), с использованием которого, сообщение передаётся в зашифрованном виде, на целом ряде псевдослучайно генерируемых «каналов» — топиков.
Подытоживая рассказ, по приведённому выше можно видеть, что использование брокеров сообщений из сферы IoT, вполне себе позволяет организовать и общение людей, а не только электронных устройств, что предоставляет новые возможности в сфере коммуникации, особенно при организации защищённых соединений.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=DAN_SEA&utm_content=a_ne_zapilit_li_nam_xardvarnyj_chat) | https://habr.com/ru/post/707568/ | null | ru | null |
# Kali Linux: упражнения по модификации пакетов, сборке ядра и созданию ISO-образов
Сегодня публикуем перевод завершения девятой главы книги «[Kali Linux Revealed](https://kali.training/introduction/kali-linux-revealed-book/)». Здесь будут подведены итоги таких тем, как модификация пакетов, сборка ядра и создание собственных ISO-образов. Кроме того, тут вы найдёте упражнения к этой главе, на которых, надеемся, будет интересно попробовать свои силы как тем, кто уже знаком с Kali, так и тем, кто только начал осваивать этот дистрибутив.
[](https://habrahabr.ru/company/ruvds/blog/342406/)
**9.5. Итоги**
--------------
В этой главе вы узнали о том, как модифицировать пакеты с исходным кодом, которые являются основными строительными блоками всех присутствующих в Kali приложений. Кроме того, мы рассказали о том, как настраивать, собирать и устанавливать собственные ядра Kali. Далее, мы поговорили об окружении `live-build` и о том, как создавать собственные ISO-образы Kali. Так же в этой главе речь шла о подготовке загрузочных флэш-носителей с поддержкой постоянных хранилищ информации, которые могут быть как зашифрованными, так и незашифрованными. Сейчас мы систематизируем основные положения этой главы и предложим вашему вниманию набор упражнений.
9.5.1. Модификация пакетов
--------------------------
Модификацией пакетов Kali обычно занимаются разработчики, и те, кто отвечает за поддержку и развитие системы, однако, может случиться так, что вам будет недостаточно возможностей, предоставляемых официальными сборками пакетов.
Поэтому знание того, как собрать модифицированный пакет, может быть очень полезным, особенно если вы хотите поделиться новым пакетом с кем-нибудь, развернуть его на множестве машин, или, после установки нового пакета, без проблем вернуть систему в предыдущее состояние.
Когда вам нужно модифицировать некую программу, весьма соблазнительно загрузить исходный код, внести в него изменения и использовать эту модифицированную версию. Однако, если программа нуждается в установке, после которой она доступна во всей системе (то есть, с использованием `make install`), тогда такая установка загрязнит файловую систему файлами, неизвестными `dpkg`, что довольно скоро приведёт к возникновению проблем, которые не могут быть выявлены на основе анализа зависимостей пакетов. Кроме того, при таком подходе к модификации пакетов, тем, что получилось, сложнее делиться с другими пользователями.
В ходе создания модифицированного пакета общая последовательность действий всегда оказывается одной и той же: скачивание пакета с исходным кодом, извлечение его содержимого, внесение изменений, а затем — сборка пакета. Существует множество инструментов, способных решить каждую из этих задач.
Для того, чтобы приступить к пересборке пакетов Kali, сначала нужно загрузить пакет с исходным кодом, который включает в себя основной \*.dsc-файл (Debian Source Control) и дополнительные файлы, на которые есть ссылки в основном файле.
Пакеты с исходным кодом хранятся на HTTP-зеркалах. Самый эффективный способ их загрузки заключается в использовании команды вида `apt source source-package-name`. Для её успешного выполнения требуется добавить строку `deb-src` в файл `/etc/apt/sources.list` и обновить индексные файлы командой `apt update`.
Кроме того, можно использовать команду `dge`t (из пакета `devscripts`) для непосредственной загрузки .dsc-файла и сопутствующих ему материалов. В случае с пакетами, подготовленными специально для Kali, исходный код которых хранится в Git-репозитории на `git.kali.org`, загрузить исходный код можно с помощью команды вида `git clone git://git.kali.org/packages/source-package` (если после выполнения такой команды ничего загружено не будет, попытайтесь переключиться на ветку `kali/master` с помощью команды `git checkout kali/master`).
После загрузки исходного кода установите пакеты, перечисленные в зависимостях сборки пакета с исходным кодом, с помощью команды `apt build-dep ./`. Её необходимо запустить, из директории пакета, в которой находится исходный код.
Внесение изменений в пакет с исходным кодом заключается в выполнении необходимых действий из следующего списка:
* Первый шаг, который нужно выполнять всегда, заключается в изменении номера версии пакета. Это требуется для того, чтобы система могла отличить новый пакет от исходного. Делается это с помощью команды вида `dch --local version-identifier` или путём модификации других сведений о пакете с помощью утилиты `dch`.
* Применение патча с помощью команды вида `patch -p1 < patch-file` или модификация серии патчей `quilt`.
* Настройка параметров сборки, которые обычно можно найти в файле `debian/rules` или в других файлах из директории `debian/`.
После модификации пакета с исходным кодом можно собрать бинарный пакет с помощью команды `dpkg-buildpackage -us -uc -b`, вызываемой из директории с исходным кодом. Эта команда создаст неподписанный бинарный пакет. Полученный пакет потом можно установить с помощью такой команды: `dpkg -i package-name_version_arch.deb`.
9.5.2. Сборка ядра
------------------
У продвинутых пользователей системы иногда возникает потребность в перекомпиляции ядра Kali. Возможно, вам это понадобится для того, чтобы уменьшить размер стандартного ядра, которое, по умолчанию, содержит множество возможностей и драйверов. Сборка нового ядра может понадобиться для добавления в него нестандартных драйверов или возможностей, или для установки патчей ядра. Тут стоит знать о том, что неправильно настроенное ядро может сделать систему нестабильной, и вы должны понимать, что команда Kali не может обеспечить обновления безопасности для ядер, которые пользователи собирают самостоятельно.
В большинстве случаев для внесения изменений в ядро понадобится установить некоторые пакеты с помощью команды `apt install build-essential libncurses5-dev fakeroot`.
Команда `apt-cache search ^linux-source` должна вывести список последних версий ядра, созданных командой поддержки Kali. Команда вида `apt install linux-source-version-number` устанавливает сжатый архив с исходным кодом ядра в `/usr/src`.
Файлы с исходном кодом надо распаковать командой `tar -xaf` в директорию, отличающуюся от `/usr/src` (например, в `~kernel`).
Когда приходит время настраивать ядро, стоит держать в голове следующие соображения:
* Если вы не являетесь пользователем с огромным опытом, сначала стоит заполнить конфигурационный файл ядра. Для этого лучше всего взять стандартную конфигурацию ядра, скопировав `/boot/config-version-string` в `~/kernel/linux-source-version-number/.config`. Как вариант, можно использовать команду `make architecture_defconfig` для построения подходящей для имеющейся архитектуры конфигурации.
* Инструмент для конфигурирования ядра с текстовым интерфейсом, запускаемый командой `make menuconfig`, считывает файл `.config` и даёт возможность настраивать ядро с помощью обширной системы меню. При выборе элемента выводится документация по нему и список возможных значений, тут же можно и ввести для него новое значение.
Если выполнить команду `make clean` из директории с исходным кодом ядра, это приведёт к удалению ранее скомпилированных файлов. Команда `make deb-pkg` создаст до пяти Debian-пакетов. Файл, имя которого выглядит как `linux-image-version.deb` содержит образ ядра и связанные с ним модули.
Для того, чтобы использовать новое ядро, нужно установить необходимые пакеты с помощью команды вида `dpkg -i file.deb`. При этом не обойтись без пакета «linux-image». Пакет «linux-headers» нужно установить лишь в том случае, если имеются внешние модули ядра для сборки, что происходит в том случае, если у вас есть установленные \*-dkms-пакеты (проверить, так ли это, можно с помощью команды `dpkg -l "*-dkms" | grep ^ii`). Другие пакеты, в большинстве случаев, не используются.
9.5.3. Сборка собственных ISO-образов Kali
------------------------------------------
Официальные ISO-образы Kali собраны с использованием набора скриптов `live-build`, который даёт возможность полной автоматизации работ и настройки всех аспектов создания ISO-образов.
Для использования `live-build` нужно, чтобы система была обновлена до последней версии.
Конфигурационные данные Kali live-build можно загрузить из Git-репозиториев Kali с помощью команды `apt install curl git live-build`, после которой выполняется команда `git clone git://git.kali.org/live-build-config.git`.
Для создания обновлённого, но немодифицированного ISO-образа Kali, достаточно воспользоваться командой `./build.sh --verbose`. Сборка займёт немало времени, так как в ходе выполнения этой операции будут загружены все необходимые пакеты. После завершения сборки новый ISO-образ можно будет найти в директории `images`. Если при выполнении этой команды воспользоваться опцией вида `--variant variant`, будет собран указанный вариант образа. Различные варианты определяются их конфигурационными директориями, имена которых выглядят как `config/variant-*`. Основной образ создаётся с помощью варианта `gnome`.
Есть несколько подходов в к настройке ISO-образа, которые заключаются во внесении изменений в конфигурационную директорию `live-build`:
* В Live-образ можно добавлять пакеты (или удалять из него существующие пакеты), модифицируя файлы `package-lists/*.list.chroot`.
* В образ можно включать собственные пакеты, помещая соответствующие .deb-файлы в директорию `packages.chroot`. Их установка может быть автоматизирована с помощью файлов `preseed/*.cfg`.
* В Live-файловую систему можно добавлять файлы, размещая из там, где они должны быть, в папке `includes.chroot`.
* В ходе процесса сборки образа с использованием `chroot` можно выполнять скрипты, устанавливая их как файлы `hooks/live/*.chroot`. Кроме того, скрипты можно вызывать во время загрузки с использованием созданного Live-образа. Их нужно установить по адресу, который выглядит как `/usr/lib/live/config/XXXX-name`, например, основываясь на конфигурационной директории `includes.chroot`.
* Для того, чтобы узнать подробности о конфигурировании и тестировании `live-build`, можно воспользоваться отличным руководством [Debian Live System Manual](http://debian-live.alioth.debian.org/live-manual/unstable/manual/html/live-manual.en.html).
Развернуть ISO-образ Kali на USB-флэшке довольно просто. При этом на подобном носителе можно настроить постоянное хранилище информации. Хотя этот процесс может показаться немного сложным, при ближайшем рассмотрении оказывается, что на переносном носителе довольно просто создавать зашифрованные и незашифрованные хранилища. Это значительно расширяет функционал подобных загрузочных носителей.
Теперь представляем вашему вниманию упражнения к данной главе.
**Упражнения по работе с пакетами и по сборке ядра Kali**
---------------------------------------------------------
Упражнение №1: создание форков пакетов Kali
-------------------------------------------
1. Создайте форк пакета `kali-meta`.
2. Включите в пакет новый метапакет, который содержит 3 ваших любимых инструмента и ничего больше.
3. Создайте бинарный .deb-файл, подходящий для дальнейшего использования.
### ▍Ответы к упражнению №1
**1.** Сначала настроим систему на работу с пакетами с исходным кодом:
```
apt-get install devscripts #Для установки dch
nano /etc/apt/sources.list
# Раскомментируйте эту строку: deb-src http://http.kali.org/kali kali-rolling main non-free contrib
```
Теперь загрузим исходный код. Обратите внимание на то, что вы, если будете следовать этим инструкциям, можете столкнуться с другими версиями пакетов:
```
apt-get update
apt source kali-meta # Установка всех пакетов kali-linux-*.
cd kali-meta-2017.2.0/
ls -l
nano debian/control
```
**2.** Изменим управляющий файл, включим в него собственные пакеты:
```
Package: kali-linux-muts
Architecture: any
Depends: ${misc:Depends},
kali-linux,
aircrack-ng,
nmap,
sqlmap,
Description: Kali Linux Custom tools for muts
This is Kali Linux, the most advanced penetration testing and security
auditing distribution.
.
This metapackage depends on few of muts' favorites.
```
Изменим номер версии пакета таким образом, чтобы пересобранные пакеты можно было отличить от исходных:
```
root@kali:~/kali-meta-2017.2.0# head -1 debian/changelog
root@kali:~/kali-meta-2017.2.0# dch --local muts -m "Added a new metapackage"
root@kali:~/kali-meta-2017.2.0# head -1 debian/changelog # Проверка того, что изменения были выполнены
```
И, наконец, соберём пакет:
```
root@kali:~/kali-meta-2017.2.0# dpkg-buildpackage -us -uc -b # Disable signatures (-us -uc), binary-only build (-b)
root@kali:~/kali-meta-2017.2.0# ls -l ../*muts*
-rw-r--r-- 1 root root 6804 Aug 28 13:42 gqrx_2017.2.0muts1_all.deb
-rw-r--r-- 1 root root 6948 Aug 28 13:42 kali-desktop-common_2017.2.0muts1_all.deb
-rw-r--r-- 1 root root 6972 Aug 28 13:42 kali-desktop-gnome_2017.2.0muts1_all.deb
-rw-r--r-- 1 root root 6796 Aug 28 13:42 kali-desktop-kde_2017.2.0muts1_all.deb
-rw-r--r-- 1 root root 6920 Aug 28 13:42 kali-desktop-live_2017.2.0muts1_all.deb
-rw-r--r-- 1 root root 6812 Aug 28 13:42 kali-desktop-lxde_2017.2.0muts1_all.deb
-rw-r--r-- 1 root root 6868 Aug 28 13:42 kali-desktop-xfce_2017.2.0muts1_all.deb
-rw-r--r-- 1 root root 7068 Aug 28 13:42 kali-linux_2017.2.0muts1_amd64.deb
-rw-r--r-- 1 root root 7062 Aug 28 13:42 kali-linux-all_2017.2.0muts1_amd64.deb
-rw-r--r-- 1 root root 7290 Aug 28 13:42 kali-linux-forensic_2017.2.0muts1_amd64.deb
-rw-r--r-- 1 root root 8732 Aug 28 13:42 kali-linux-full_2017.2.0muts1_amd64.deb
-rw-r--r-- 1 root root 6850 Aug 28 13:42 kali-linux-gpu_2017.2.0muts1_amd64.deb
-rw-r--r-- 1 root root 6844 Aug 28 13:42 kali-linux-muts_2017.2.0muts1_amd64.deb
-rw-r--r-- 1 root root 7298 Aug 28 13:42 kali-linux-nethunter_2017.2.0muts1_amd64.deb
-rw-r--r-- 1 root root 7088 Aug 28 13:42 kali-linux-pwtools_2017.2.0muts1_amd64.deb
-rw-r--r-- 1 root root 6864 Aug 28 13:42 kali-linux-rfid_2017.2.0muts1_amd64.deb
-rw-r--r-- 1 root root 6908 Aug 28 13:42 kali-linux-sdr_2017.2.0muts1_amd64.deb
-rw-r--r-- 1 root root 6924 Aug 28 13:42 kali-linux-top10_2017.2.0muts1_amd64.deb
-rw-r--r-- 1 root root 6942 Aug 28 13:42 kali-linux-voip_2017.2.0muts1_amd64.deb
-rw-r--r-- 1 root root 7360 Aug 28 13:42 kali-linux-web_2017.2.0muts1_amd64.deb
-rw-r--r-- 1 root root 7058 Aug 28 13:42 kali-linux-wireless_2017.2.0muts1_amd64.deb
-rw-r--r-- 1 root root 10312 Aug 28 13:42 kali-meta_2017.2.0muts1_amd64.buildinfo
-rw-r--r-- 1 root root 8343 Aug 28 13:42 kali-meta_2017.2.0muts1_amd64.changes
root@kali:~/kali-meta-2017.2.0# ls -l ../kali-linux-muts_2017.2.0muts1_amd64.deb
-rw-r--r-- 1 root root 6852 Aug 28 14:05 ../kali-linux-muts_2017.2.0muts1_amd64.deb
```
[Вот решение](https://asciinema.org/a/cHId68LJSRBJYtNKbUEowdpCN) на Asciinema (текст из видео копировать нельзя).
Упражнение №2: обновление пакета Kali
-------------------------------------
1. Подготовьте самую последнюю версию набора программ SET для использования с Kali.
2. Создайте бинарный файл для дальнейшего использования.
3. Можно ли, используя тот же подход, обновить пакет `aircrack-ng`?
### ▍Ответы к упражнению №2
**1.** Для начала загрузим Kali-версию SET:
```
apt source set
```
Далее, загрузим самую свежую версию SET. Тут, как и в предыдущем упражнении, вы можете столкнуться с другими номерами версий:
```
wget https://github.com/trustedsec/social-engineer-toolkit/archive/master.tar.gz -O set_7.7.1.orig.tar.gz
tar xvf set_7.7.1.orig.tar.gz
```
Для того, чтобы не запутаться, переименуем самую свежую версию:
```
mv social-engineer-toolkit-master social-engineer-toolkit-7.7.1
```
Скопируем всё, что имеет отношение к Debian:
```
cp -a set-7.7/debian social-engineer-toolkit-7.7.1/debian
rm -rf social-engineer-toolkit-7.7.1/.git
```
Обновим номер версии:
```
cd social-engineer-toolkit-7.7.1
head -1 debian/changelog
dch -v 7.7.1-0muts1 "New upstream release"
head -1 debian/changelog
```
**2.** Соберём пакет и проверим его работоспособность:
```
dpkg-buildpackage -us -uc -b
ls -l ../*muts* # использованный тег версии
dpkg -i ../set_7.7.1-0muts1_all.deb # использованный тег версии
```
**3.** В случае с `aircrack-ng` всё делается похожим образом:
```
nano /etc/apt/sources.list
apt-get update
apt source aircrack-ng
wget https://github.com/aircrack-ng/aircrack-ng/archive/master.tar.gz
tar zxpf master.tar.gz
mv aircrack-ng-master aircrack-ng-1.3
cp -rf aircrack-ng-1.2-0~rc4/debian/ aircrack-ng-1.3/
cd aircrack-ng-1.3/
head -1 debian/changelog
dch -v 1:1.3 -m "Upstream update"
nano debian/changelog
dpkg-checkbuilddeps
apt-get install libgcrypt-dev libgcrypt11-dev libnl-genl-3-dev libpcap0.8-dev libpcre3-dev libsqlite3-dev pkg-config zlib1g-dev
dpkg-buildpackage -us -uc -b
```
Упражнение№3: пересборка ядра
-----------------------------
При сборке стандартного ядра Kali действует принцип включения в него максимального функционала. Это нужно для обеспечения поддержки как можно более широкого спектра аппаратных платформ.
1. Установите инструмент для измерения производительности вроде `likwid` и запустите быстрый тест `likwid-bench`.
2. Установите патч graysky2 «Kernel GCC patch» для того, чтобы оптимизировать ядро под ваш процессор.
3. Перекомпилируйте ядро после установки патча и выбора своей модели процессора.
### ▍Ответы к упражнению №3
**1.** Установим `likwid`, запустим тест:
```
apt-get install likwid
likwid-topology -g | head # выясняем подробности об имеющемся процессоре
likwid-bench -t copy -w S0:100kB:1 # запускаем тест на socket 0
```
**2.** Патч для оптимизации ядра под конкретный процессор можно найти [здесь](https://github.com/graysky2/kernel_gcc_patch). Установим зависимости, необходимые для выполнения перекомпиляции ядра. Тут, как обычно, вы можете столкнуться с другими версиями:
```
apt install build-essential libncurses5-dev fakeroot
apt-cache search ^linux-source # выполним поиск текущей версии linux-source package
apt install linux-source-4.9 # загрузим её
ls /usr/src # which gets extracted to /usr/src
```
**3.** Извлечём исходный код ядра и скопируем туда, где он окажется, текущий конфигурационный файл:
```
mkdir ~/kernel; cd ~/kernel
tar -xaf /usr/src/linux-source-4.9.tar.xz
cp /boot/config-4.9.0-kali3-amd64 ~/kernel/linux-source-4.9/.config # Copy existing config
```
Запустим `menuconfig` на непропатченной конфигурации ядра:
```
cd linux-source-4.9
make menuconfig
```
Перейдём по следующим пунктам меню и посмотрим тип процессора:
```
Processor type and features --->
Processor family (Generic-x86-64) --->
```
Выйдем из конфигурации без сохранения. Загрузим оптимизирующий патч и пропатчим ядро:
```
cd ~/kernel
wget https://raw.githubusercontent.com/graysky2/kernel_gcc_patch/master/enable_additional_cpu_optimizations_for_gcc_v4.9%2B_kernel_v3.15%2B.patch
cd linux-source-4.9/
patch -p1 < ../enable_additional_cpu_optimizations_for_gcc_v4.9+_kernel_v3.15+.patch
make menuconfig
```
Теперь снова войдём в раздел конфигурационной программы, позволяющий настраивать тип процессора. Тут должны появиться новые пункты:
```
Processor type and features --->
Processor family (Generic-x86-64) --->
```
Выберем необходимый тип процессора, сохраним конфигурацию и выйдем из программы. Теперь соберём ядро:
```
export CONCURRENCY_LEVEL=5 #количество имеющихся CPU +1
make deb-pkg LOCALVERSION=-custom KDEB_PKGVERSION=$(make kernelversion)-1
```
Запустим тестирование:
```
likwid-topology -g | head # выясняем подробности об имеющемся процессоре
likwid-bench -t copy -w S0:100kB:1 # запускаем тест на socket 0
```
Улучшились ли показатели тестирования? Как ощущения? Может, получилось что-то вроде этого?
**Упражнения по сборке Live-образов**
-------------------------------------
Упражнение №1: Особая Live-сборка Kali
--------------------------------------
[В одной из серий](https://vimeo.com/225665986) [Mr. Robot](http://www.usanetwork.com/mrrobot) Анжеле нужно загрузиться с USB-диска Kali и, для того, чтобы взломать систему, ввести несколько команд. Можете ли вы собрать такой ISO-образ Kali, который позволит ей решить задачу быстрее? Автоматизируйте работу так, чтобы после загрузки Kali Анжеле не пришлось бы касаться клавиатуры.
### ▍Ответы к упражнению №1
Для решения этой задачи надо собрать для Анжелы Live-ISO и отдать его ей.
```
# Обновляем систему!
apt-get update
apt-get dist-upgrade
# устанавливаем необходимые инструменты
apt install -y git live-build cdebootstrap curl
# Клонируем конфигурационные файлы Kali live build
git clone git://git.kali.org/live-build-config.git
# Перезаписываем стандартный список пакетов, меняя его на минимально необходимый набор
cd live-build-config/
cat kali-config/variant-default/package-lists/kali.list.chroot
echo cryptsetup > kali-config/variant-default/package-lists/kali.list.chroot
echo openssh-server >> kali-config/variant-default/package-lists/kali.list.chroot
echo nmap >> kali-config/variant-default/package-lists/kali.list.chroot
# Добавляем файлы в live-файловую систему (настраиваем скрипты, выполняющиеся при загрузке)
mkdir -p kali-config/common/includes.chroot/lib/systemd/system/
# Регистрируем собственную службу "Angela" для запуска /usr/bin/startssh
cat << EOF > kali-config/common/includes.chroot/lib/systemd/system/angela.service
[Unit]
Description=Start Custom Script
After=multi-user.target
[Service]
Type=idle
ExecStart=/bin/bash /usr/bin/startssh
[Install]
WantedBy=multi-user.target
EOF
# Создаём /usr/bin (и родительские каталоги) в Live-файловой системе
mkdir -p kali-config/common/includes.chroot/usr/bin/
# Создаём скрипт "startssh", который сделает наше чёрное дело
cat << EOF > kali-config/common/includes.chroot/usr/bin/startssh
#!/bin/sh
echo hola > /root/test.txt
EOF
# Создаём хук, активирующий службу
cat << EOF > kali-config/common/hooks/live/angela.chroot
#!/bin/sh
systemctl enable angela.service || true
EOF
# Делаем его исполняемым
chmod 755 kali-config/common/hooks/live/angela.chroot
# Создаём конфигурационный файл загрузки, настраиваем приглашение, тайм-аут, автозагрузку, и так далее
cat << EOF > kali-config/common/includes.binary/isolinux/isolinux.cfg
include menu.cfg
default vesamenu.c32
prompt 0
timeout 20
ONTIMEOUT live-amd64
EOF
# Собираем ISO!
./build.sh --verbose
```
Упражнение №2: автоматический установщик минималистичной Live-сборки Kali
-------------------------------------------------------------------------
1. Создайте самоустанавливающийся ISO-образ, содержащий минимально возможное количество пакетов, и включите в него только пакеты `openssh-server` и `salt-minion`.
2. Добавьте к этому образу ваш публичный SSH-ключ для облегчения последующего доступа к нему.
3. Проверьте работоспособность образа.
### ▍Ответы к упражнению №2
Набор `live-build` используют всю структуру директорий в качестве входных данных для своей конфигурации. Мы храним эту конфигурацию и некоторые вспомогательные скрипты в Git-репозитории `live-build-config`. Мы будем использовать этот репозиторий как базу для сборки специально настроенных образов. Установим необходимые пакеты и загрузим Git-репозиторий с конфигурацией Kali live-build:
```
apt install curl git live-build
git clone git://git.kali.org/live-build-config.git
cd live-build-config
```
Создадим список включаемых в образ пакетов, начиная с `salt-minion`:
```
echo salt-minion > kali-config/variant-default/package-lists/kali.list.chroot
```
И ещё пакеты:
```
echo openssh-server >> kali-config/variant-default/package-lists/kali.list.chroot
```
Создадим директорию для включаемых файлов и поместим там наш `preseed.cfg`:
```
mkdir -p kali-config/common/includes.installer
wget https://www.kali.org/dojo/preseed.cfg -O ./kali-config/common/includes.installer/preseed.cfg
```
Добавлять файлы в ISO-образ можно, размещая их в конфигурационной директории `includes.binary`. Например, это `install.cfg` (опции загрузочного меню):
```
cat << EOF > kali-config/common/includes.binary/isolinux/install.cfg
label install
menu label ^Install
linux /install/vmlinuz
initrd /install/initrd.gz
append vga=788 --quiet file=/preseed.cfg locale=en_US keymap=us hostname=kali domain=local.lan
EOF
```
Туда же можно добавить файл `isolinux.cfg` с опциями загрузки:
```
cat << EOF > kali-config/common/includes.binary/isolinux/isolinux.cfg
include menu.cfg
ui vesamenu.c32
default install
prompt 0
timeout 5
EOF
echo 'systemctl enable ssh' > kali-config/common/hooks/live/01-start-ssh.chroot
```
Добавим в ISO-образ и SSH-ключ:
```
ssh-keygen -f /root/.ssh/id_rsa -t rsa -N '' # необязательно в том случае, если это уже сделано
mkdir -p kali-config/common/includes.chroot/root/.ssh/
cat /root/.ssh/id_rsa.pub > kali-config/common/includes.chroot/root/.ssh/authorized_keys
```
Соберём образ:
```
./build.sh --verbose
```
Упражнение №3: сборка LIve-USB с несколькими постоянными хранилищами и с паролем самоуничтожения
------------------------------------------------------------------------------------------------
Создайте Live-флэшку с несколькими постоянными хранилищами информации и включите пароль самоуничтожения LUKS.
### ▍Ответы к упражнению №3
Здесь мы предполагаем, что работа начинается с USB-флэшки, подготовленной в соответствии с инструкциями, приведёнными в разделе 2.1.4., «[Копирование образа на DVD-ROM или на USB-флэшку](https://kali.training/2-getting-started-with-kali/downloading-kali-linux/#sect.copying-the-image)». Подразумевается, что диск имеет размер, достаточный для хранения ISO-образа (около 3 Гб) и данных, которые планируется поместить в постоянное хранилище. Кроме того, мы исходим из предположения, что Linux видит флэш-диск как `/dev/sdb`, и что он содержит лишь два раздела, которые являются частью стандартного ISO-образа (`/dev/sdb1` и `/dev/sdb2`). Считаем важным напомнить, что выполняя действия, которые будут описаны ниже, нужно проявлять осторожность, так как переразбив не тот диск можно потерять важные данные.
Теперь подключаем флэшку к компьютеру (или к виртуальной машине) и выясняем имя устройства с использованием команд `dmesg` или `fdisk`. Как уже было сказано, предполагается, что это `/dev/sdb`. Если какие-то разделы были смонтированы автоматически, их надо отмонтировать. Теперь запускаем процесс разбиения на разделы:
```
umount /dev/sdb1
umount /dev/sdb2
parted /dev/sdb
```
Здесь мы будем создавать два хранилища. Одно будет зашифрованным, другое — обычным.
```
(parted) print
Model: SanDisk Ultra USB 3.0 (scsi)
Disk /dev/sdb: 124GB
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags:
Number Start End Size Type File system Flags
1 32.8kB 2794MB 2794MB primary boot, hidden
2 2794MB 2794MB 721kB primary
(parted) mkpart primary 2794 5000
(parted) mkpart primary 5000 100%
(parted) quit
Information: You may need to update /etc/fstab.
```
Команда `mkpart primary` `2794 5000` создаёт первый новый раздел (если посчитать их все, то он будет третьим), который начинается с 2794 Мб, и заканчивается на 5000 Мб. Мы используем именно это значение для указания начала раздела, так как образ Kali занимает на устройстве 2794 Мб. Возможно, вам придётся изменить эти значения для того, чтобы привести их в соответствие с размерами вашего ISO-образа или флэш-диска.
После создания двух новых разделов, можно приступать к настройке их в роли постоянных хранилищ информации в нашем окружении загрузки Kali. Мы начинаем этот процесс, используя имя `sdb3` для незашифрованного хранилища. Мы сначала форматируем раздел, потом даём ему метку `persistence`. Метка должна быть именно такой, это очень важно. Если этот шаг пропустить или назначить разделу другую метку, постоянное хранилище информации работать не будет!
```
mkfs.ext3 /dev/sdb3
e2label /dev/sdb3 persistence
```
Затем создаём файл `persistence.conf`, который указывает на то, какие папки нам нужно сохранить в постоянном хранилище. В данном случае мы собираемся сохранить там всю файловую систему:
```
mkdir -p /mnt/usb
mount /dev/sdb3 /mnt/usb
echo "/ union" > /mnt/usb/persistence.conf
umount /mnt/usb
```
Далее, настраиваем зашифрованное постоянное хранилище. Для этого зашифруем раздел с использованием `cryptsetup`, отформатируем его, назначим метку, проверим, всё ли сделано правильно и создадим файл `persistence.conf` так же, как делали это выше:
```
cryptsetup --verbose --verify-passphrase luksFormat /dev/sdb4
cryptsetup luksOpen /dev/sdb4 my_usb
mkfs.ext3 /dev/mapper/my_usb
e2label /dev/mapper/my_usb persistence
ls -l /dev/disk/by-label
mkdir -p /mnt/my_usb
mount /dev/mapper/my_usb /mnt/my_usb
echo "/ union" > /mnt/my_usb/persistence.conf
umount /dev/mapper/my_usb
cryptsetup luksClose /dev/mapper/my_usb
```
Вот и всё! Теперь с USB-диска можно загрузиться и выбрать, как именно продолжать загрузку: без хранилища, с незашифрованным хранилищем, или с зашифрованным хранилищем.
Для того, чтобы добавить пароль самоуничтожения (LUKS Nuke) к зашифрованному разделу, нужно выполнить следующую команду:
```
cryptsetup luksAddNuke /dev/sdb4
```
**Итоги**
---------
На этом мы завершаем публикацию перевода 9-й главы книги книги «[Kali Linux Revealed](https://kali.training/introduction/kali-linux-revealed-book/)». Надеемся, эти материалы помогли всем желающим освоить сборку пакетов и ядер Kali, а также подготовку собственных ISO-образов системы.
**Уважаемые читатели!** Расскажите, удалось ли вам самостоятельно выполнить упражнения к этой главе?
Предыдущие части:
→ Часть 1. [Kali Linux: политика безопасности, защита компьютеров и сетевых служб](https://habrahabr.ru/company/ruvds/blog/338338/)
→ Часть 2. [Kali Linux: фильтрация трафика с помощью netfilter](https://habrahabr.ru/company/ruvds/blog/338480/)
→ Часть 3. [Kali Linux: мониторинг и логирование](https://habrahabr.ru/company/ruvds/blog/338668/)
→ Часть 4. [Kali Linux: упражнения по защите и мониторингу системы](https://habrahabr.ru/company/ruvds/blog/338668/)
→ Часть 5. [Kali Linux: оценка защищённости систем](https://habrahabr.ru/company/ruvds/blog/339312/)
→ Часть 6. [Kali Linux: виды проверок информационных систем](https://habrahabr.ru/company/ruvds/blog/339636/)
→ Часть 7. [Kali Linux: формализация исследований и типы атак](https://habrahabr.ru/company/ruvds/blog/339828/)
→ Часть 8. [Kali Linux: контрольные вопросы по исследованию защищённости систем](https://habrahabr.ru/company/ruvds/blog/340198/)
→ Часть 9. [Kali Linux: модификация пакетов](https://habrahabr.ru/company/ruvds/blog/340824/)
→ Часть 10. [Kali Linux: сборка ядра](https://habrahabr.ru/company/ruvds/blog/341428/)
→ Часть 11. [Kali Linux: настройка и сборка ISO-образов](https://habrahabr.ru/company/ruvds/blog/341882/) | https://habr.com/ru/post/342406/ | null | ru | null |
# Простой zero-copy рендеринг аппаратно ускоренного видео в QML
Введение
--------
Целью данной статьи является продемонстрировать способ как можно подружить сторонние видео буфера и QML. Основная идея — использовать стандартный QML компонент VideoOutput. Он позволяет подсовывать сторонние источники, неплохо документирован и имеет бекэнд поддерживающий GL\_OES\_EGL\_image\_external.
Мысль, что это вдруг может быть полезно, возникла после того, как я попытался запустить примеры работы с камерой в Qt, и на embedded платформе они работали со скоростью 3-5 кадра в секунду. Стало ясно, что из коробки ни о каком zero-copy речи не идет, хотя платформа все это отлично поддерживает. Справедливости ради, на десктопе VideoOutput и Camera работают, как и положено, быстро и без лишних копирований. Но в моей задаче, увы, нельзя было обойтись существующими классами для захвата видео, и хотелось завести видео из стороннего источника, каким может быть произвольный GStreamer пайплайн для декодирования видео, к примеру, из файла или RTSP стрим, или сторонний API который интегрировать в базовые классы Qt несколько сомнительно. Можно еще, конечно, в очередной раз переизобрести велосипед и написать свой компонент с рисованием через OpenGL, но это сразу показалось заведомо тупиковым и сложным путем.
Все вело к тому, что нужно разобраться как же оно устроено на самом деле, и написать небольшое приложение подтверждающее теорию.
Теория
------
VideoOutput поддерживает пользовательские source, при условии что
1. переданный объект может принять QAbstractVideoSurface напрямую через свойство videoSurface
2. или через mediaObject с контролом QVideoRendererControl [[ссылка]](https://doc.qt.io/qt-5/qml-qtmultimedia-videooutput.html#source-prop).
Поиск по исходникам и документации показал, что в QtMultimedia есть класс QAbstractVideoBuffer который поддерживает различные типы хэндлов, начиная от QPixmap и заканчивая GLTexture и EGLImage. Дальнейшие поиски привели к плагину videonode\_egl, который отрисовывает пришедший ему кадр при помощи шейдера с samplerExternalOES. Это означает, что после того как мне удасться создать QAbstractVideoBuffer с EGLImage, остается найти способ передать этот буфер в videnode\_egl.
А если EGLImage платформой не поддерживается, то можно обернуть пришедшую память и отправить на отрисовку, благо шейдеры для большинства пиксельных форматов уже реализованы.
Реализация
----------
Пример почти целиком основывается на туториале [Video Overview](https://doc.qt.io/qt-5/videooverview.html#working-with-low-level-video-frames).
Для того чтобы Qt заработало с OpenGL ES на десктопе, необходимо пересобрать Qt с соответствующим флагом. По умолчанию, для десктопа он не включен.
Для простоты мы воспользуемся первым способом, а в качестве источника видео возьмем простой GStreamer пайплайн:
```
v4l2src ! appsink
```
Создадим класс V4L2Source, который будет поставлять фреймы в заданную ему QAbstractVideoSurface.
```
class V4L2Source : public QQuickItem
{
Q_OBJECT
Q_PROPERTY(QAbstractVideoSurface* videoSurface READ videoSurface WRITE
setVideoSurface)
Q_PROPERTY(QString device MEMBER m_device READ device WRITE setDevice)
Q_PROPERTY(QString caps MEMBER m_caps)
public:
V4L2Source(QQuickItem* parent = nullptr);
virtual ~V4L2Source();
void setVideoSurface(QAbstractVideoSurface* surface);
void setDevice(QString device);
public slots:
void start();
void stop();
private slots:
void setWindow(QQuickWindow* win);
void sync();
signals:
void frameReady();
...
}
```
Все достаточно тривиально, кроме слота setWinow() — он нужен чтобы перехватить сигнал QQuickItem::windowChanged() и установить callback на QQuickWindow::beforeSynchronizing().
Так как бэкэнд VideoOutput не всегда умеет работать с EGLImage, то необходимо запросить у QAbstractVideoSurface какие форматы для заданного QAbstractVideoBuffer::HandleType она поддерживает:
```
void V4L2Source::setVideoSurface(QAbstractVideoSurface* surface)
{
if (m_surface != surface && m_surface && m_surface->isActive()) {
m_surface->stop();
}
m_surface = surface;
if (surface
->supportedPixelFormats(
QAbstractVideoBuffer::HandleType::EGLImageHandle)
.size() > 0) {
EGLImageSupported = true;
} else {
EGLImageSupported = false;
}
if (m_surface && m_device.length() > 0) {
start();
}
}
```
Создадим наш пайплайн, и установим необходимые callback'и:
```
GstAppSinkCallbacks V4L2Source::callbacks = {.eos = nullptr,
.new_preroll = nullptr,
.new_sample =
&V4L2Source::on_new_sample};
V4L2Source::V4L2Source(QQuickItem* parent) : QQuickItem(parent)
{
m_surface = nullptr;
connect(this, &QQuickItem::windowChanged, this, &V4L2Source::setWindow);
pipeline = gst_pipeline_new("V4L2Source::pipeline");
v4l2src = gst_element_factory_make("v4l2src", nullptr);
appsink = gst_element_factory_make("appsink", nullptr);
GstPad* pad = gst_element_get_static_pad(appsink, "sink");
gst_pad_add_probe(pad, GST_PAD_PROBE_TYPE_QUERY_BOTH, appsink_pad_probe,
nullptr, nullptr);
gst_object_unref(pad);
gst_app_sink_set_callbacks(GST_APP_SINK(appsink), &callbacks, this,
nullptr);
gst_bin_add_many(GST_BIN(pipeline), v4l2src, appsink, nullptr);
gst_element_link(v4l2src, appsink);
context = g_main_context_new();
loop = g_main_loop_new(context, FALSE);
}
void V4L2Source::setWindow(QQuickWindow* win)
{
if (win) {
connect(win, &QQuickWindow::beforeSynchronizing, this,
&V4L2Source::sync, Qt::DirectConnection);
}
}
GstFlowReturn V4L2Source::on_new_sample(GstAppSink* sink, gpointer data)
{
Q_UNUSED(sink)
V4L2Source* self = (V4L2Source*)data;
QMutexLocker locker(&self->mutex);
self->ready = true;
self->frameReady();
return GST_FLOW_OK;
}
// Request v4l2src allocator to add GstVideoMeta to buffers
static GstPadProbeReturn
appsink_pad_probe(GstPad* pad, GstPadProbeInfo* info, gpointer user_data)
{
if (info->type & GST_PAD_PROBE_TYPE_QUERY_BOTH) {
GstQuery* query = gst_pad_probe_info_get_query(info);
if (GST_QUERY_TYPE(query) == GST_QUERY_ALLOCATION) {
gst_query_add_allocation_meta(query, GST_VIDEO_META_API_TYPE, NULL);
}
}
return GST_PAD_PROBE_OK;
}
```
В конструкторе стандартный код для запуска своего пайплайна, создается GMainContext и GMainLoop чтобы завести пайплайн в отдельном потоке.
Стоит обратить внимание на флаг Qt::DirectConnection в setWindow() — он гарантирует что callback будет вызван в том же потоке что и сигнал, что дает нам доступ к текущему OpenGL контексту.
V4L2Source::on\_new\_sample() который вызывается когда новый кадр из v4l2src приходит в appsink просто выставляет флаг готовности и вызывает соответствующий сигнал, чтобы проинформировать VideoOutput что требуется перерисовать содержимое.
Пробник на sink паде у appsink необходим, чтобы попросить аллокатор v4l2src добавлять мета информацию о видео формате к каждому буферу. Это необходимо чтобы учесть ситуации, когда драйвер выдает видео буфер со страйдом/оффсетом отличными от стандартных.
Обновление видеокадра для VideoOutput происходит в слоте sync():
```
// Make sure this callback is invoked from rendering thread
void V4L2Source::sync()
{
{
QMutexLocker locker(&mutex);
if (!ready) {
return;
}
// reset ready flag
ready = false;
}
// pull available sample and convert GstBuffer into a QAbstractVideoBuffer
GstSample* sample = gst_app_sink_pull_sample(GST_APP_SINK(appsink));
GstBuffer* buffer = gst_sample_get_buffer(sample);
GstVideoMeta* videoMeta = gst_buffer_get_video_meta(buffer);
// if memory is DMABUF and EGLImage is supported by the backend,
// create video buffer with EGLImage handle
videoFrame.reset();
if (EGLImageSupported && buffer_is_dmabuf(buffer)) {
videoBuffer.reset(new GstDmaVideoBuffer(buffer, videoMeta));
} else {
// TODO: support other memory types, probably GL textures?
// just map memory
videoBuffer.reset(new GstVideoBuffer(buffer, videoMeta));
}
QSize size = QSize(videoMeta->width, videoMeta->height);
QVideoFrame::PixelFormat format =
gst_video_format_to_qvideoformat(videoMeta->format);
videoFrame.reset(new QVideoFrame(
static_cast(videoBuffer.get()), size, format));
if (!m\_surface->isActive()) {
m\_format = QVideoSurfaceFormat(size, format);
Q\_ASSERT(m\_surface->start(m\_format) == true);
}
m\_surface->present(\*videoFrame);
gst\_sample\_unref(sample);
}
```
В этой функции мы забираем последний доступный нам буфер из appsink, запрашиваем GstVideoMeta чтобы узнать информацию об оффсетах и страйдах для каждого плейна (что ж, для простоты примера, никакого fallback на случай, если по какой-то причине меты нет, не предусмотрено) и создаем QAbstractVideoBuffer с нужным типом хедла: EGLImage (GstDmaVideoBuffer) или None (GstVideoBuffer). Затем оборачиваем это в QVideoFrame и отправляем в очередь на отрисовку.
Сама реализация GstDmaVideoBuffer и GstVideoBuffer достаточно тривиальна:
```
#define GST_BUFFER_GET_DMAFD(buffer, plane) \
(((plane) < gst_buffer_n_memory((buffer))) ? \
gst_dmabuf_memory_get_fd(gst_buffer_peek_memory((buffer), (plane))) : \
gst_dmabuf_memory_get_fd(gst_buffer_peek_memory((buffer), 0)))
class GstDmaVideoBuffer : public QAbstractVideoBuffer
{
public:
// This should be called from renderer thread
GstDmaVideoBuffer(GstBuffer* buffer, GstVideoMeta* videoMeta) :
QAbstractVideoBuffer(HandleType::EGLImageHandle),
buffer(gst_buffer_ref(buffer)), m_videoMeta(videoMeta)
{
static PFNEGLCREATEIMAGEKHRPROC eglCreateImageKHR =
reinterpret_cast(
eglGetProcAddress("eglCreateImageKHR"));
int idx = 0;
EGLint attribs[MAX\_ATTRIBUTES\_COUNT];
attribs[idx++] = EGL\_WIDTH;
attribs[idx++] = m\_videoMeta->width;
attribs[idx++] = EGL\_HEIGHT;
attribs[idx++] = m\_videoMeta->height;
attribs[idx++] = EGL\_LINUX\_DRM\_FOURCC\_EXT;
attribs[idx++] = gst\_video\_format\_to\_drm\_code(m\_videoMeta->format);
attribs[idx++] = EGL\_DMA\_BUF\_PLANE0\_FD\_EXT;
attribs[idx++] = GST\_BUFFER\_GET\_DMAFD(buffer, 0);
attribs[idx++] = EGL\_DMA\_BUF\_PLANE0\_OFFSET\_EXT;
attribs[idx++] = m\_videoMeta->offset[0];
attribs[idx++] = EGL\_DMA\_BUF\_PLANE0\_PITCH\_EXT;
attribs[idx++] = m\_videoMeta->stride[0];
if (m\_videoMeta->n\_planes > 1) {
attribs[idx++] = EGL\_DMA\_BUF\_PLANE1\_FD\_EXT;
attribs[idx++] = GST\_BUFFER\_GET\_DMAFD(buffer, 1);
attribs[idx++] = EGL\_DMA\_BUF\_PLANE1\_OFFSET\_EXT;
attribs[idx++] = m\_videoMeta->offset[1];
attribs[idx++] = EGL\_DMA\_BUF\_PLANE1\_PITCH\_EXT;
attribs[idx++] = m\_videoMeta->stride[1];
}
if (m\_videoMeta->n\_planes > 2) {
attribs[idx++] = EGL\_DMA\_BUF\_PLANE2\_FD\_EXT;
attribs[idx++] = GST\_BUFFER\_GET\_DMAFD(buffer, 2);
attribs[idx++] = EGL\_DMA\_BUF\_PLANE2\_OFFSET\_EXT;
attribs[idx++] = m\_videoMeta->offset[2];
attribs[idx++] = EGL\_DMA\_BUF\_PLANE2\_PITCH\_EXT;
attribs[idx++] = m\_videoMeta->stride[2];
}
attribs[idx++] = EGL\_NONE;
auto m\_qOpenGLContext = QOpenGLContext::currentContext();
QEGLNativeContext qEglContext =
qvariant\_cast(m\_qOpenGLContext->nativeHandle());
EGLDisplay dpy = qEglContext.display();
Q\_ASSERT(dpy != EGL\_NO\_DISPLAY);
image = eglCreateImageKHR(dpy, EGL\_NO\_CONTEXT, EGL\_LINUX\_DMA\_BUF\_EXT,
(EGLClientBuffer) nullptr, attribs);
Q\_ASSERT(image != EGL\_NO\_IMAGE\_KHR);
}
...
// This should be called from renderer thread
~GstDmaVideoBuffer() override
{
static PFNEGLDESTROYIMAGEKHRPROC eglDestroyImageKHR =
reinterpret\_cast(
eglGetProcAddress("eglDestroyImageKHR"));
auto m\_qOpenGLContext = QOpenGLContext::currentContext();
QEGLNativeContext qEglContext =
qvariant\_cast(m\_qOpenGLContext->nativeHandle());
EGLDisplay dpy = qEglContext.display();
Q\_ASSERT(dpy != EGL\_NO\_DISPLAY);
eglDestroyImageKHR(dpy, image);
gst\_buffer\_unref(buffer);
}
private:
EGLImage image;
GstBuffer\* buffer;
GstVideoMeta\* m\_videoMeta;
};
class GstVideoBuffer : public QAbstractPlanarVideoBuffer
{
public:
GstVideoBuffer(GstBuffer\* buffer, GstVideoMeta\* videoMeta) :
QAbstractPlanarVideoBuffer(HandleType::NoHandle),
m\_buffer(gst\_buffer\_ref(buffer)), m\_videoMeta(videoMeta),
m\_mode(QAbstractVideoBuffer::MapMode::NotMapped)
{
}
QVariant handle() const override
{
return QVariant();
}
void release() override
{
}
int map(MapMode mode,
int\* numBytes,
int bytesPerLine[4],
uchar\* data[4]) override
{
int size = 0;
const GstMapFlags flags =
GstMapFlags(((mode & ReadOnly) ? GST\_MAP\_READ : 0) |
((mode & WriteOnly) ? GST\_MAP\_WRITE : 0));
if (mode == NotMapped || m\_mode != NotMapped) {
return 0;
} else {
for (int i = 0; i < m\_videoMeta->n\_planes; i++) {
gst\_video\_meta\_map(m\_videoMeta, i, &m\_mapInfo[i],
(gpointer\*)&data[i], &bytesPerLine[i],
flags);
size += m\_mapInfo[i].size;
}
}
m\_mode = mode;
\*numBytes = size;
return m\_videoMeta->n\_planes;
}
MapMode mapMode() const override
{
return m\_mode;
}
void unmap() override
{
if (m\_mode != NotMapped) {
for (int i = 0; i < m\_videoMeta->n\_planes; i++) {
gst\_video\_meta\_unmap(m\_videoMeta, i, &m\_mapInfo[i]);
}
}
m\_mode = NotMapped;
}
~GstVideoBuffer() override
{
unmap();
gst\_buffer\_unref(m\_buffer);
}
private:
GstBuffer\* m\_buffer;
MapMode m\_mode;
GstVideoMeta\* m\_videoMeta;
GstMapInfo m\_mapInfo[4];
};
```
После всего этого мы можем собрать QML страничку следующего вида:
```
import QtQuick 2.10
import QtQuick.Window 2.10
import QtQuick.Layouts 1.10
import QtQuick.Controls 2.0
import QtMultimedia 5.10
import v4l2source 1.0
Window {
visible: true
width: 640
height: 480
title: qsTr("qml zero copy rendering")
color: "black"
CameraSource {
id: camera
device: "/dev/video0"
onFrameReady: videoOutput.update()
}
VideoOutput {
id: videoOutput
source: camera
anchors.fill: parent
}
onClosing: camera.stop()
}
```
Выводы
------
Целью данной статьи было показать, как интегрировать существующий API, который способен выдавать аппаратно-ускоренное видео, с QML и использовать существующие компоненты для отрисовки без копирования (ну или в худшем случае с одним, но без дорогостоящего софтверного конвертирования в RGB).
[Ссылка на код](https://github.com/Rambden/qml-zero-copy-example/tree/master)
Ссылки
------
* <https://habr.com/ru/post/481540/>
* <https://habr.com/ru/post/254625/>
* <https://doc.qt.io/qt-5/videooverview.html>
* <https://doc.qt.io/qt-5/qml-qtmultimedia-videooutput.html>
* <https://doc.qt.io/qt-5/qtquick-visualcanvas-scenegraph.html>
* <https://doc.qt.io/qt-5.12/qtquick-scenegraph-openglunderqml-example.html> | https://habr.com/ru/post/486062/ | null | ru | null |
# PostgreSQL 8.3
 Джош Беркус (Josh Berkus) [объявил](http://www.postgresql.org/about/news.872) о выходе PostgreSQL 8.3beta1 (см. [официальный Changelog](http://www.postgresql.org/docs/8.3/static/release-8-3.html)). Более полугода потребовалось разработчикам для того, чтобы завершить работу по обработке патчей (напомним, feature freeze состоялся 1-го апреля 2007 года). Так что самое время рассказать, чем же порадует нас в этом году самая развитая из открытых СУБД в мире.
Я разобью весь список на четыре части. В первой, для многих самой важной, части я перечислю изменения, которые так или иначе касаются производительности. Во второй — приведу список новых возможностей для программистов баз данных, призванных ещё более расширить и без того неслабый набор «фич» PostgreSQL. Третья часть посвящена нововведениям, предназначенным для администраторов баз данных. И, наконец, в конце я упомяну некоторые Open Source проекты, которые являются проектами-спутниками Постгреса (другими словами, имеют свой собственный цикл разработки).
Производительность
------------------
Начнём с того, что сегодня (на данный момент стабильная ветка — 8.2, актуальная версия — 8.2.5) PostgreSQL успешно тягается в плане производительности не только с OpenSource-альтернативами, но и с ведущими коммерческими СУБД. Такими как Oracle. Это уже не пустой звук — взгляните на результаты [тестирования](http://postgresmen.ru/news/view/44), проведённого в компании Sun. Медленных слонов больше нет! Богатейший набор типов индексов, широчайшие возможности тюнинга системы, работа с очень большими объёмами и нагрузками, хороший выбор систем репликации и масштабирования — всё это «по зубам» современным слонам. Даже скорость разработки выгодно отличает Постгрес по сравнению с другими СУБД: каждый год мы неизменно получаем существенный шаг вперёд.
Что же нового в PostgreSQL версии 8.3 в плане производительности? Многие изменения нетривиальны. По словам координатора разработки PostgreSQL Брюса Момджана ([Bruce Momjian](http://momjian.us/)), нанёсшего не так давно по приглашению компании «Постгресмен» [визит в Москву](http://postgresmen.ru/news/view/62), та работа по оптимизации производительности системы, которой заняты разработчики Постгреса в последние годы, является чрезвычайно сложной. Каждый шаг требует всё более и более существенных трудозатрат, занимает всё больше времени и сил разработчиков.
Одним из таких действительно нетривиальных изменений можно смело считать «фишку» под названием **HOT (Heap Only Tuples)**. Это, пожалуй, одно из самых существенных изменений в плане производительности. Чтобы понять, в чём заключается данное изменение, необходимо вспомнить, что PostgreSQL реализует так называемую мультиверсионную модель разграничения доступа ([MVCC](http://en.wikipedia.org/wiki/Multiversion_concurrency_control), Multi-Version Concurrency Control).
Суть HOT в следующем. Ранее, до реализации данного подхода, при обновлении строки в таблице каждая новая её версия приводила к появлению новых версий всех индексов, независимо от того, затрагивали ли данные изменения проиндексированные столбцы или нет (см. рис. «Обновление без HOT»). Теперь же, если новая версия строки попадает в ту же страницу памяти, что и предыдущая, и столбцы, по которым был создан индекс, не изменялись, индекс остаётся прежним. Но это ещё не всё. Если есть такая возможность, происходит «моментальное» повторное использование места в странице Heap. Что, естественно, сокращает объём работы, производимой при операции VACUUM. На рис. «HOT-обновление» схематически отображено, каким образом происходит теперь обновление строки.
Следующая новинка придётся по вкусу, прежде всего, большому количеству веб-разработчиков. Начиная с версии 8.3 любую транзакцию в PostgreSQL можно делать **«асинхронной»**.
Это означает, что при выполнении операции фиксации транзакции (COMMIT) сервер PostgreSQL не будет ждать завершения дорогостоящей операции синхронизации журнала транзакций (WAL fsync). Другими словами, транзакция будет считаться успешно завершённой сразу же, как только все логические условия будут выполнены (проверены все необходимые ограничения целостности). Физически запись в журнал транзакций произойдёт через очень малый промежуток времени (как правило, для нормально функционирующих систем это максимум 200-1000 мс).За состояние транзакции (синхронная/асинхронная) отвечает переменная окружения synchronous\_commit. Перейти в асинхронный режим просто:
> `SET synchronous_commit TO OFF;`
Стоит отметить, что асинхронные транзакции не являются альтернативой режиму работы сервера с отключенной операций fsync. Дело в том, что режим fsync=off может привести к получению несогласованного состояния базы (к примеру, в случае непредвиденного отказа оборудования или потери питания) и рекомендуется только в тех случаях, когда используется оборудование высокой надёжности (например, контроллер дисков с батарейкой). Использование же новой возможности никак не может привести к рассогласованию данных. Максимум, что возможно, это потеря небольшой порции данных (опять-таки, в случае жёсткого сбоя сервера — ошибки ОС, оборудования, сбой питания). Типичным примером для асинхронных транзакций может служить задача сохранения большого количества информации в таблицу-журнал (например, лог действий пользователя), когда потеря нескольких строк не является критичной. При этом все важные транзакции могут по-прежнему быть синхронными.
Ещё одно улучшение в области производительности относится к ситуациям, когда при выполнении запросов PostgreSQL последовательно просматривает таблицы (операция SeqScan). Если до версии 8.3 в таких случаях нередко возникали ситуации, когда разные процесса Постгреса одновременно делали одну и ту же работу — просматривали одну и ту же таблицу — то теперь, благодаря реализации **Synchronized Scans («синронизованные просмотры»)**, в один и тот же момент времени для одной таблицы может проводиться не более одной операции просмотра. Достигается это следующим образом. Если в рамках какой-либо сессии требуется проведение SeqScan-а для некоторой таблицы, для которой уже выполняется SeqScan (для другой сессии), то произойдёт «прыжок на ходу» к результатам уже выполняющегося SeqScan-а. По завершении данного процесса, если это необходимо, будет осуществлён «добор» результатов с помощью ещё одного неполного SeqScan-а (см. рис).
Работа над уменьшением стресс-эффекта, производимого выполнением системой процессов checkpoint («контрольная точка») продолжается: теперь checkpoint-ы выполняются не сразу, а постепенно: процесс как бы «размазан» во времени. Отсюда и название данного изменения — **checkpoint smoothing**. Стоит отметить, что при штатном выключении сервера и проведениия «явной» операции checkpoint (команда [CHECKPOINT](http://www.postgresql.org/docs/current/interactive/sql-checkpoint.html)) запись данных на диск по-прежнему будет производиться с максимально возможной скоростью.
В завершение разговора о производительности, приведём краткий перечень других изменений, призванных улучшить быстродействие систем, использующих PostgreSQL:
* теперь **autovacuum включён по умолчанию**;
* в некоторых ситуациях теперь возможнен **запуск сразу нескольких процессов autovacuum** (например, при продолжительном процессе чистки большой таблицы, небольшие таблицы теперь не вынуждены ждать завершения данного процесса);
* заметное **уменьшение дискового пространства**, занимаемого базами данных: 1) за счёт заголовков varlena-типов (типы данных переменной длины: текст, массивы и т. п.), которые ранее занимали строго 4 байта, а теперь в некоторых ситуациях всего 1 байт; 2) за счёт экономии заголовков строк таблицы (ранее 27 байт, теперь — 24);
* **выполнение транзакций, не модифицирующих данные, не приводит к увеличению значения счётчика транзакций (xid)**, что существенно снижает вероятность ситуации «перекрытия» счётчика транзакций (xid wraparound); кроме того, данное изменение является значительным шагом вперёд к реализации встроенной Master-Slave репликации на основе трансфера журнала транзакций — теперь не возникнет рассинхронизации счётчика xid между Master- и Slave-узлами;
* реализован **механизм автонастройки параметров процесса bgwriter** (background writer — специальный процесс, занимающийся записью «грязных» разделяемых буферов на диск);
* оптимизирован механизм получения результата для запросов с использованием «`…ORDER BY … LIMIT…`» (т. н., **Top-N sorting**): в некоторых случаях система удерживает необходимые страницы данных в оперативной памяти, что обеспечивает очень высокую скорость выдачи результата;
* теперь можно задавать (пока только в виде двух констант) оценочную стоимость выполнения фунции и оценку количества рядов, которые она возвращает, что позволяет планнеру PostgreSQL выбирать лучший план запроса (пример: `ALTER FUNCTION log_data(text) COST 100000 ROWS 1`).
Разработчикам баз данных
------------------------
Самое заметное и существенное изменение, которое следует здесь отметить, — это **миграция модуля для полнотекстового поиска (contrib/tsearch2) в ядро системы**. Разрабатываемый российскими разработчиками [Олегом Бартуновым](http://www.sai.msu.su/~megera/) и [Фёдором Сигаевым](http://sigaev.ru/), tsearch2 долгое время являлся самым популярным contrib-модулем Постгреса. Патч для миграции полнотекстового поиска в ядро, который был [принят этим летом](http://http//postgresmen.ru/news/view/53) в результате кропотливой и продолжительной работы (принятая версия патча — 58!) сразу нескольких ключевых разработчиков команды PostgreSQL, является самым большим за всю историю проекта.
Кроме того, что все возможности модуля tsearch2 теперь будут доступны по умолчанию и процессы миграции на новую версию PostgreSQL заметно упростятся, конфигурировать словари и правила обработки текстов теперь станет проще: все основные операции по конфигурированию осуществляются с помощью SQL-команд. Вот так, например, можно создать простой словарь-тезаурус:
>
> ```
> СREATE TEXT SEARCH DICTIONARY thesaurus_astro (
> TEMPLATE = thesaurus,
> DictFile = thesaurus_astro,
> Dictionary = english_stem
> );
> ALTER TEXT SEARCH CONFIGURATION russian
> ADD MAPPING FOR lword, lhword, lpart_hword
> WITH thesaurus_astro, english_stem;
> ```
>
Упростились и процессы создания индекса. Пример создания GIN-индекса над обычным текстовым столбцом (без создания дополнительных столбцов и триггеров):
>
> ```
> CREATE INDEX pgweb_idx ON pgweb
> USING gin(to_tsvector('russian', title || body));
> ```
>
А вот пример запроса с ранжированием по релевантности, использующий к тому же специальную функцию plainto\_tsquery для получения tsquery (позволяет забыть об экранировании символов и быстро и просто преобразовать обычный текст в tsquery):
>
> ```
> SELECT
> ts_rank_cd(textsearch_index, q) AS rank, title
> FROM
> pgweb, plainto_tsquery('supernova star') q
> WHERE
> q @@ textsearch_index
> ORDER BY
> rank DESC LIMIT 10;
> ```
>
Другое заметное изменение — **поддержка XML**, в работе над которой принимал участие автор данной статьи. Данный функционал реализован в соответствии со стандартом SQL:2003 (14-я часть стандарта, SQL/XML).
Прежде всего, появился специальный тип данных `xml`, встроенный в ядро. При использовании данного типа, сервер проверяет, правильно ли сформированы данные (проверка на [well-formedness](http://www.w3.org/TR/REC-xml/#sec-well-formed)). Причём возможны варианты использования, при которых разрешена работа с частями документа (это позволяет обеспечить свойство «замкнутости» функций для работы с XML на тип данных `xml`).
В соответствии со стандартом SQL:2003 реализован набор функций для преобразования реляционных данных в XML (т. н., функции публикации SQL/XML). Вот простой пример запроса на формирование XML-данных:
>
> ```
> SELECT XMLROOT (
> XMLELEMENT (
> NAME 'some',
> XMLATTRIBUTES (
> 'val' AS 'name',
> 1 + 1 AS 'num'
> ),
> XMLELEMENT (
> NAME 'more',
> 'foo'
> )
> ),
> VERSION '1.0',
> STANDALONE YES
> );
> ```
>
Кроме того, реализована поддержка DTD-валидации (функция `xmlvalidatedtd()`), поддержка оценки XPath-выражений (функция `xpath()`, возвращающая массив из данных типа xml ), и альтернативные функции для упрощённой публикации реляционных данных в виде XML (функции `tabletoxml()`, `querytoxml()` и другие).
Для ускорения выполнения запроса к XML-данным возможно использование функциональных btree-индексов и GIN-индексов, а также использования полнотекстового поиска для XML-данных. Приведём пример создания btree-индекса по результатам оценки XPath-выражения:
>
> ```
> CREATE INDEX i_table1_xdata ON table1 USING btree(
> ((xpath(’//person/@name’, xdata))[1])
> );
> ```
>
Что касается типов данных, PostgreSQL 8.3 представляет целый ряд нововведений: помимо встроенных в ядро системы типов `tsquery/tsvector` и `xml`, появились следующие:
* **`enum`** (перечислимые типы данных, определяемые пользователем) для удобства некоторых пользователей, в том числе мигрирующих с TheirSQL;
* типы данных **GUID/UUID** (в виде contrib-модуля);
* **массивы составных типов** (например, определённых пользователем типов).
И наконец, краткий список остальных изменений:
* автоматическая **инвалидация кэша плана запросов** для PL/pgSQL-функций;
* конструкции **«`CREATE FUNCTION … RETURNS TABLE`» и «`RETURN TABLE…`»** для создания функций, результатом которых является таблица;
* поддержка **операции обновления для курсоров**;
* стандартная (ISO/ANSI SQL) конструкция **«`ORDER BY … NULLS FIRST/LAST`»** для упрощения установки порядка следования NULL-значений (также помогает при миграции с других СУБД);
* индексация NULL-значений в GiST-индексах.
Администраторам баз данных
--------------------------
Данный раздел получился куцым, ибо многое из того, что призвано улучшить жизнь DBA, описано выше :-) Тем не менее, расскажем кратко о том, что осталось.
В планах запросов (команда [EXPLAIN ANALYZE](http://www.postgresql.org/docs/8.2/interactive/sql-explain.html)) теперь **видно, какой именно алгоритм сортировки был выбран и сколько памяти было израсходовано**:
>
> ```
> QUERY PLAN
> -------------------------------------------------------
> Sort (cost=34.38..34.42 rows=13 width=176) (actual time=0.946..0.948 rows=6 loops=1)
> Sort Key: obj2tag.o2t_tag_name
> Sort Method: quicksort Memory: 18kB <-- см. сюда!
> -> Hash Join (cost=19.19..34.14 rows=13 width=176) (actual time=0.812..0.835 rows=6 loops=1)
> [...]
> ```
>
Специальный contrib-модуль **pg\_standby**, написанный Саймоном Ригсом ([Simon Riggs](http://www.2ndquadrant.com/)) упростит работу администраторам, настраивающим сервер «тёплого бэкапа» (Warm Standby) на основе трансфера журнала логов (WAL transfer). Модуль написан на чистом C, поэтому является легко расширяемым и портируемым на новые платформы (работоспособность проверена уже, по крайней мере, на Linux и Win32).
При определении функции теперь можно переопределять переменные окружения, которые будут действовать только в рамках выполнения данной функции (**привязка значений переменных функциям**). Например, вот так можно указать, что выполнение функции `log _data()` переключает транзакцию в режим асинхронности:
>
> ```
> ALTER FUNCTION log_data(text)
> SET synchronous_commit TO OFF;
>
> ```
>
Ну и, по традиции, краткий список других новинок данного раздела:
* поддержка интерфейса **[GSSAPI](http://en.wikipedia.org/wiki/Generic_Security_Services_Application_Program_Interface)**;
* **улучшенная сборка на платформе Win32** (теперь не требуется MinGW, сборка ведётся в MS VC++, что помимо прочего приводит к улучшению производительности в Windows);
* **создание таблиц по подобию с учётом индексов** (пример: `CREATE TABLE dict2 (LIKE dictionary INCLUDING INDEXES`)).
Дополнительные проекты
----------------------
Компания [EnterpriseDB](http://enterprisedb.com/) (сотрудники которой являются активным разработчиками PostgreSQL, многие изменения версии 8.3 в области производительности являются именно их заслугой) выпустила **отладчик [pldebugger](http://pgfoundry.org/projects/edb-debugger/)**, который представляет собой contrib-модуль, позволяющий отлаживать PL/pgSQL-функции в стандартном инструменте для администрирования [pgAdminIII](http://www.pgadmin.org/) и осуществлять профайлинг.
Проект в данный момент существует в виде независимого contrib-модуля (представлен на [PgFoundry](http://pgfoundry.org/)) и работает на большом количестве платформ (включая Linux и Win32). Стоит отметить, что данный модуль работает и с версией 8.2 Постгреса.
Как мы [рассказывали не так давно](http://postgresmen.ru/articles/view/25), компания [**Skype**](http://skype.com/) (которая использует в широко известном одноимённом проекте именно PostgreSQL) выпустила в Open Source сразу несколько продуктов, которые могут быть полезны большому кругу разработчиков. Среди них прежде всего стоит отметить псевдо-язык [**PL/Proxy**](http://https//developer.skype.com/SkypeGarage/DbProjects/PlProxy), позволяющий организовывать горизонтальное масштабирование практически без ограничений (при условии, если вся бизнес-логика приложения реализована в виде хранимых процедур), чрезвычайно лёгкий менеджер соединений [**PgBouncer**](http://https//developer.skype.com/SkypeGarage/DbProjects/PgBouncer). Загляните на страничку [Skype Developers Zone](https://developer.skype.com/SkypeGarage/DbProjects/), вы найдёте много интересного!
На рубеже весны и лета 2007-го года вышла версия 1.0 простого и удобного **инструмента для анализа логов [pgFouine](http://pgfouine.projects.postgresql.org/)**. Данная программа поможет вам узнать, чем же занимался ваш процессор (процессоры) сервера баз данных. pgFoiune анализирует логи запросов Постгреса (при включении журнализации запросов рекомендуется вводить ограничение по времени снизу, см. описание параметра [`log_min_duration_statement`](http://www.postgresql.org/docs/current/static/runtime-config-logging.html#GUC-LOG-MIN-DURATION-STATEMENT)), предоставляя отчёты по самым медленным запросам, ошибкам и общую статистику (см. [примеры](http://pgfouine.projects.postgresql.org/reports.html)). Тем самым данный инструмент позволяет разработчику баз данных понять, какие запросы можно улучшить, чтобы ускорить работу приложения, использующего PostgreSQL.
И наконец, кратко об остальных продуктах:
* проект [**pgSNMP**](http://pgsnmpd.projects.postgresql.org/) является реализацией SNMP-агента для PostgreSQL (мониторинг состояния сервера);
* **SEPostgres** – расширение, основанное на модели обеспечения усиленной безопасности [SELinux](http://en.wikipedia.org/wiki/SELinux);
* создан инструмент, создающий рекомендации администратору баз данных по созданию индексов и показывающий возможный план выполнения запроса при условии наличия таких индексов (**Index Advisor**);
* в известном инструменте для web-администрирования **phppgadmin** появились (или вот-вот появятся) возможности **настройки Slony-кластера, полнотекстового поиска, параметров автовакуума**.
Заключение
----------
Версия 8.3 является очередным шагом на пути к полноценной системе управления баз данных для корпоративного использования. Нетривиальные улучшения в области производительности, появление возможностей, которые продиктованы нуждами пользователей, расширение множества проектов-спутников — всё это демонстрирует уверенное и быстрое развитие PostgreSQL.
При написании данного обзора автор использовал следующие источники:
* [pgwiki/WhatsNew83](http://developer.postgresql.org/index.php/WhatsNew83)
* [pgwiki/Feature\_Matrix](http://developer.postgresql.org/index.php/Feature_Matrix)
* [pgwiki/8.3\_Changelog](http://developer.postgresql.org/index.php/8.3_Changelog)
* [pgwiki/Todo:PatchStatus](http://developer.postgresql.org/index.php/Todo:PatchStatus)
* Доклад Брюса Момджана на конференции Highload-2007, Москва ([pdf](http://momjian.us/main/writings/pgsql/features.pdf)).
* Официальная [документация PostgreSQL 8.3](http://www.postgresql.org/docs/8.3/static/index.html).
* Архив рассылки [pgsql-hackers](http://archives.postgresql.org/pgsql-hackers/). | https://habr.com/ru/post/14933/ | null | ru | null |
# Telegram MTPROTO Proxy — всё что мы знаем о нём
Сразу после событий с блокировками Telegram в Иране и России, в бета-версиях мессенджера начал появлятся новый тип Proxy, а если быть точным, новый протокол — MTProto Proxy.
Этот протокол был создан командой Telegram для решения проблем обхода блокировок, но так ли он хорош?
Как сейчас?
-----------
Основный тип прокси с которым сейчас работает телеграм — socks. У него есть фатальный недостаток: **Логин и пароль** при подключении к прокси — **передаётся в открытом виде**, нет, ваш телеграм таким образом «увести» нельзя, но вот заглянуть внутрь прокси и понять, что Иван Иванов пользуется телеграмом — можно.
В тех странах, которые используют DPI для анализа трафика, так и сделано. Это устройство разбирает туннель и смотрит, что же там внутри, если видит запрещенный трафик — блокируем.
Что предлагает Дуров?
---------------------
MTProto Proxy — протокол семейства MTProto (на нем работает Telegram), решает сразу несколько проблем:
1. Для подключения вместо логин+пароль, достаточно только пароля
2. Трафик не отличается от обычного HTTPS/TLS (ну почти)
3. Пароль не передается до сервера при подключении
4. Трафик зашифрован
5. Возможна работа через прокси только Telegram'a *(другие приложения работать не будут)*
6. Promoted каналы
Как вы видите — набор особенностей делает данный тип прокси узкоспециальным — для Telegram, обычный трафик вы туда не сможете передавать и это, как не странно — огромный плюс.
Только Telegram
---------------
Ранее каналы (и боты) делали свои прокси и раздавали их в мир для сохранения аудитории в случае блокировки. Их прокси попадали в глобальные списки прокси и через них осуществлялись рассылки спама и другие нехорошие вещи. С новым типом прокси — вы не сможете нарушить закон, максимум что произойдет — telegram забанит ваш IP-адрес.
*Пример нарушения закона в случае с socks: Через ваш прокси пытались взломать банк/гос.ведомство, ваш хостер получит официальную жалобу и в самом лучшем случае просто вас заблокирует, в худшем — велкам ту суд.*
Promoted-каналы
---------------
Promoted-каналы — это такой канал, на который вы автоматически будете подписаны при подключении к прокси, он будет закреплен наверху списка контактов/чатов и его нельзя удалить пока вы не отключитесь от данного прокси.
Грубо говоря, telegram позволяет монетизировать proxy, если раньше вы могли взять прокси от канала X (тк он работает быстрее), но вообще его не читать а пойти читать Y, (а при этом, канал X тратит деньги на поддержку прокси в пустоту), то теперь за пользования прокси вы будете платить подписью на канал.
Таким образом, можно ожидать взрывной рост таких прокси, если ранее создание прокси было больше порывом доброй воли или благотворительностью, то сейчас — чем больше пользователей на вашем прокси = тем больше подписчиков у канала --> рекламу можно продать дороже.
Трафик зашифрован
-----------------
Запустив Wireshark я пошел смотреть, как же выглядит трафик при работе через прокси. А выглядит он как обычное TCP/SSL соединение *(без некоторых пакетов/заголовков которые относятся к https)*. Другими словами, трафик может маскироватся под такие решения как Cisco Anyconnect и аналогичные решения которые используют TCP+SSL.
Внутри тоннеля — «каша» из шифрованного трафика, трафик зашифрован, как можно догадатся, тем самым паролем/секретной фразой которую вы вводите при подключении. Но не только ей, конечно же, тут используются все возможности SSL/TLS.
Когда будет в продакшене?
-------------------------
На данный момент, MTProto Proxy доступен в стабильной версии Telegram for OS X, Telegram or Android, и в бета-версиях Telegram Desktop, iOS Telegram X.
Похоже мы ждем релиза в «продакшен» данного прокси в клиентах Desktop и обычная iOS версия (не Х) сразу после этого, мы должны увидеть новый пост от команды с рассказом о том, почему это хорошо и как жить дальше.
А потестировать где?
--------------------
На просторах чатов в телеграмм был найден полу-официальный прокси который прекрасно работает с новым протоколом и *(похоже)* запущен одним из разработчиков, собственно вот он:
[t.me/proxy?server=proxy.digitalresistance.dog&port=443&secret=d41d8cd98f00b204e9800998ecf8427e](https://t.me/proxy?server=proxy.digitalresistance.dog&port=443&secret=d41d8cd98f00b204e9800998ecf8427e)
Но и это еще не все, энтузиасты на Github методом анализа исходников пытаются сделать свои прокси сервера (пока официального еще нет), [вот *(PHP)*](https://github.com/danog/MadelineProto) [пару *(C#)*](https://github.com/TGMTProto/MTProtoProxy) [проектов *(Rust)*](https://github.com/dotcypress/mtproxy).
PS А еще в самой [свежей версии библиотеки](https://github.com/grishka/libtgvoip/commits/public) для VOIP звонков которая используется в telegram найдена поддержка режима конференций, похоже скоро будет сразу два больших анонса.
**UPD:** MTProto proxy — в данный момент часть инфраструктуры Telegram и когда телеграм «бегает» от блокировок — он именно множит и переносит копии своего MTProto Proxy между хостерами, сами же обрабатывающие сервера никуда не переезжают. Таким образом, в скором времени, Telegram позволит часть своей инфраструктуры развернуть у себя. *(Протокол «родных» прокси может отличатся от того, что телеграм в данный момент реализует у себя в клиентах под названием MTPROTO)*
**UPD:** [Аналогичный пост от Анны](http://telegra.ph/telegram-blocks-wtf-05-26) *(Vee Security)* по поводу видов прокси в Telegram и про MTProto Proxy *(включая разбор конкретного вида шифрования)*
**UPD:** MTProto Proxy от [создателей](https://t.me/unkn0wnerror) TgVPN [mtproto.tgproxy.cloud/mtproxy.html](https://mtproto.tgproxy.cloud/mtproxy.html) просят протестировать
**UPD:** Самая стабильная версия сервера MTProto (на мой взгляд) — на Rust, доступна на Github [github.com/dotcypress/mtproxy](https://github.com/dotcypress/mtproxy)
Самый простой вариант для запуска «своего» прокси:
```
sudo docker run --name 'mtproto_proxy' --restart unless-stopped -p 1984:1984 -dti dotcypress/mtproxy -s 'proxy secret'
```
Вместо *proxy secret* — стоит указать свою фразу на основе которой будет сгенерирован ключ
Получить ключ:
```
docker logs mtproto_proxy
``` | https://habr.com/ru/post/359348/ | null | ru | null |
# Сэмплирование Томпсона
Сэмплирование Томпсона — это один из самых сложных способов решения задачи «многорукого бандита».
Задача
------
Маленький Робот потерялся в торговом центре. С помощью обучения с подкреплением мы хотим помочь ему найти свою маму. Но прежде чем он начнёт её искать, ему нужно подзарядиться от набора розеток, каждая из которых даёт разное количество энергии.
С помощью стратегий из задачи про **многорукого бандита** нам нужно найти лучшую розетку в кратчайшие сроки, чтобы Маленький Робот подзарядился и отправился в путь.
Маленький Робот вошёл в комнату подзарядки. В ней 5 розеток, каждая выдаёт разное количество энергии. Нужно, чтобы Маленький Робот как можно быстрее зарядился, поэтому необходимо найти лучшую розетку и подключиться к ней.
Эта задача аналогична задаче про многорукого бандита, за исключением того, что вместо поиска игрового автомата, дающего максимальный выигрыш, мы ищем розетку с наилучшим объёмом энергии.
Сэмплирование Томпсона
----------------------
Во всех методах, которые мы ранее рассматривали, действия выбирались на основе текущих средних значениях вознаграждений, получаемых за эти действия. Сэмплирование Томпсона (иногда его называют алгоритмом байесовых бандитов) работает иначе: вместо уточнения прогноза среднего вознаграждения она расширяет его, чтобы построить вероятностную модель из полученных вознаграждений, а затем выбрать на её основе действие.
В этом случае не только повышается точность прогнозирования возможного вознаграждения, так ещё и модель оценивает некую достоверность этого вознаграждения, и эта достоверность растёт по мере сбора данных. Такой процесс обновления прогноза с появлением новых доказательств называется **байесовским выводом** (Bayesian Inference).
Сэмплирование Бернулли-Томпсона
-------------------------------
Давайте в качестве введения, и чтобы легче было работать, упростим задачу с поиском розетки. Вместо того, чтобы каждая розетка возвращала разное количество заряда, пусть они либо заряжают, либо нет. Тогда у вознаграждения будет два возможных значения: 1 — розетка заряжает, 0 — розетка не заряжает. Если у случайной величины лишь два возможных значения, её поведение можно описать с помощью [распределения Бернулли](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D1%81%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5_%D0%91%D0%B5%D1%80%D0%BD%D1%83%D0%BB%D0%BB%D0%B8).
Теперь вместо количества энергии в розетках меняется вероятность заряжания как такового. Нам нужно найти розетку с максимальной вероятностью заряжания, а не розетку с максимальным количеством энергии.
Итак, при сэмплировании Томпсона получается модель вероятностей вознаграждения. Когда доступность вознаграждения является бинарной (как в этом случае, да или нет), идеальной моделью для такой вероятности является [бета-распределение](https://ru.wikipedia.org/wiki/%D0%91%D0%B5%D1%82%D0%B0-%D1%80%D0%B0%D1%81%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5). Подробнее о взаимосвязи бета-распределения и распределения Бернулли читайте [здесь](https://towardsdatascience.com/beta-distribution-intuition-examples-and-derivation-cf00f4db57af).
Бета-распределение зависит от двух параметров: и . Проще говоря, это счётчики числа успехов и неудач. Также у бета-распределения есть усреднённое значение, вычисляемое как:
Изначально мы не знаем, какова вероятность наличия энергии в какой-либо розетке, потому можно присвоить альфе и бете значение 1, что даст нам **равномерное распределение** (на иллюстрации 1 показано красным). Это начальное предположение называется [априорной вероятностью](https://ru.wikipedia.org/wiki/%D0%90%D0%BF%D1%80%D0%B8%D0%BE%D1%80%D0%BD%D0%B0%D1%8F_%D0%B2%D0%B5%D1%80%D0%BE%D1%8F%D1%82%D0%BD%D0%BE%D1%81%D1%82%D1%8C): вероятность возникновения какого-то события до того, как мы получили какие-либо сведения о нем; в данном случае она представлена бета-распределением 
Проверив розетку и получив вознаграждение, мы можем скорректировать наши ожидания того, что розетка работает. Такая новая вероятность после получения каких-то сведений называется [апостериорной вероятностью](https://ru.wikipedia.org/wiki/%D0%90%D0%BF%D0%BE%D1%81%D1%82%D0%B5%D1%80%D0%B8%D0%BE%D1%80%D0%BD%D0%B0%D1%8F_%D0%B2%D0%B5%D1%80%D0%BE%D1%8F%D1%82%D0%BD%D0%BE%D1%81%D1%82%D1%8C). Она тоже представлена бета-распределением, но теперь мы обновили значения и на основе полученного вознаграждения.
Если розетка работает, то вознаграждение равно 1, и — счётчик успехов — увеличивается на 1. - счётчик неудач — не растёт. Если же мы не получим вознаграждение, то  не изменится, а увеличится на 1. Чем больше мы собираем данных, тем сильнее бета-распределение начинает отличаться от прямой линии и становится всё более точной моделью вероятности усреднённого вознаграждения. Поддерживая значения  и , алгоритм сэмплирования Томпсона может описать ожидаемое среднее вознаграждение и уровень его достоверности.
В отличие от жадного алгоритма, в котором на каждом временном шаге выбирается действие с наивысшим ожидаемым вознаграждением, даже если достоверность ожидания невысока, сэмплирование Томпсона берёт образцы из бета-распределения каждого действия, и выбирает действие с наивысшим возвращённым значением. Поскольку редко пробуемые действия имеют широкие распределения, (см. синюю кривую на иллюстрации 1), то у них больше диапазон возможных значений. Поэтому розетка, у которой сейчас низкое ожидаемое среднее вознаграждение, но которая тестировалась реже розетки с более высоким средним ожиданием, может вернуть большее выборочное значение и будет выбрана на следующем временном шаге.
На вышеприведённом графике синяя кривая имеет более низкое ожидаемое среднее вознаграждение, чем у зелёной кривой. Поэтому при жадном алгоритме будет выбрана зелёная розетка, а синяя никогда не будет выбрана. А сэмплирование Томпсона эффективно учитывает полную ширину кривой, которая у синей розетки может быть шире, чем у зелёной. В этом случае выбор может быть сделан в пользу синей розетки.
Чем чаще используется розетка, тем выше достоверность её ожидаемого среднего. Это отражено в сужении распределения вероятности, и выборочное значение будет браться из диапазона значений, которые ближе к реальному среднему (см. зелёную кривую на иллюстрации 1). В результате исследование (explore) уменьшается, а использование (exploit) растёт, потому что алгоритм начинает чаще выбирать розетки с более высокой вероятностью получения вознаграждения.
С другой стороны, розетки с низким ожидаемым среднем будут выбираться реже и в конце концов будут быстро выброшены из процесса выбора. Поэтому их истинное среднее может и не быть найдено. А поскольку нас интересует лишь розетка с наивысшей вероятностью получения вознаграждения, причём найти её нужно как можно скорее, то нас не волнует, что мы так и не получим всю информацию о плохо работающих розетках.
Реализация розеток по Бернулли
------------------------------
Воспользуемся базовым классом розеток, поверх которого добавим особую функциональность изучаемого алгоритма. Затем прогоним этот новый класс через набор экспериментов с помощью тестовой программы для всех бандитских алгоритмов. Подробное описание базового класса розеток и тестовой системы дано в [одной из предыдущих статей](https://towardsdatascience.com/multi-armed-bandits-part-2-5834cb7aba4b), а весь код лежит на [Github](https://github.com/WhatIThinkAbout/BabyRobot/tree/master/Multi_Armed_Bandits).
Покажу реализацию сэмплирования Бернулли-Томпсона на примере класса `BernoulliThompsonSocket`:
```
class BernoulliThompsonSocket( PowerSocket ):
def __init__( self, q ):
self.α = 1 # the number of times this socket returned a charge
self.β = 1 # the number of times no charge was returned
# pass the true reward value to the base PowerSocket
super().__init__(q)
def charge(self):
""" return some charge with the socket's predefined probability """
return np.random.random() < self.q
def update(self,R):
""" increase the number of times this socket has been used and
update the counts of the number of times the socket has and
has not returned a charge (alpha and beta)"""
self.n += 1
self.α += R
self.β += (1-R)
def sample(self):
""" return a value sampled from the beta distribution """
return np.random.beta(self.α,self.β)
```
В этом классе мы инициализируем  и  со значениями 1, чтобы получить равномерное распределение. Затем при обновлении мы просто увеличиваем  если розетка возвращает вознаграждение, а в противном случае увеличиваем .
Функция sample выводит значение из бета-распределения, используя в качестве параметров текущие значения  и .
Результаты экспериментов
------------------------
На иллюстрации 2 показано изменение бета-распределения для каждой розетки, когда мы используем розетки с более простой вероятностью. Чтобы было проще, мы уменьшили количество розеток до трёх. Их истинные вероятности при проверке работоспособности равны 0,3 (зелёная), 0,7 (красная) и 0,8 (синяя).
Иллюстрация 2: сэмплирование Томпсона с использованием бета-распределения для трёх розеток с истинными вероятностями 0,3, 0,7 и 0,8.Истинные средние значения 0,3, 0,7 и 0,8 показаны пунктирами. В легенде указано общее количество попыток для каждой розетки и количество успешных. Что можно отметить, глядя на эти графики:
* На временном шаге 0 (не показан) все бета-распределения будут иметь  и  равными 1, чтобы было равномерное распределение.
* Поскольку начальное распределение у всех розеток одинаковое, на временном шаге 1 синяя была выбрана произвольно. При проверке она дала вознаграждение, поэтому её  увеличилась на 1, кривая плотности вероятностей сместилась вправо. Зелёная и красная розетки ещё не были проверены, поэтому их распределения остались равномерными (зелёная линия не видна под красной).
* На втором временном шаге снова выбрана синяя розетка, и она снова вернула вознаграждение. Её график ещё немного сместился вправо, потому что розетка проверена дважды и оба раза вернула вознаграждение. Ещё есть вероятность, что она будет возвращать вознаграждение каждый раз.
* К пятому разу ещё раз была выбрана синяя, но на этот раз она не дала вознаграждения. Поэтому вероятность того, что розетка всегда будет вознаграждать, упала до 0 (при вероятности = 1.0). С другой стороны, зелёная розетка была протестирована дважды и пока не вернула вознаграждение, поэтому кривая плотности вероятностей сдвинулась влево с максимальным значением = 0, потому что ещё есть шанс, что розетка никогда не вернёт вознаграждение.
* К 15 разу пару раз была проверена красная розетка. Поскольку она один раз вернула вознаграждение, её ожидаемая средняя вероятность вознаграждения равна 0,5. На этом этапе синяя розетка была проверена 11 раз, из них 6 раз она вернула вознаграждение, так что её ожидаемая вероятность вознаграждения равна 0,54. Жадный алгоритм выбрал бы синюю розетку, но поскольку мы проверяли красную реже синей, её кривая плотности вероятностей гораздо шире, так что у розетки хорошие шансы быть выбранной вместо синей.
* Чем больше проверяется розетка, тем выше доверенность её ожидания и тем у̒же становится её кривая плотности вероятностей. Лучшая розетка потом будет использоваться чаще, а проверка менее оптимальных розеток сойдёт на нет. Такое поведение видно в конце нашего теста, когда синяя розетка выбирается намного чаще остальных. Также видно, что зелёная розетка вернула вознаграждение в двух попытках. Следовательно, теперь отсутствует вероятность, что розетка никогда не вернёт вознаграждение, поэтому график падает до 0.
* Наконец, видно, что у красной и синей розеток кривые плотности вероятностей не находятся прямо на их истинных средних вероятностях. Если бы тест прогнали ещё несколько раз, то синяя кривая в результате совпала бы с истинным средним значение, но у красной будет гораздо меньше попыток (если вообще будут), так что её истинное значение может остаться ненайденным. Как упоминалось выше, это не проблема, потому что нас интересует только лучшая розетка, а не истинные средние значения других розеток.
Сэмплирование Гаусса-Томпсона
-----------------------------
Упрощённая задача с розетками — хороший пример для изучения сэмплирования Байеса-Томпсона. Но если применять этот метод для решения настоящей задачи, в которой розетки не двоичны, а возвращают разное количество энергии, нам нужно кое-что изменить.
Выше мы моделировали поведение розеток с помощью бета-распределения. Это было сделано потому, что упрощённые розетки имели два возможных значения — работает или не работает, и их можно было описать с помощью распределения Бернулли. При извлечении значения из этого распределения (значение *правдоподобия*) оно умножается на значение, извлечённое из бета-распределения (*априорная* вероятность), а получившееся значение (*апостериорная* вероятность) также имеет бета-распределение. Если правдоподобие, умноженное на априорность, даёт апостериорность с тем же типом распределения, что и у априорности, то такая априорность называется [сопряжённым априорным распределением](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D0%BF%D1%80%D1%8F%D0%B6%D1%91%D0%BD%D0%BD%D0%BE%D0%B5_%D0%B0%D0%BF%D1%80%D0%B8%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D1%80%D0%B0%D1%81%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5).
В нашей стандартной задаче каждая розетка возвращает реальное значение, описываемое нормальным распределением. Если мы считаем, что нам известна дисперсия розетки (которая равна 1, потому что мы используем в коде неизменённую версию функции numpy randn), то из [таблицы на Википедии](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D0%BF%D1%80%D1%8F%D0%B6%D1%91%D0%BD%D0%BD%D0%BE%D0%B5_%D0%B0%D0%BF%D1%80%D0%B8%D0%BE%D1%80%D0%BD%D0%BE%D0%B5_%D1%80%D0%B0%D1%81%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5#%D0%9D%D0%B5%D0%BF%D1%80%D0%B5%D1%80%D1%8B%D0%B2%D0%BD%D0%BE-%D1%80%D0%B0%D1%81%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D1%91%D0%BD%D0%BD%D1%8B%D0%B5_%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%B8_%D0%BF%D1%80%D0%B0%D0%B2%D0%B4%D0%BE%D0%BF%D0%BE%D0%B4%D0%BE%D0%B1%D0%B8%D1%8F) мы узнаём, что у сопряжённой априорности тоже нормальное распределение. Если же нам неизвестна дисперсия распределения, или если мы используем другое распределение, то нам просто нужно выбрать в таблице одну из других сопряжённых априорностей и скорректировать соответствующим образом наш алгоритм.
Поэтому мы можем смоделировать результат проверки розетки с помощью нормального распределения и постепенно улучшать модель, обновляя её среднее и параметры дисперсии. Если вместо дисперсии воспользоваться точностью (тау), где точность равна единице, делённой на дисперсию (точность = 1/дисперсия), то мы можем использовать простые правила для обновления среднего и точности :
где:
* — точность реального результата проверки розетки, которая в нашем случае равна 1;
* — количество проверок розетки;
* — результат, полученный при каждой i-проверке розетки (эквивалентно вознаграждению , которое мы использовали до этого момента;
* — ожидаемое среднее (среднее распределения, использованного для моделирования результата);
* — полная точность распределения, использованного для моделирования результата.
На первый взгляд выглядит пугающе, но тут лишь говорится, что у на есть два параметра  и , которые мы будем обновлять при каждой проверке розетки, как и в случае с и  для розеток Бернулли. Только там эти параметры представляли количество успешных и неудачных проверок розеток, а и представляют ожидаемые среднее и точность, отражая достоверность ожидаемого среднего значения.
Можно сделать ещё пару упрощений:
* Мы знаем, что количество возвращаемой розеткой энергии имеет дисперсию 1, поэтому точность  тоже равна 1. Следовательно, обновление точности розетки представляет собой просто где n — количество проверок розетки, так что при каждой проверке мы просто увеличиваем точность розетки на 1.
* У ожидаемого среднего числитель содержит сумму всех результатов проверки розетки, умноженную на . Оставлять сумму вознаграждений нецелесообразно, потому что она может разрастись до очень больших размеров. Однако в нашей базовой реализации розеток мы всегда вычисляем — ожидаемое значение действия на временном шаге t, которое вычисляется так
* В этом уравнении ![R_i]()— вознаграждение, получаемое на каждом временном шаге при выполнении действия a. Оно идентично термину который использовался выше в обновлённом выражении. Поэтому можно просто заменить в обновлённом выражении сумму на и получим
Этими упрощениями мы избавились от страшной математики! Теперь очевидно, что нам нужно лишь сохранять ожидания среднего, а также точности вознаграждения для всех розеток, а затем применять два простых правила для обновления этих значений. А когда напишете эти уравнения в коде, всё станет ещё понятнее.
Реализация розеток Гаусса
-------------------------
Ниже представлен код для сэмплирования Гаусса-Томпсона. Обратите внимание, что в этом коде мы заменили сумму всех вознаграждений на `self.n * self.Q`. Это даёт нам точно такое же значение, но без необходимости суммировать все вознаграждения, что может оказаться очень громоздким вычислением.
```
class GaussianThompsonSocket( PowerSocket ):
def __init__(self, q):
self.τ_0 = 0.0001 # the posterior precision
self.μ_0 = 1 # the posterior mean
# pass the true reward value to the base PowerSocket
super().__init__(q)
def sample(self):
""" return a value from the the posterior normal distribution """
return (np.random.randn() / np.sqrt(self.τ_0)) + self.μ_0
def update(self,R):
""" update this socket after it has returned reward value 'R' """
# do a standard update of the estimated mean
super().update(R)
# update the mean and precision of the posterior
self.μ_0 = ((self.τ_0 * self.μ_0) + (self.n * self.Q))/(self.τ_0 + self.n)
self.τ_0 += 1
```
Важно отметить:
* Функция `sample` возвращает не `Q` (ожидаемое значение вознаграждения розетки), а выборочное значение из нормального распределения, которое мы используем для моделирования результата розетки (апостериор со средним `self.μ_00` и точностью `self.τ_0`).
* Как и в случае с бета-распределением, которое применялось для моделирования результатов двоичных розеток, мы хотим, чтобы наше априорное распределение начиналось с близкого к равномерному, с прямой линией распределения вероятностей. Это даёт возможность вернуть выборочное значение из широкого диапазона возможных значений. Так что изначально мы задаём очень маленькую точность апостериора (`self.τ_0 = 0.0001`). Тогда розетки, которые мы ещё не пробовали, будут выбраны с большей вероятностью, как и в случае с оптимистично-жадным алгоритмом.
Если вы вернётесь к коду базовой розетки, то увидите, что при выборе розетка возвращает количество энергии, заданное нормальным распределением поблизости от истинного среднего значения:
```
def charge(self):
""" return a random amount of charge """
# the reward is a guassian distribution with unit variance around the true value 'q'
value = np.random.randn() + self.q
```
В функции`charge`Numpy-функция`randn`возвращает из нормального распределения среднего 0 и дисперсии 1 случайное значение. Добавив к нему значение истинного вознаграждения розетки`q`, мы смещаем распределение среднего к реальному результату розетки.
В функции`sample`розеток Томпсона применяется очень похожая функция:
```
def sample(self):
""" return a value from the the posterior normal distribution """
return (np.random.randn() / np.sqrt(self.τ_0)) + self.μ_0
```
Только в этом случае нормальное распределение находится на апостериорном среднем `self.μ_0`. Кроме того, randn теперь делится на квадратный корень апостериорной точности `self.τ_0`. Помните, что точность равна единице, делённой на дисперсию. Это меняет ширину распределения, уменьшая её по мере получения новых образцов, и достоверность ожидаемого среднего растёт.
Результаты экспериментов
------------------------
Как и в случае с Бернулли, мы прогнали больше 1000 попыток. Поскольку апостериорное распределение началось с почти прямой линии, каждая из пяти розеток однократно проверена в течение первых пяти попыток. В последующих попытках доминирует розетка 4 (красная кривая). К концу тестирования она превратилась в высокую тонкую кривую, центр которой лежит на значении 12 (истинное значение вознаграждения розетки), что говорит о высоком уровне достоверности этого значения.
За первые 200 проверок лишь ещё одна розетка тестировалась больше одного раза — пятая (фиолетовая кривая, с истинным вознаграждением 10). Но она проверялась лишь трижды, поэтому имеет маленькую и толстую кривую распределения, что говорит о низкой достоверности значения.
Иллюстрация 3: сэмплирование Томпсона с использованием нормального распределения для пяти розеток, с истинными значениями вознаграждения 6, 4, 8, 12 и 10 соответственно.На иллюстрации 3 видно, как быстро сэмплирование Томпсона находит и использует лучшую розетку, а остальные оставляет практически без проверки. Таким образом алгоритм возвращает большое и почти оптимальное накопленное вознаграждение.
Сожаление в сэмплировании Томпсона
----------------------------------
Сожаление (regret), получаемое при использовании сэмплирования Томпсона для решения стандартной задачи с розетками, показано на иллюстрации 4. Оно практически нулевое, это говорит о том, что почти всегда выбиралась лучшая розетка. Также сожаление можно оценить по графику «накопительное вознаграждение от времени», где реальное полученное вознаграждение настолько близко к оптимальному, что кривые почти совпадают. По кривым плотности вероятностей в сэмплировании Гаусса-Томпсона видно, что алгоритм быстро находит лучшее действие и безжалостно его использует, что даёт очень низкий уровень сожаления.
Как и в случае с алгоритмом UCB, сэмплирование Томпсона можно [показать с логарифмическим сожалением](https://web.stanford.edu/~bvr/pubs/TS_Tutorial.pdf), когда со временем значение сожаления падает почти до нуля. В нашем эксперименте логарифмическое падение сожаления незаметно из-за очень маленького количества действий и отдельных значений вознаграждения для каждой розетки, сожаление уже почти нулевое.
Иллюстрация 4: сожаление в сэмплировании Томпсона при решении стандартной задачи с розетками.Подробнее о сэмплировании Томпсона, его применении и математическом аппарате можно почитать в книге “A Tutorial on Thompson Sampling” автора Daniel J. Russo.
Итоги
-----
Алгоритмам для решения задачи с бандитом нужно искать компромисс между исследованием и использованием. Им нужно искать лучшие действия, при этом пытаясь воспользоваться уже полученной информацией.
В простом алгоритме, например, эпсилон-жадном (epsilon-greedy), компромисс по большей части достигается с помощью использования действия, которое сейчас даёт максимальное вознаграждение, и добавления простого исследования, а затем случайно выбирается какое-то другое действие. В более сложных решениях вроде UCB часто выбираются действия с максимальным вознаграждением, но это уравновешивается измерением достоверности. Это гарантирует проверку действий, которые редко выбирались.
Сэмплирование Томпсона предлагает иной подход. Вместо простого вычисления ожидания вознаграждения оно постепенно улучшает модель вероятности вознаграждения для каждого действия, а сами действия выбираются на основе образцов из распределения. Поэтому можно получить ожидание среднего значения вознаграждения, а также вычислить достоверность этого ожидания. Как мы видели в наших экспериментах, это позволяет быстро находить и фиксировать оптимальное действие, выдавая практически оптимальный накопленный результат.
Но является ли сэмплирование Томпсона лучшим решением задачи многорукого бандита? И что ещё важнее, стоит ли его использовать для зарядки Малыша Робота? Об этом мы расскажем в следующей статье, в которой сравним друг с другом все алгоритмы! | https://habr.com/ru/post/547258/ | null | ru | null |
# Краткий курс компьютерной графики, аддендум: ambient occlusion
---
### Official translation (with a bit of polishing) is available [here.](https://github.com/ssloy/tinyrenderer/wiki)
---
В кратком курсе компьютерной графики, что я предоставил вашему рассмотрению пару недель назад, мы пользовались методами локального освещения. Что это значит? Это значит, что интенсивность освещения каждой точки мы выбирали независимо от её соседей.
Модель освещения Фонга — классический пример локального выбора:
Финальная интенсивность складывается из трёх слагаемых: окружающее освещение, постоянное значение для всех точек сцены. Диффузное освещение и блики зависят от вектора нормали к данной точке и направления света, но не зависят от геометрии остальной части сцены. Давайте подумаем, а почему, собственно, окружающее освещение было выбрано постоянным для всей сцены?
Второй подход к глобальному освещению: ambient occlusion
========================================================
Ну, на самом деле, я немного был неправ, когда сказал, что в том курсе у нас освещение было локальным. В шестой части мы рассмотрели построение тени, отбрасываемой нашим объектом. И это является одним из приёмов глобального освещения. В данной статье я предлагаю рассмотреть несколько простых подходов к просчёту окружающего света. Вот пример модели, в которой я использовал **только окружающую** (ambient) компоненту освещения модели Фонга, никакого диффузного света, никаких бликов.
Итак, задача ставится следующим образом: посчитать значение окружающего освещения (ambient lighting) для каждой точки видимой части нашей сцены.
Когда Фонг сказал, что окружающая среда вокруг настолько бархатная и пушистая, что отражает во все стороны одинаково света, это было несколько сильным упрощением. Разумеется, это было сделано в угоду локальным методам освещения, которые гораздо быстрее глобальных. Вспомните, что для построения тени нам пришлось делать рендер в два прохода. Впрочем, с современным железом мы себе можем позволить слегка посибаритстовать, чтобы получить более правдоподобную картинку. В реальной жизни, если вы видите вход в тоннель, то совершенно явно он будет слабее освещён солнечным светом, нежели окружающая гора.
Достаточно правдоподобные картинки получаются, если предположить, что наш объект окружён равномерно светящейся полусферой (например, пасмурное небо). Но это не значит, что тоннель тоже светится внутри, а значит, придётся делать дополнительную работу, просчитывая, насколько каждая точка объекта видна из нашей светящейся полусферы.
Идём в лоб
----------
Сопутствующие исходники брать [здесь](https://github.com/ssloy/tinyrenderer/tree/631386c5ab1987d4cfa097e8f89894cadd593c2d).
Самый простой способ — это выбрать случайным образом, скажем, тысячу разных точек на полусфере вокруг объекта, отрендерить сцену тысячу раз с камерой, поставленной в эти точки, и посчитать, какие части модели мы видели. Тут уместно задать пару вопросов.
Вопрос 1: а умеете ли с ходу вы выбрать с равномерным распределением тысячу точек на сфере без аккумулирования вокруг полюсов?
Как-то так:
**Скрытый текст**
Ведь если просто случайно (равномерно) выбрать широту и долготу, то у полюса у нас получится замечательный сгусток, а это означает, что наше предположение о равномерности отражённого миром света неверно. Примеры готовых вычислений можно взять [тут](http://mathworld.wolfram.com/SpherePointPicking.html).
Вопрос 2: а где хранить информацию о том, какой кусок светящейся полусферы виден из данной точки объекта? Поскольку мы идём в лоб, то ответ практически очевиден: в текстуре объекта!
Итак, пишем два шейдера и делаем рендер два раза для каждой точки. Вот первый (фрагментный) шейдер и результат его работы:
```
virtual bool fragment(Vec3f gl_FragCoord, Vec3f bar, TGAColor &color) {
color = TGAColor(255, 255, 255)*((gl_FragCoord.z+1.f)/2.f);
return false;
}
```
**Скрытый текст**
Непосредственно картинка нас не особо интересует, нам интересен z-буфер в результате работы этого шейдера.
Затем делаем второй проход с таким фрагментным шейдером:
```
virtual bool fragment(Vec3f gl_FragCoord, Vec3f bar, TGAColor &color) {
Vec2f uv = varying_uv*bar;
if (std::abs(shadowbuffer[int(gl_FragCoord.x+gl_FragCoord.y*width)]-gl_FragCoord.z)<1e-2) {
occl.set(uv.x*1024, uv.y*1024, TGAColor(255));
}
color = TGAColor(255, 0, 0);
return false;
}
```
Нам абсолютно не важно, что он выдаст красную картинку. Здесь интересна вот эта строчка:
```
occl.set(uv.x*1024, uv.y*1024, TGAColor(255));
```
occl — это изначально залитая чёрным картинка размером 1024x1024. И эта строчка говорит, что если мы видим данный фрагмент, то отметим его в текстурной карте occl. Вот так выглядит картинка occl после окончания работы рендера:
**Скрытый текст**
Упражнение на понимание происходящего: почему у нас явно видимые треугольники с дырками? Точнее, почему отмечены только отдельные точки ничем не скрытых треугольников?
Упражнение 2: почему у одних треугольников плотность покрытия точками больше, нежели у других?
В общем, повторяем процедуру тысячу раз, считаем среднее из тысячи получившихся картинок occl и получаем вот такую текстуру:
**Скрытый текст**
О! Это уже похоже на что-то стоящее, давайте отрендерим модель, используя только цвет этой текстуры, без дополнительных просчётов освещения.
```
virtual bool fragment(Vec3f gl_FragCoord, Vec3f bar, TGAColor &color) {
Vec2f uv = varying_uv*bar;
int t = aoimage.get(uv.x*1024, uv.y*1024)[0];
color = TGAColor(t, t, t);
return false;
}
```
aoimage здесь — это только что посчитанная текстура. Вот результат работы этого шейдера:
**Скрытый текст**
Упражнение 3: ой, а чего это он мрачнее тучи?
**ответ**Это половина ответа на упражнение 2. Вы не замечали, что в текстуре у диаблы только одна рука? Художник экономный, он сказал, что руки одинаковые, расположив сетку текстурных координат двух рук на одном и том же месте текстуры. И это означает (грубо), что зона, где нарисована рука, будет подсвечена в два раза сильнее, нежели зона, где нарисовано лицо, т.к. оно только одно.
### Подведём итог
Этот метод позволяет (пред-)посчитать текстуру ambient occlusion для сцен, где геометрия статична. Время просчёта зависит от количества точек, которое вы выберете, но обычно время нас интересует слабо, т.к. это практически создание сцены, а не непосредственно процесс игры, такая текстура считается один раз, и затем просто используется. Достоинство в том, что использовать такую текстуру дёшево, она может быть посчитана с условиями более сложного освещения, нежели просто равномерно светящаяся полусфера. Недостаток — если у нас есть наложения в текстурном пространстве, то произойдёт нежный облом.
Куда, куда накладывать скотч, чтобы оно заработало?
===================================================
Поскольку текстурное пространство для диаблы не подходит, можно использовать обычный фреймбуфер. Рендер получится в несколько проходов: рендерим просто z-буфер из обычной позиции камеры, затем освещаем модель из (положим) тысячи различных источников света, посчитав тысячу раз shadow mapping, и считаем среднее для каждого пикселя. Всё бы было хорошо, мы избавились от проблемы наложения информации на себя, но зато получили дикое количество рендерного времени. Если в предыдущем подходе мы просчитывали текстуру один раз на всё время жизни модели, то теперь она зависит от положения камеры в пространстве…
Screen-space ambient occlusion
==============================
Итак, мы приходим к выводу, что глобальное освещение — дорогая штука, нам нужно много дорогостоящих вычислений о видимости поверхности из различных мест. Давайте попробуем найти компромисс между скоростью и качеством результата. Вот сразу картинка, которую мы будем считать:
Рисуем картинку в один проход, вот использованный шейдер:
```
struct ZShader : public IShader {
mat<4,3,float> varying_tri;
virtual Vec4f vertex(int iface, int nthvert) {
Vec4f gl_Vertex = Projection*ModelView*embed<4>(model->vert(iface, nthvert));
varying_tri.set_col(nthvert, gl_Vertex);
return gl_Vertex;
}
virtual bool fragment(Vec3f gl_FragCoord, Vec3f bar, TGAColor &color) {
color = TGAColor(0, 0, 0);
return false;
}
};
```
Ээээ… color = TGAColor(0, 0, 0); ?! Правильно, мы сейчас считаем только ambient освещение, и реально нам из этого шейдера интересен только буфер глубины, ничего, что фреймбуфер останется полностью чёрным после окончания работы шейдера, модель проявится в результате постпроцессинга сцены.
Вот использованный код отрисовки с нашим пустым шейдером и постпроцессинг картинки:
```
ZShader zshader;
for (int i=0; infaces(); i++) {
for (int j=0; j<3; j++) {
zshader.vertex(i, j);
}
triangle(zshader.varying\_tri, zshader, frame, zbuffer);
}
for (int x=0; x
```
Отрисовка пустым шейдером нам даёт заполненный буфер глубины. Постпроцессинг выглядит следующим образом: для каждого пикселя на экране мы испускаем некоторое количество (здесь восемь) лучей в разные стороны. Буфер глубины для нас можно представить как холмистую местность. Что нас интересует, так это как сильно мы будем подниматься, если пойдём в направлении каждого луча. Функция max\_elevation\_angle и даёт максимальный подъём, который мы встретим на пути текущего луча.
Если у всех восьми лучей угол подъёма нулевой, то это значит, что данная точка (x,y) хорошо видна отовсюду. Если же угол примерно 90°, то точка очень слабо видна из окружающей небесной сферы, и, как следствие, должна быть слабо освещена.
По-хорошему надо было бы посчитать [телесный угол](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BB%D0%B5%D1%81%D0%BD%D1%8B%D0%B9_%D1%83%D0%B3%D0%BE%D0%BB) получившейся фигуры, но для наших целей вполне хватит взять (90°-угол подъёма) и поделить на 8, чтобы получить приближение телесного угла. Возведение получившегося телесного угла в степень сто просто поднимает контраст картинки.
Вот что получается на голове старого негра:
Как обычно, код доступен [здесь](https://github.com/ssloy/tinyrenderer/tree/d7c806bc3d598fc54dd446b6c81b94f723728205).
**Скрытый текст**
Общение вне хабра
-----------------
Если у вас есть вопросы, и вы не хотите задавать их в комментариях, или просто не имеете возможности писать в комментарии, присоединяйтесь к jabber-конференции xmpp: 3d@conference.sudouser.ru | https://habr.com/ru/post/250769/ | null | ru | null |
# Как собрать статистику с веб-сайта и не набить себе шишек
Привет, Хабр! Меня зовут Слава Волков, и я фронтенд-разработчик в Badoo. Сегодня я хотел бы немного рассказать про сбор статистики с фронтенда.
Мы знаем, что аналитика позволяет оценить эффективность работы любого веб-сайта, улучшить его работу, а значит, повысить уровень продаж и усовершенствовать взаимодействие пользователей с сайтом. Проще говоря, аналитика – это способ контроля над процессами, происходящими на веб-сайте. В большинстве случаев для обычных сайтов достаточно установить Google Analytics или «Яндекс.Метрику» – их возможностей вполне достаточно.
Но как быть, когда стандартных средств мониторинга недостаточно? Или когда собираемая статистика должна быть интегрирована в вашу собственную систему аналитики для отображения полноценной картины происходящего между разными компонентами? В таком случае, скорее всего, вам придется разработать свою систему. А вот как лучше отправлять статистику с ваших веб-сайтов, какие проблемы могут при этом возникнуть и как их избежать, я расскажу в этой статье. Заинтересовались? Добро пожаловать под кат.
Для таких сервисов, как Badoo, любая статистика является очень важным способом оценки текущей ситуации на ресурсе, будь то клики пользователя, блоки, которые он увидел, действия, которые совершил, или ошибки во время работы с сайтом. На основании этой информации мы производим мониторинг работы сайта и принимаем решения, от которых зависят появление новых фичей, смена положения блоков на странице и другие изменения. Поэтому мы работаем с огромным количеством разнообразной статистики. С какими же трудностями можно столкнуться с таким потоком сообщений?
Первая проблема, которая может возникнуть, – это ограничения браузеров по количеству одновременных соединений к одному домену. Например, при загрузке страницы мы выполняем четыре Ajax-запроса для получения данных (загрузки шрифтов, SVG-графики), загружаем динамично стили. В итоге у нас получается шесть запросов, которые браузер выполняет одновременно ([пример номер 1](https://vexell.ru/files/testpool/#ex1)) (во всех примерах я поставил задержку в две секунды, и их все лучше смотреть на своей машине во избежание сетевых задержек).
```
function sendAjax(url, data) {
return new Promise(function(resolve, reject) {
var req = new XMLHttpRequest();
req.open('POST', url);
req.onload = function() {
if (req.readyState != 4) return;
if (req.status == 200) {
resolve(req.response);
} else {
reject(Error(req.statusText));
}
};
req.onerror = function() {
reject(Error("Network Error"));
};
req.send(data);
});
}
function logIt(startDate, requestId, $appendContainer) {
var endDate = new Date();
var text = 'Request #' + requestId + '. Execution time: ' + ((endDate - startDate) / 1000) + 's';
var $li = document.createElement('li');
$li.textContent = text;
$appendContainer.appendChild($li);
}
document.querySelector('.js-ajax-requests').addEventListener('click', function(e) {
e.preventDefault();
var $appendContainer = e.currentTarget.nextElementSibling;
for (var i = 1; i <= 8; i++) {
(function(i) {
var startDate = new Date();
sendAjax(REQUEST_URL + '?t=' + Math.random()).then(function() {
logIt(startDate, i, $appendContainer);
});
})(i);
}
});
```
Но что будет, если мы начнём отправлять ещё какую-то статистику о зашедшем пользователе? Получим вот такой результат ([пример номер 2](https://vexell.ru/files/testpool/#ex2)):
Как видно, два запроса отправки статистики повлияли на общую загрузку сайта, и если эти данные нужны для отрисовки страницы, то пользователь столкнётся с задержкой, равной времени выполнения самого быстрого из предыдущих запросов.
В большинстве случаев ждать ответа от статистики нет смысла, но на общий поток выполнения эти запросы всё-таки влияют. Как избежать такой ситуации?
### Отправка данных
Если вы уже используете HTTP/2 или передаёте данные через WebSocket-соединение, то такая проблема вас вообще не должна коснуться. Но если ещё нет, возможно, вам поможет просто переход на HTTP/2 (и вы забудете все как страшный сон). Благо все современные браузеры это поддерживают, и в самых популярных веб-серверах уже появилась поддержка этого протокола. Единственная проблема, с которой можно столкнуться, – необходимость убрать все хаки, которые вы делали для HTTP/1.1, например, доменное шардирование (создающее лишнее TCP-соединение и мешающее приоритизации), конкатенация JS и CSS и встраиваемые изображения dataURI. Кроме того, при переходе на HTTP/2 вам придётся перевести весь сайт на HTTPS, а это может быть затратно, особенно если много данных со сторонних ресурсов у вас загружается по HTTP.
При использовании WebSocket-соединения вы также получаете постоянное соединение с сервером и никаких ограничений на количество запросов. Ничего плохого в этом решении нет, кроме того, что придётся поднять свой сокет-сервер и связать его со своей системой, – дополнительная работа для разработчиков. Но в итоге через сокет можно будет передавать не только статистику, но и обычные запросы. А главное – это позволит получать нотификации с сервера и экономить трафик.
#### Способ №1
Если вы ещё не готовы переходить на HTTP/2 или использовать WebSocket-соединение, самое простое решение – вынесение запросов со статистикой на отдельный домен, собственно, как и вынесение всей статики. Тогда проблема исчезнет ([пример номер 3](https://vexell.ru/files/testpool/#ex3)):
Само собой не стоит забывать о конфигурации CORS, иначе такие запросы будут заблокированы браузером.
#### Способ №2
Используя возможности [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API), мы можем сделать шесть дополнительных запросов, не передавая cookie ([пример номер 4](https://vexell.ru/files/testpool/#ex4)). Но это поможет только в том случае, если cookie не будут использоваться для авторизации при запросах. По умолчанию Fetch их не передаёт. Кажется, что это выглядит как баг реализации, но такое поведение наблюдается как в Chrome, так и в Firefox. Баг, фича? Для того чтобы cookie уходили, необходимо установить дополнительный параметр:
```
fetch(REQUEST_URL + '?t=' + Math.random(), {
method: 'POST',
credentials: 'include'
}).then(function () {
// ...
});
```
Итак, мы определились, как мы будем передавать данные на сервер. Но не будем же мы отправлять запрос на каждое действие пользователя. Конечно, лучше буферизировать события и затем группой передавать на сервер. Но в этом случае, если пользователь покинет страницу, есть риск потерять накопленный буфер. Как избежать такой ситуации?
### Буферизация
Буферизацию сообщений можно организовать с помощью функции [debounce](https://gist.github.com/ethyde/d56b12d8dbe2d7a327f2628b6fdd2f9f), которая и позволит нам организовать задержку между отправкой сообщений. Небольшой пример данной работы можно [посмотреть тут](https://codepen.io/vexellz/pen/apPyge) (при необходимости можно дополнить его с учётом размера передаваемых данных или максимального времени жизни очереди).
Кроме использования задержки **debounce**, есть [примеры](https://developers.google.com/web/updates/2015/08/using-requestidlecallback) использования метода [window.requestIdleCallback](https://developer.mozilla.org/ru/docs/Web/API/Window/requestIdleCallback), но, к сожалению, он поддерживается ещё далеко не всеми браузерами. Метод **requestIdleCallback** ставит в очередь функцию, которая будет выполнена в момент простоя браузера. Данную возможность как раз неплохо использовать для выполнения фоновых задач, например, отправки статистики или подзагрузки каких-либо lazy load-элементов на странице. Моё мнение – она лучше подходит для агрегации синхронных вызовов. Например, посмотрите этот [пример](https://codepen.io/vexellz/pen/xqzrEd).
Кроме того, неплохо было бы определить, когда ваша система готова к использованию, и затем вызвать метод **ready()**, после которого статистика начнёт отправляться на сервер, не блокируя остальную работу. А до этого она может как раз попадать в буфер.
### Гарантия доставки событий
К сожалению, при использовании буферизации может возникнуть такая ситуация: пользователь закрыл вкладку – и статистика, которую вы собирали, не отправляется и теряется. Этого можно избежать. Первое, что приходит на ум, – это создание метода **force()** у вашего объекта отправки статистики, который будет выполняться при [beforeunload](https://developer.mozilla.org/en-US/docs/Web/Events/beforeunload). Но если вы используете для отправки статистики XHR-запросы, то при закрытии вкладки или браузера запрос также не будет выполнен:
```
window.addEventListener('beforeunload', sendData, false);
function sendData() {
var client = new XMLHttpRequest();
client.open("POST", "/server.php", false);
client.send(data);
}
```
Исправить это можно отправкой синхронного запроса, как в примере выше (но это заблокирует для пользователя действия с браузером), или же использованием специального метода [sendBeacon](https://developer.mozilla.org/en-US/docs/Web/API/Navigator/sendBeacon), который позволяет асинхронно отправлять небольшие объёмы данных на сервер и гарантирует их доставку даже после закрытия страницы. Данный метод работает во всех современных браузерах, кроме Safari и Internet Explorer (в Edge есть поддержка), поэтому для них придётся оставить старый синхронный XHR. Но главное – метод выглядит достаточно компактно и просто:
```
window.addEventListener('beforeunload', sendData, false);
function sendData() {
var navigator = window.navigator;
var url = "/server.php";
if (!navigator.sendBeacon || !navigator.sendBeacon(url, data)) {
var t = new XMLHttpRequest();
t.open('POST', url, false);
t.setRequestHeader('Content-Type', 'text/plain');
t.send(data);
}
}
```
Для того чтобы убедиться, что ваши запросы уходят, достаточно открыть в Chrome DevTools вкладку Network и отфильтровать по запросам типа Other. Тут будут находиться все ваши sendBeacon-запросы.
К сожалению, у sendBeacon есть недостатки, из-за которых на него нельзя перевести все отправки запросов. Во-первых, метод попадает под ограничение количества соединений на один домен ([пример номер 5](https://vexell.ru/files/testpool/#ex5)), так что теоретически может возникнуть ситуация, когда запрос отправки статистики заблокирует какой-то важный запрос за получением данных (но есть исключение: если вы используете вместо XHR-запросов новый Fetch API без передачи cookie, то sendBeacon уже не попадает под ограничение коннектов ([пример номер 9](https://vexell.ru/files/testpool/#ex9))). Во-вторых, sendBeacon может иметь ограничение на размер запроса. Например, раньше для Firefox и Edge максимальный размер запроса составлял 64 Кб, сейчас же для Firefox уже нет ограничения на размер данных ([пример 8](https://vexell.ru/files/testpool/#ex8)). Когда я пытался найти максимальный размер данных для Chrome (на текущий момент актуальна 57 версия), то нашёл очень [интересный баг](https://bugs.chromium.org/p/chromium/issues/detail?id=701678), из-за которого использование sendBeacon становится проблематичным и который вызвал у нас падение в отправке статистики. Попробуйте выполнить [пример 7](https://vexell.ru/files/testpool/#ex7), перезагрузите страницу и посмотрите результат [примера 8](https://vexell.ru/files/testpool/#ex8):
В Chrome до тех пор, пока буфер не достигнет 64 Кб, остальные запросы просто нельзя отправить. Сейчас баг уже исправлен, и я надеюсь, что его исправление попадёт в ближайшую версию. После этого ограничение на один запрос будет также составлять 64 Кб данных.
Так что, если через этот метод у вас уходит много статистики от разных компонентов, то, скорее всего, вы столкнётесь с лимитом. Если вы перешагнёте этот лимит, то метод `navigator.sendBeacon()` вернёт `false`, и в таком случае лучше воспользоваться обычным XHR-запросом, а `navigator.sendBeacon()` оставить только для тех случаев, когда пользователь покидает страницу. Также этот метод не гарантирует получение данных сервером, если пропало интернет-соединение, поэтому при отправке данных лучше воспользоваться свойством [navigator.onLine](https://developer.mozilla.org/en-US/docs/Web/API/NavigatorOnLine/onLine), которое возвращает сетевой статус браузера, прежде чем отправлять запросы.
В принципе, [последнее решение](http://codepen.io/vexellz/pen/OpbxqK) выглядит достаточным для большинства случаев. Если вынести отправку статистики на отдельный домен ([пример номер 6](https://vexell.ru/files/testpool/#ex6)), то вообще решение практически универсальное, особенно если мы рассматриваем десктопные веб-приложения. Если же рассматривать мобильный веб, в котором нередки случаи потери соединения и случаи, когда необходимо гарантировать доставку сообщений на сервер, то это решение уже не подходит, и лучше воспользоваться обычным XHR-запросом и проверять результат его выполнения.
Но есть ли универсальное решение, которое подойдёт как десктопному, так и мобильному вебу? Если заглянуть в будущее и обратиться к новым экспериментальным технологиям, то такая возможность действительно существует.
### Service Worker и фоновая синхронизация
Фоновая синхронизация в [Service Worker](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API) представлена [Background Sync API](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerRegistration/sync) или с ещё одной реализацией как [периодическая синхронизация](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerRegistration/periodicSync). Возьмём уже рассмотренный пример и попробуем переписать его с использованием возможностей сервис-воркера.
Готовый тестовый пример можно [посмотреть по этой ссылке](https://vexell.ru/files/testpool/example-sw.html). А тут – [исходный код](https://github.com/VeXell/test-sync).
```
Statistic.prototype._sendMessageToServiceWorker = function(message) {
return new Promise(function(resolve, reject) {
var messageChannel = new MessageChannel();
messageChannel.port1.onmessage = function(event) {
if (event.data.error) {
reject(event.data.error);
} else {
resolve(event.data);
}
};
navigator.serviceWorker.controller.postMessage(message, [messageChannel.port2]);
});
};
Statistic.prototype._syncData = function() {
return navigator.serviceWorker.ready.then(function(registration) {
return registration.sync.register('oneTimeStatisticSync');
});
};
```
Service Worker:
```
self.addEventListener('sync', function(event) {
console.info('Sync event executed');
if (event.tag == "oneTimeStatisticSync") {
event.waitUntil(sendStatistic());
}
});
```
Как вы можете заметить, в этот раз мы отправляем данные сразу в сервис-воркер, взаимодействуя с ним через PostMessage, а задержку делаем только на синхронизацию. Большой плюс сервис-воркера в том, что, если вдруг пропадает интернет-соединение, он автоматически отправляет данные только после его появления. Посмотрите видео ниже. Или попробуйте сделать это сами. Просто отключите интернет и понажимайте на ссылки в примере выше. Вы увидите, что запросы отправляются только после установки соединения.
Чтобы не заморачиваться с ручной синхронизацией и немного упростить код, можно воспользоваться периодической синхронизацией, которая доступна в сервис-воркере. К сожалению, даже в Chrome Canary это ещё не работает и можно лишь предположить, как это будет функционировать. Но вот уже кто-то даже [написал полифил](https://github.com/AdaLiszk/swPeriodicSync) для этого:
```
navigator.serviceWorker.register('service-worker.js')
.then(function() {
return navigator.serviceWorker.ready;
})
.then(function(registration) {
this.ready();
return registration;
}.bind(this))
.then(function(registration) {
if (registration.periodicSync) {
registration.periodicSync.register({
tag: 'periodicStatisticSync',
minPeriod: 1000 * 30, // 30sec
powerState: 'auto',
networkState: 'online'
});
}
});
```
Благодаря использованию периодической синхронизации можно не только отправлять статистику, но и загружать новые данные, когда приложение неактивно. Это очень удобно, например, для новостных сайтов – чтобы загружать новые данные каждый час. Но так как в данный момент этой возможности ещё нет, приходится пользоваться обычной синхронизацией и своими таймерами.
К недостаткам использования Service Worker можно отнести, наверное, то, что этот способ поддерживается ещё не всеми браузерами. Кроме того, его реализация требует использования только HTTPS-протокола: Service Worker должен быть подключён по HTTPS и все fetch-запросы внутри него тоже должны быть с использованием этого протокола (исключение составляет `localhost`).
### Заключение
В заключение хочется отметить, что возможностей для мониторинга и отправки данных из веб-приложений становится всё больше – веб неплохо развивается в этом направлении. Поэтому использование уже существующих возможностей браузеров позволяет качественно собирать статистику с веб-ресурсов. И не забывайте, что статистика, которую вы собираете, при правильном сборе и анализе позволит вам лучше понимать работу своего сайта и взаимодействие с ним пользователей.
Желаю всем успехов в сборе данных! | https://habr.com/ru/post/325062/ | null | ru | null |
# Применение R при вычислениях с повышенной точностью
Периодически встречаются задачи, даже в обыденной жизни, когда разрядной точности `float64`/`int64` оказывается недостаточной для того, чтобы получить ответ с требуемой точностью. Метаться в поисках другого инструмента? Тоже вариант.
А можно этого и не делать, а проявить любопытство и узнать, что для вычисления с произвольной точностью давным-давно сделана библиотека [GNU MPFR](https://www.mpfr.org/) к которой есть обертки почти к всем языкам. Практика показывает, что с этой библиотекой вообще мало кто знаком, что вызвано, наверное, особенностями программ обучения в ВУЗ-ах и последующим программистским мейнстримом.
Библиотека хороша и заслуживает того, чтобы на нее обращали внимание, хотя бы в рамках расширения кругозора. По R к ней есть обертка [Rmpfr](http://rmpfr.r-forge.r-project.org/). Ниже приведу простенький пример на задачках для школьников (ну не трогать же проектные данные под NDA) и затрону ряд классических граблей, на которые наступают почти сразу же.
Является продолжением [предыдущих публикаций](https://habrahabr.ru/users/i_shutov/posts/).
Берем для примера задачу №39 из [конкурса 2019/2020 учебного года](https://kvantik.com/konkurs/math/) в Квантике:
*Положительные числа x и y таковы, что в неравенстве ниже левая дробь больше правой. Что больше: x или y?*
Естественно, что решать ее надо аналитически (знакопеременное неравенство), но это не повод не использовать ее в качестве демонстрации.
Рисуем простенький код для вычисления последовательности значений дробей. Можно сразу финальное значение задать, но тут же демосцена для `mpfr`, так что движемся мелкими шажками.
**Решаем стандартными методами**
```
library(tidyverse)
library(magrittr)
options(digits=15)
frec <- function(stopval, n, x){
res <- ifelse(n == stopval,
(stopval - 1) + stopval/(stopval + 1 + x),
(n - 1 ) + n / (frec(stopval, n + 2, x))
)
res
}
frec_wrap <- function(stopval, x){
res <- frec(stopval = stopval, n = 1, x = x)
print(glue::glue("{stopval}: {res}"))
res
}
sol_df <- tibble(stopval = seq(1, 29, by = 2)) %>%
mutate(val1 = purrr::map_dbl(stopval, frec_wrap, x = 1),
val2 = purrr::map_dbl(stopval, frec_wrap, x = 5),
delta = val1 - val2)
```
И вот ведь незадача, уже на 14-ой итерации (стоп число = 29) нам недостаточно точности чтобы различить значения дробей. А надо считать аж до 2019!
Все пропало? Ну нет, возьмем в руки `Rmfpr`. Первая идея — давайте просто заменим `float64` на `mpfr` и дело в шляпе.
**Решаем через повышенную точность**
```
library(tidyverse)
library(magrittr)
library(Rmpfr)
frec2 <- function(stopval, n, x){
if(n == stopval){
(stopval - 1) + stopval/(stopval + 1 + x)} else {
(n - 1 ) + n / (frec2(stopval, n + 2, x))
}
}
frec2_wrap <- function(stopval, x){
.precision <- 5000
res <- frec2(stopval = mpfr(stopval, .precision),
n = mpfr(1, .precision),
x = mpfr(x, .precision)
)
print(glue::glue("{stopval}: {formatMpfr(res, drop0trailing = TRUE)}"))
res
}
sol2_df <- tibble(stopval = seq(1, 29, by = 2)) %>%
mutate(val1 = purrr::map(stopval, frec2_wrap, x = 1),
val2 = purrr::map(stopval, frec2_wrap, x = 5))
```
Но не тут то было. Худо-бедно посчитать можно, но в `tibble` уже засунуть затруднительно. Распечатать или провести математические действия путем векторизации невозможно.
**Проблема №1:**
`tibble` в последней инкарнации не принимает типы данных, отличные от `vctrs`. Все прочие (а `mpfr` является S4 классом) только через list-column. Как-то неудобненько и не наглядненько.
Кстати, переход на `vctrs` не только здесь дает знать. Он начинает рвать на простых операция присвоения в несуществующие колонки, пример кода:
```
for(jj in 1:12){
# поскольку прямое присвоение, то мы ничего перед этим не чистим
flags_df[[glue("bp_2_{jj}_T")]] <- flags_df[[glue("bp_2_{jj}_in")]] & flags_df[[glue("flag_2_{jj}")]]
flags_df[[glue("bp_2_{jj}_F")]] <- flags_df[[glue("bp_2_{jj}_in")]] & ! flags_df[[glue("flag_2_{jj}")]]
}
```
**Проблема №2:**
list-column автоматически отменяет векторизацию и требует ручной итерации. При этом разницу между двумя `mpfr` числами придется опять помещать в list-column.
**Проблема №3**
Посмотреть визуально `mpfr` числа не представляется возможным. StackOverflow предлагает массу вариантов с регулярными выражениями по выцеплению визуального представления. Плюс это еще засунуть в итератор. И эти люди говорят нам об элегантности подходов в R?
Проблемы? Да-да-да! Это все потому что R, а не Python! Мы всегда знали!
Нет. Просто RTFM, вспоминаем хорошо забытое старое и решаем все одним взмахом.
* Проблема №1. Решается все просто — свет клином на `tibble` не сошелся. Можно использовать старый проверенный `data.frame`.
* Проблема №2. В `rpfm` есть абстрация для вектора чисел с повышенной точностью над которыми можно проводить мат. операции обычным образом, не привлекая итераторы. А `data.frame` вполне себе стерпит такой вектор.
* Проблема №3. Читаем документацию и используем векторизированную функцию `formatMpfr` для создания текстовых представлений чисел.
Легкость бытия возвращается в первозданном виде.
**Ещё немного кода**
```
library(tidyverse)
library(magrittr)
library(Rmpfr)
# решаем через повышенную точность
frec2 <- function(stopval, n, x){
if(n == stopval){
(stopval - 1) + stopval/(stopval + 1 + x)} else {
(n - 1 ) + n / (frec2(stopval, n + 2, x))
}
}
frec2_wrap <- function(stopval, x){
# browser()
.precision <- 5000
res <- frec2(stopval = mpfr(stopval, .precision),
n = mpfr(1, .precision),
x = mpfr(x, .precision)
)
print(glue::glue("{stopval}: {formatMpfr(res, drop0trailing = TRUE)}"))
res
}
sol_df <- data.frame(stopval = seq(111, 119, by = 2)) %>%
# сразу преобразуем список mpfr чисел в вектор
mutate(val1 = new("mpfr", unlist(purrr::map(stopval, frec2_wrap, x = 1))),
val2 = new("mpfr", unlist(purrr::map(stopval, frec2_wrap, x = 5))),
delta = val1 - val2)
sol_txt_df <- sol_df %$%
tibble(stopval = stopval,
val1_txt = formatMpfr(val1, drop0trailing = TRUE),
val2_txt = formatMpfr(val2, drop0trailing = TRUE),
delta_txt = formatMpfr(delta, drop0trailing = TRUE))
```
P.S. Желающие поспорить в поисках истины могут не утруждаться. Это больше похоже на задачку в стиле головоломок, чем на серьезную претензию. А те, кто умеет читать между строк, обязательно ознакомятся с [GNU MPFR](https://www.mpfr.org/).
Предыдущая публикация — [«Применение R в задаче обновления кассового ПО?»](https://habr.com/ru/post/490138/). | https://habr.com/ru/post/501472/ | null | ru | null |
# How to Get Nice Error Reports Using SARIF in GitHub
Let's say you use GitHub, write code, and do other fun stuff. You also use a static analyzer to enhance your work quality and optimize the timing. Once you come up with an idea - why not view the errors that the analyzer gave right in GitHub? Yeah, and also it would be great if it looked nice. So, what should you do? The answer is very simple. SARIF is right for you. This article will cover what SARIF is and how to set it up. Enjoy the reading!
### What is SARIF?
[SARIF](https://docs.oasis-open.org/sarif/sarif/v2.0/sarif-v2.0.html) (Static Analysis Results Interchange Format) is a JSON-based format for showing results of static analysis tools. That is, we just need to get the analyzer report in this format. Then we can use it in products that support it - for example, on GitHub or in Visual Studio Code.
This format appeared because vendors of static analysis tools create their own output formats. However, even if the different analyzers' reports were presented in the same format (for example, JSON), the structure of the reports would differ. Therefore, one common standard was only a matter of time.
SARIF is developing rapidly, and it is becoming more popular. However, it has a small drawback. Sometimes it changes its structure, and you have to adjust the code a little so that the SARIF file passes validation. Nevertheless, these are small things compared to the benefits it brings. In theory, in an ideal world, it is enough to get a report in this format and then it can be opened in any program/system that works with static analysis results. Not bad, sounds great!
### Setting up GitHub repository
For GitHub to start analyzing SARIF files, you first need to set up a repository. When setting up, we used [this](https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/enabling-code-scanning-for-a-repository) instruction.
So, open your repository and click on "Security".
Find the "Code scanning alerts" in the center and click on "Set up code scanning" on the right.
Next, click on "Set up this workflow".
Now give a name for the yml file (for example, upload-sarif.yml) and write the following content:
```
name: "Upload SARIF"
# Run workflow each time code is pushed to your repository and on a schedule.
# The scheduled workflow runs every at 00:00 on Sunday UTC time.
on:
push:
schedule:
- cron: '0 0 * * 0'
jobs:
build:
runs-on: ubuntu-latest
steps:
# This step checks out a copy of your repository.
- name: Checkout repository
uses: actions/checkout@v2
- name: Upload SARIF file
uses: github/codeql-action/upload-sarif@v1
with:
# Path to SARIF file relative to the root of the repository
sarif_file: results.sarif
```
It should look as follows:
Now click on "Start commit", write a message (for example, "Create upload-sarif. yml") and make a commit.
Great, we've set up the repository! We can move on to getting the SARIF file.
### Getting a SARIF file
As you might have guessed, SARIF is a unified standard, and you can get it using various static analyzers and tools. In this article, we will use PVS-Studio and PlogConverter. Keep reading to find out about all this.
#### Checking the project
To get the SARIF file, we first need to check the project using a static analyzer. Therefore, we added a small test C++ project with a single file in the repository configured above for demonstration. What we are going to actually check? :) Here is the content of the file:
```
#include
void f(unsigned int ch)
{
unsigned int chx = -1;
if (ch >= 0x0fff0)
{
if ( !((ch >= 0x0FF10) && (ch <= 0x0FF19))
|| ((ch >= 0x0FF21) && (ch <= 0x0FF3A))
|| ((ch >= 0x0FF41) && (ch <= 0x0FF5A)))
{
ch = chx;
}
}
}
int main()
{
std::cout << "error" << std::endl;
}
```
By the way, the synthetic example with an error has a real prototype, described in the article "[How PVS-Studio Proved to Be More Attentive Than Three and a Half Programmers](https://www.viva64.com/en/b/0587/)".
As mentioned above, we'll check the project with the [PVS-Studio](https://www.viva64.com/en/pvs-studio/) static analyzer. Namely, using the "PVS-Studio\_Cmd.exe" console utility. This utility allows you to analyze C++, C# MSBuild projects on Windows. By default, you can find it by path "C:\Program Files (x86)\PVS-Studio". You can read more about this utility [here](https://www.viva64.com/en/m/0035/).
Don't worry if you don't have a license for the check. Click [here](https://www.viva64.com/en/pvs-studio-download/) and you'll get to the website. You'll be able to download it and get a trial license.
Fine, let's move on to the analysis. To make it, just run this command:
```
PVS-Studio_Cmd.exe -t "D:\Use_SARIF_Example\BestProjectCpp.sln" \
-o "D:\Use_SARIF_Example\results.plog" -e "D:\Use_SARIF_Example\"
```
Let's look at the command line in a little more detail. The "-t " flag is required. It allows you to specify an object to check (sln or a csproj/vcxproj file). The "-o " flag is responsible for the path to the file where the analysis results will be written. The "-e " flag is the root part of the path that PVS-Studio will use when generating relative paths in warnings. It is necessary because the report will be processed in the cloud.
Great, now you need to convert the plog file to a SARIF file. To do this, we'll use the PlogConverter utility.
#### Converting from Plog to SARIF
We will perform the conversion using the PlogConverter utility, so let me say a few words about it. [PlogConverter](https://github.com/viva64/plog-converter) is an open source utility designed to convert PVS-Studio analyzer reports from one format to another. The utility is described in more detail in the [documentation](https://www.viva64.com/en/m/0038/).
So, we need to find PlogConverter.exe on the computer. This utility is installed together with PVS-Studio and is located next to "PVS-Studio\_Cmd.exe". Let's follow this path, open the console and write the following command:
```
PlogConverter.exe "D:\Use_SARIF_Example\results.plog" \
-o "D:\Use_SARIF_Example" -t sarif -n results
```
That's all. Now you can upload this file and view the analysis results.
### Final check
To check that everything we've done works correctly, we will quickly upload our SARIF file manually and see the analysis results. To do this, go to the repository and click on "Add file -> Upload files".
Next, add the SARIF file and wait for it to be processed. If you want to see the processing progress, click on "Actions" and select a working task.
When it's done, go to the "Security" tab. Select "Code scanning alerts -> PVS-Studio" on the left.
On the right, you will see the analyzer messages. Let's open a warning:
Here we see:
1. quick filter by errors;
2. error message. It also indicates exactly where the error is located in the source code.
3. Link to the documentation for the analyzer warning.
### Working scenario how to use SARIF on GitHub
It's time to see how all this can work in practice. I suggest considering a scenario where a person downloads a repository, performs some work, creates a SARIF file using the commands above, and uploads changes to a separate branch. As a result, this scenario will allow us to see not only what files the user has changed, but also what mistakes are made. Therefore, let's download the repository and make changes to the file with the C++ code:
```
#include
void f(unsigned int ch)
{
unsigned int chx = -1;
if (ch >= 0x0fff0)
{
if (!((ch >= 0x0FF10) && (ch <= 0x0FF19))
|| ((ch >= 0x0FF21) && (ch <= 0x0FF3A))
|| ((ch >= 0x0FF41) && (ch <= 0x0FF5A)))
{
ch = chx;
}
}
}
int ComputeProjectionMatrixFOV(float fov)
{
float yScale = 1.0 / tan((3.141592538 / 180.0) \* fov / 2);
return yScale;
}
int main()
{
std::cout << "error" << std::endl;
}
```
Next, we check the file, save the report. We also get the SARIF file and replace the one in the downloaded repository with this new SARIF file. Finally, we make a commit in a separate branch. That's it, the user has done their job. Now it's time to look at errors.
Go to the repository. Click on "Security" - > " Code scanning alerts "- > " PVS-Studio "and on the right select the desired branch in "Branch". Look at the result:
As you can see, error messages in the branch are saved separately. Agree, this is quite convenient. If you'd like, you can create a bat file that will run the analyzer, convert the report to SARIF, and replace the existing SARIF file.
### What can you do with the results?
So, you have the report, what's available for you? The first thing to note is that all errors are divided into two groups. These are "Open" and "Closed". "Open" are active errors that are not handled. "Closed" are errors that we have fixed or marked as false.
The second is the filters by error statuses (closed, open, and so on).
There are also filters on error characteristics. For example, you can sort by an error number.
GitHub also allows us to mark messages as "false positive", "used in tests", and my favorite "won't fix":). To mark a message, select it (there is a checkbox to the left of the message) and click on "Dismiss" on the top right.
Messages that you mark up this way will not be included in the open errors column the next time you download the SARIF file.
If we need to return messages to "Open", we can do it easily. To do this, select "Closed", then select what we want to return, and click "Reopen" on the right.
Also note that if you upload a new log, it overwrites the current open errors. If the errors that were in "Open" are not found in the new log, then they fall into "Closed". Therefore, we recommend using SARIF only for analyzing the entire project. If you only need to analyze a pull request, then check out our articles on this topic. For example, [this](https://www.viva64.com/en/b/0750/) one. It will not be very convenient to use SARIF for pull request analysis.
### Does it only work for C++?
Of course not, you don't depend on the language at all. All you need is a static analysis tool that can analyze your code and create a SARIF file. For example, the PVS-Studio analyzer used for this project can analyze C++, C#, and Java. So, let's try to check the code in C# again, because ~~it's the best language in the world~~ one of this article's authors likes it a lot. For example, we quickly do all the same things that were mentioned in the article, but for a C# project. Here is the content of the file that was analyzed:
```
using System;
using System.Collections.Generic;
using System.Linq;
namespace TestSarif
{
class Program
{
static void Main()
{
var result = Formula42(3, 5);
}
static int Formula42(int? coefficientA, int? coefficientB)
{
var data = new List();
if (coefficientA != null)
data.Add(Formula42(coefficientA.Value));
else if (coefficientB != null)
data.Add(Formula42(coefficientA.Value));
return data.SingleOrDefault();
}
static private int Formula42(int coefficient)
{
return coefficient;
}
}
}
```
Here is the result:
Well, let's look at the error itself.
### Conclusion
To sum up, I would like to note that SARIF is a convenient format that allows you to view the analysis results. Besides, setting up is fast and easy. For example, in VS Code, you can do it in a couple of clicks. By the way, if you are interested in how to do this, then write about it in the comments. Anyway, if you have any suggestions on the topics of the article, don't hesitate to write us about them.
So, try and use it. Thanks for your attention! | https://habr.com/ru/post/541540/ | null | en | null |
# Использование эмоциональных иконок Emoji в коммитах на GitHub
Некоторое время назад, сервис GitHub [анонсировал](https://github.com/blog/1289-emoji-autocomplete) возможность использовать эмоциональные иконки Emoji во всей своей [GFM-разметке](https://help.github.com/articles/github-flavored-markdown).
Мало кто знает, что эмоциональные иконки можно использовать не только в комментариях к pull requests и issues, но и в **commit messages**!
> **DISCLAIMER**
>
> #### Данная статья носит исключительно ознакомительный характер и практическое применение этого материала не приветствуется в реальных проектах.
>
>
Вид в истории коммита:
Добавлять иконки к коммитам очень просто:
```
git commit --message='Мой первый коммит :metal:'
```
Ознакомиться с полным набором эмоциональных иконок предлагает открытый проект [EMOJI CHEAT SHEET](http://www.emoji-cheat-sheet.com/)
Статистика популярности использования эмоциональных иконок на GitHub (актуальна на момент запуска):
В настоящее время, список сервисов, которые поддерживают Emoji включает: Campfire, GitHub, Gist, Basecamp, Teambox, Trac, Flowdock, Sprint.ly, Kandan, Textbox.io, Kippt, GitLab, JabbR, Trello, Hall, plug.dj, Qiita, Zendesk, Ruby China, Grove and Idobata, VK.
#### Небольшой список библиотек, которые помогу реализовать поддержку Emoji в вашем проекте:
<https://github.com/hassankhan/emojify.js>
<https://github.com/fengmk2/emoji>
<https://github.com/iamcal/js-emoji>
#### Дополнительные ссылки:
[Emoji](http://en.wikipedia.org/wiki/Emoji)
[EMOJI CHEAT SHEET](http://www.emoji-cheat-sheet.com/)
[iOS Emoji](http://www.grumdrig.com/emoji-list/)
[All-Github-Emoji-Icons](https://github.com/scotch-io/All-Github-Emoji-Icons)
[Демо
====](https://github.com/scotch-io/All-Github-Emoji-Icons)
Эмоциональных коммитов!  | https://habr.com/ru/post/205010/ | null | ru | null |
# Различия между MVVM и остальными MV*-паттернами
> *От переводчика*:
>
> *Уже опубликовано много материалов по MVC и его производным паттернам, но каждый понимает их по-своему. На этой почве возникают разногласия и холивары. Даже опытные разработчики спорят о том, в чем отличие между MVP, MVVM и Presentation Model и что должен делать тот или иной компонент в каждом паттерне. Ситуация усугубляется еще и тем, что многие не знают истинную роль контроллера в классическом варианте MVC. Предлагаю вашему вниманию перевод [хорошей обзорной статьи](https://blogs.msdn.microsoft.com/erwinvandervalk/2009/08/14/the-difference-between-model-view-viewmodel-and-other-separated-presentation-patterns/), которая многое проясняет и расставляет всё по своим местам*.
Прежде чем мы начнем погружаться в детали паттерна Model-View-ViewModel (MVVM), я думаю, будет полезно описать сходства и различия между MVVM и другими шаблонами проектирования для разделения модели и представления (MV\*-паттерны).
Существует довольно много MV\*-паттернов: Model-View-Controller, Model-View-Presenter, Presentation Model, Passive View, Supervising Controller, Model-View-ViewModel и многие другие:
Глядя на схемы, вы, конечно же, видите, что стрелки показывают отношения между компонентами. Но только ли в этом различие? Является ли Controller тем же, что и Presenter или PresentationModel? Как бы вы сравнили между собой Model-View-Presenter и Model-View-ViewModel? В данной статье я собираюсь описать сходства и различия между наиболее распространенными MV\*-паттернами.
Построение UI без использования MV\*-паттернов
----------------------------------------------
Как бы вы построили пользовательский интерфейс (UI), не используя вышеперечисленные паттерны? Взяли бы форму, добавили на нее виджеты, а логику написали бы в коде. Такой код, описывающий логику View, жёстко связан с пользовательским интерфейсом, так как он напрямую взаимодействует с элементами на экране. Это хороший, но прямолинейный подход. Он применим только для очень простых интерфейсов. Когда логика становится более сложной, поддержка такого UI может превратиться в кошмар!
Корень проблемы заключается в том, что построение UI таким способом нарушает принцип единственной ответственности ([single responsibility principle](http://en.wikipedia.org/wiki/Single_responsibility_principle)), который гласит: «*У класса должна быть только одна причина для изменения*». Если UI-компонент содержит код для отображения, логики и данных, то у него есть несколько причин для изменения. Например, если вы хотите поменять тип пользовательского элемента, который используется для отображения данных, то изменения не должны повлиять на логику. Однако поскольку логика так тесно связана с элементами управления, ее тоже придется менять. Это так называемый «код с душком» ([code smell](http://en.wikipedia.org/wiki/Code_smell)), который сигнализирует, что принцип единственной ответственности нарушен.
Таким образом, если форма содержит код для отображения элементов управления, логику интерфейса (что происходит при нажатии кнопки) и данные для отображения на экране, вы столкнетесь со следующими проблемами:
* **Усложнение поддержки**
Изменения в UI, логике или данных, скорее всего, повлекут за собой изменения в остальных частях. Поэтому вносить правки гораздо сложнее, что затрудняет поддержку.
* **Ухудшение тестируемости**
Логика и данные приложения могут быть написаны таким образом, чтобы каждый компонент мог быть протестирован отдельно. Однако код, связанный с пользовательским интерфейсом, плохо поддается модульному тестированию, потому что для этого часто требуется участие пользователя для запуска логики в UI. Кроме того, любая визуализация часто требует оценки со стороны человека, что всё «выглядит правильно». *Отметим, что существуют решения для автоматизации тестирования пользовательского интерфейса. Однако они только имитируют взаимодействие с пользователем. Как правило, они сложнее в настройке и обслуживании, чем unit-тесты, и чаще всего используются при интеграционном тестировании, так как для этого требуется запуск всего приложения*.
* **Уменьшение возможности переиспользования**
Если ваш UI-код смешан с кодом логики и данных, то его становится гораздо сложнее переиспользовать.
Цели MV\*-паттернов
-------------------
Хотя каждый из паттернов имеет довольно много отличий, их цели похожи: отделить UI-код (View) от кода логики (Presenter, Controller, ViewModel и т. д.) и кода обработки данных (Model). Это позволяет каждому из них развиваться самостоятельно. Например, вы сможете изменить внешний вид и стиль приложения, не затрагивая логику и данные.
Кроме того, так как логика и данные отделены от отображения, то они могут быть протестированы отдельно. Для простых приложений это может быть не так важно. Например, если ваше приложение является простым редактором данных. Однако, если у вас более сложная логика интерфейса, то возможность автоматически проверить, что она работает правильно, будет очень ценной.
Model-View-Controller
---------------------
Одним из самых первых паттернов для отделения представления от логики и модели стал [Model-View-Controller](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller) (MVC). Эта концепция была описана [Трюгве Реенскаугом](https://en.wikipedia.org/wiki/Trygve_Reenskaug).
> **В 1979 году!** (Я тогда ещё даже не родился).
Этот паттерн был разработан для написания приложений на Smalltalk. Но в те дни, программирование было не таким, как сегодня. Не было Windows. Не было графического интерфейса пользователя. Не было библиотек виджетов. Если вы хотите пользовательский интерфейс, его нужно отрисовать самостоятельно. Или если вы хотите взаимодействовать с устройствами ввода, такими как клавиатура.
Но то, что сделал Трюгве было весьма революционным. Там, где все смешивали код отображения, логики и данных, он применил паттерн, чтобы разделить эти обязанности между отдельными классами.
Проблема паттерна MVC состоит в том, что это, вероятно, один из самых неправильно понятых паттернов в мире. И я думаю, это из-за названия. Трюгве сначала назвал паттерн Model-View-Editor, но позже остановился на Model-View-Controller. Понятно, что такое Model (данные) и что такое View (то, что я вижу на экране). Но что такое Сontroller? Является ли [Application Controller](http://www.martinfowler.com/eaaCatalog/applicationController.html) таким же, как в паттерне MVC? (*Нет, но вы можете увидеть, откуда взялась путаница*).
Что же представляют собой эти Model, View и Controller:
* **Model**
Модель – это данные вашего приложения, логика их получения и сохранения. Зачастую это модель предметной области (*domain model*), основанная на базе данных или на результатах от веб-сервисов. В некоторых случаях *domain model* хорошо проецируется на то, что вы видите на экране. Но иногда перед использованием ее необходимо адаптировать, изменить или расширить.
* **View**
View отвечала за отображение UI на экране. Без библиотек виджетов, это означало самостоятельную отрисовку блоков, кнопок, полей ввода и т. п. View также может наблюдать за моделью и отображать данные из неё.
* **Controller**
Controller обрабатывает действия пользователя и затем обновляет Model или View. Если пользователь взаимодействует с приложением (нажимает кнопки на клавиатуре, передвигает курсор мыши), контроллер получает уведомление об этих действиях и решает, что с ними делать.
> *Примечание от переводчика:*
>
> *Следует отметить, что Controller получает события ввода напрямую, а не через View. Контроллер интерпретирует пользовательский ввод от клавиатуры или мыши, и посылает команды модели и/или представлению внести соответствующие изменения.*
Я написал пример на скорую руку для иллюстрации того, как будет выглядеть контроллер в «чистой» реализации MVC. Я его реализовал на обычном asp.net (не asp.net MVC), но без применения каких-либо пользовательских элементов управления. Так что это более традиционный asp стиль. (*Да, это не очень удачный пример, но я надеюсь, что он станет отправной точкой к пониманию истинной роли контроллера*).
```
public class Controller
{
private readonly IView _view;
public Controller(IView view)
{
_view = view;
HttpRequest request = HttpContext.Current.Request;
if (request.Form["ShowPerson"] == "1")
{
if (string.IsNullOrEmpty(request.Form["Id"]))
{
ShowError("The ID was missing");
return;
}
ShowPerson(Convert.ToInt32(request.Form["Id"]));
}
}
private void ShowError(string s)
{
_view.ShowError(s);
}
private void ShowPerson(int Id)
{
var model = new Repository().GetModel(Id);
_view.ShowPerson(model);
}
}
```
После многих лет парадигма программирования несколько изменилась – появились пользовательские элементы управления ([виджеты](https://en.wikipedia.org/wiki/Widget_(GUI))). Виджеты как отрисовывают самих себя, так и интерпретируют пользовательский ввод. Кнопка знает, что делать, если вы кликните по ней. Поле ввода знает, что делать, если вы вводите текст в нём. Это уменьшает потребность в контроллере, и паттерн MVC стал менее актуальным. Однако так как по-прежнему существует необходимость отделения логики приложения от представления и от данных, набрал популярность другой паттерн под названием Model-View-Presenter (MVP).
Большинство примеров паттерна MVC фокусируются на очень небольших компонентах, таких как реализация текстового окна или реализация кнопки. При использовании более современных технологий пользовательского интерфейса (Visual Basic 3 является современным по сравнению со Smalltalk 1979), как правило, нет необходимости в этом паттерне. Но он может помочь, если вы разрабатываете свой виджет, используя очень низкий уровень API (например, Direct X).
Последние пару лет паттерн MVC стал снова актуальным, но уже по другой причине, в связи с появлением [ASP.NET MVC](https://www.asp.net/mvc). Фреймворк ASP.NET MVC не использует концепцию виджетов в отличии от ASP.NET. В ASP.NET MVC View представляет собой элемент управления ASPX, который отрисовывает HTML. И контроллер снова обрабатывает действия пользователя, так как он принимает HTTP запросы. На основании *http*-запроса он определяет, что делать (обновить Model или отобразить конкретную View).
Model-View-Presenter
--------------------
С развитием среды визуального программирования и внедрения виджетов, которые инкапсулирует отрисовку и обработку пользовательского ввода, отпала необходимость в создании отдельного класса контроллера. Но разработчики всё ещё нуждаются в отделении логики от представления, только теперь на более высоком уровне абстракции. Потому что оказалось, что если вы создаете форму из нескольких пользовательских элементов, она также содержит и логику интерфейса и данных. Паттерн MVP описывает, как отделить UI от логики интерфейса (что происходит при взаимодействии с виджетами) и от данных (какие данные отображать на экране).
* **Model**
Это данные вашего приложения, логика их получения и сохранения. Зачастую она основана на базе данных или на результатах от веб-сервисов. В некоторых случаях потребуется ее адаптировать, изменить или расширить перед использованием во View.
* **View**
Обычно представляет собой форму с виджетами. Пользователь может взаимодействовать с ее элементами, но когда какое-нибудь событие виджета будет затрагивать логику интерфейса, View будет направлять его презентеру.
* **Presenter**
Презентер содержит всю логику пользовательского интерфейса и отвечает за синхронизацию модели и представления. Когда представление уведомляет презентер, что пользователь что-то сделал (например, нажал кнопку), презентер принимает решение об обновлении модели и синхронизирует все изменения между моделью и представлением.
Стоит отметить одну важную вещь, что презентер не общается с представлением напрямую. Вместо этого, он общается через интерфейс. Благодаря этому презентер и модель могут быть протестированы по отдельности.
Существует два варианта этого паттерна: Passive View и Supervising Controller.
### Passive View
В этом варианте MVP представление **ничего не знает** о модели, но вместо этого предоставляет простые свойства для всей информации, которую необходимо отобразить на экране. Презентер будет считывать информацию из модели и обновлять свойства во View.
Это было бы примером PassiveView:
```
public PersonalDataView : UserControl, IPersonalDataView
{
TextBox _firstNameTextBox;
public string FirstName
{
get
{
return _firstNameTextBox.Value;
}
set
{
_firstNameTextBox.Value = value;
}
}
}
```
Как вы можете видеть, требуется писать довольно много кода как во View, так и в презентере. Тем не менее, это сделает взаимодействие между ними более тестируемым.
### Supervising Controller
В этом варианте MVP представление **знает** о модели и отвечает за связывание данных с отображением. Это делает общение между презентером и View более лаконичным, но в ущерб тестируемости взаимодействия View-Presenter. Лично я ненавижу тот факт, что этот паттерн содержит в названии «Controller». Потому что контроллер снова не тот, что в MVC и не такой, как Application Controller.
Это было бы примером представления в паттерне Supervising Controller:
```
public class PersonalDataView : UserControl, IPersonalDataView
{
protected TextBox _firstNameTextBox;
public void SetPersonalData(PersonalData data)
{
_firstNameTextBox.Value = data.FirstName;
}
public void UpdatePersonalData(PersonalData data)
{
data.FirstName = _firstNameTextBox.Value;
}
}
```
Как вы можете видеть, этот интерфейс является менее детальным и возлагает больше ответственности на View.
Presentation Model
------------------
Мартин Фаулер описывает на своем сайте другой подход для достижения разделения ответственности, который называется [Presentation Model](http://martinfowler.com/eaaDev/PresentationModel.html). PresentationModel представляет собой **логическое представление** пользовательского интерфейса, не опираясь на какие-либо визуальные элементы.
PresentationModel имеет несколько обязанностей:
1. **Содержит логику пользовательского интерфейса:**
Так же, как и презентер, PresentationModel содержит логику пользовательского интерфейса. Когда вы нажимаете на кнопку, это событие направляется в PresentationModel, которая затем решает, что с ним делать.
2. **Предоставляет данные из модели для отображения на экране**
PresentationModel может преобразовывать данные из модели так, чтобы они были легко отображены на экране. Часто информация, содержащаяся в модели, не может непосредственно использоваться на экране. Вам, возможно, сначала потребуется преобразовать данные, их дополнить или собрать из нескольких источников. Это наиболее вероятно, когда у вас нет полного контроля над моделью. Например, если вы получаете данные от сторонних веб-сервисов или же из базы данных существующего приложения.
3. **Хранит состояние пользовательского интерфейса**
Зачастую пользовательский интерфейс должен хранить дополнительную информацию, которая не имеет ничего общего с моделью. Например, какой элемент выбран в данный момент на экране? Какие ошибки валидации произошли? PresentationModel может хранить эту информацию в свойствах.
View может легко извлекать данные из PresentationModel и получать всю необходимую информацию для отображения на экране. Одно из преимуществ такого подхода заключается в том, что вы можете создать логическое и полностью тестируемое представление вашего UI, не полагаясь на тестирование визуальных элементов.
Паттерн Presentation Model никак не описывает, каким образом View использует данные из модели (PresentationModel).
Model-View-ViewModel
--------------------
Наконец, паттерн Model-View-ViewModel также известный, как MVVM или просто шаблон ViewModel. Он очень похож на паттерн Presentation Model:
В действительности едва ли не единственным отличием является явное использование возможностей связывания данных (*databinding*) в WPF и Silverlight. Не удивительно, потому что [Джон Госсман](http://blogs.msdn.com/johngossman/archive/2005/10/08/478683.aspx) был одним из первых, кто упомянул об этом паттерне в своем блоге.
ViewModel не может общаться со View напрямую. Вместо этого она представляет легко связываемые свойства и методы в виде [команд](http://msdn.microsoft.com/en-us/library/system.windows.input.icommand.aspx). View может привязываться к этим свойствам, чтобы получать информацию из ViewModel и вызывать на ней команды (методы). Это не требует того, чтобы View знала о ViewModel. XAML Databinding использует рефлексию, чтобы связать View и ViewModel. Таким образом, вы можете использовать любую ViewModel для View, которая предоставляет нужные свойства.
Некоторые из вещей, которые мне действительно нравится в этом паттерне, когда он применяется к Silverlight или WPF:
* Вы получаете полностью тестируемую логическую модель вашего приложения.
* Поскольку ViewModel предоставляет View всю необходимую информацию в удобном виде, то само представление может быть довольно простым. А дизайнер может экспериментировать с внешним видом и стилем в редакторе Expression Blend и изменять его, не влияя на пользовательский интерфейс.
* И, наконец, вы можете избежать написания кода для View (*code behind*). Теперь это повод для споров среди поклонников паттерна MVVM. Я лично считаю, что, как правило, вам не нужно писать дополнительный код для View, и найдется решение лучше. Да, иногда нужно проделать некоторые трюки (*такие как создание attached behaviors*), но они обеспечивают хорошие и переиспользуемые решения. Тем не менее я также признаю, что не все любят XAML разметку и связывание данных в XAML. Паттерн ViewModel не заставляет вас использовать или избегать *code behind*. Делайте то, что кажется вам правильным.
Заключение
----------
Я надеюсь, что это описание наиболее распространенных MV\*-паттернов поможет вам понять их различия.
> Комментарий переводчика:
>
>
>
> Как и автор, я надеюсь, что это описание поможет вам понять сходства и различия MV\*-паттернов. Разобравшись в них, вам будет легче принять решение, какой из паттернов применить в своем приложении.
>
>
>
> Основные выводы, которые можно сделать из статьи:
>
> * Модель во всех паттернах выглядит одинаково и имеет одну и ту же цель – получение, обработка, а также сохранение данных.
> * В классическом MVC пользовательский ввод обрабатывает Controller, а не View.
> * Современные ОС и библиотеки виджетов берут на себя обработку пользовательского ввода, поэтому у вас больше нет нужды в контроллере из паттерна MVC.
> * Цель MV\*-паттернов: отделить друг от друга отображение UI, логику интерфейса и данные (их получение и обработку).
> * Используя MV\*-паттерн в своем приложении, вы упрощаете его поддержку и тестирование, отделяете данные от способа их визуализации.
> * MVP достаточно универсальный паттерн и подойдет во многих случаях (это мое личное мнение). Какой вариант использовать: Passive View или Supervising Controller – решать вам. Руководствуйтесь тем, что вам нужно: больше контроля и тестируемости либо лаконичности и краткости кода. Лавируйте между задачами и применяйте тот или другой подход.
> * Если в системе присутствует хорошая реализация автоматического связывания данных (databinding), то MVVM – это ваш выбор.
> * Presentation Model – хорошая альтернатива MVVM, и будет полезна там, где нет автоматического связывания. Но вам придется писать код связывания самостоятельно (это несложный, но рутинный код). Есть идеи, как это элегантно реализовать, но об этом мы поговорим в следующей [статье](https://habrahabr.ru/company/mobileup/blog/326962/).
>
>
>
>
>
> *P.S. Отдельно хочу поблагодарить своего коллегу [Jeevuz](https://habrahabr.ru/users/jeevuz/) за помощь при подготовке перевода*. | https://habr.com/ru/post/313538/ | null | ru | null |
# Парсинг сайтов судов общей юрисдикции в России
### История о том, как выявлять новые иски к клиенту
Содержание
----------
1. [Введение](https://1)
2. [Парсить сайты судов общей юрисдикции - законно?](https://2)
3. [Разведка боем](https://3)
4. [Что нужно от сайта](https://4)
5. [Выбор стратегии поиска](https://5)
6. [Собираем](https://6)
7. [Записываем](https://7)
8. [Формируем датасеты для сравнения, отчет](https://8)
9. [Отправляем отчет себе или коллегам на почту](https://9)
10. [Заключение](https://10)
I. Введение
-----------
1. Статья не претендует на статус полноценного исследования и написана начинающим. Программирование - мое хобби, работаю юристом и специализируюсь на судебных спорах.
2. Доверитель захотел регулярно получать информацию обо всех исках, которые к нему предъявляют.
3. Споры бывают «бытовые» и коммерческие. Бытовые (потребительские, трудовые, «дачно-гаражно-дворовые» споры и др.) рассматриваются судами общей юрисдикции, коммерческие – арбитражными судами. Особняком стоят споры с гос.органами, которые при разных условиях рассматриваются и там, и там.
4. С мониторингом не завершенных коммерческих споров (когда дело еще рассматривается судом) все хорошо. Все арбитражные суды (чуть меньше 120) == [один сайт](https://kad.arbitr.ru/) с информацией о спорах. С ним можно подписаться на конкретную компанию или судебный спор, быстро найти информацию и получать апдейты о них.
Вводишь ИНН организации – и в поисковой выдаче все споры (как продолжающиеся, так и завершенные) с этой организацией во всех арбитражных судах России за все время существования сайта. Определение о принятии иска, об отложении / приостановлении разбирательства, о назначении экспертизы и др. Красота.
5. Совсем другое дерево – это общая юрисдикция. Запасись терпением всяк сюда входящий.
Если нужна информация о незавершенном споре в суде общей юрисдикции - добро пожаловать на 2500+ сайтов судов (не считая мировых судей, которых в 10 раз больше), унифицированного каталога либо нет, либо он недоступен простым смертным. Информацию о споре в конкретном суде получаем только на сайте этого суда через поиск.
Если нужен судебный акт по завершенному спору (для нашей задачи не интересен) – идем в [ГАС «Правосудие»](https://sudrf.ru/). Все-таки случайно здесь появляются судебные акты по не завершенным спорам. Но подвох в том, что суды в 99% случаев не публикуют такие акты, и акты не попадают в видимый для пользователя сегмент ГАС «Правосудие». Для нашей задачи ГАС «Правосудие» - источник крайне не надежный.
6. Мега-приложение на 2500+ сайтов судов писать нет ресурсов, выбрали 19 наиболее вероятных для подачи иска судов. Сайты мировых судей отсекли из-за низкой цены потенциального иска (50 000 руб.).
7. Тайна юридической помощи – такая же важная, как медицинская или банковская. Поэтому в коде не будет ссылок, которые помогают раскрыть моего доверителя. Все герои вымышлены, а совпадения - случайны.
8. Использовать буду не «скраппинг», а старинное русское «парсинг» как более понятное широкому кругу читателей слово.
Ну что, погнали?
II. Парсить сайты судов общей юрисдикции – законно?
---------------------------------------------------
В повседневной работе я не занимаюсь глубоко вопросами интеллектуальной собственности.
Парсинг сайтов в мире и в России – вопрос актуальный и однозначного решения не имеет. Выражаясь грубо, правопорядки ищут компромисс между позициями «А чо, парсер же как человек смотрит, человеку же можно!» и «Это моя база данных, я ее танцую, и вообще у меня сервер от ваших ботов стонет».
Моими коллегами написано множество интересных материалов на эту тему. Есть уйма интересных судебных дел в других правопорядках (American Airlines v. FareChase, Facebook v. Power Ventures, Craigslist, Inc. v. Instamotor, Inc. и др.). Россия - не исключение, один только спор [Double Data v. VK](https://kad.arbitr.ru/Card/1f33e071-4a16-4bf9-ab17-4df80f6c1556) чего стоит.
Ситуация с некоммерческими сайтами судов яснее. Открытость и гласность – ключевые принципы судопроизводства. В отношении информации на сайте судов в России принят отдельный закон: Федеральный закон от 22.12.2008 № 262-ФЗ «Об обеспечении доступа к информации о деятельности судов в Российской Федерации». Помимо этого еще есть масса других документов, к примеру:
1. «Положение по созданию и сопровождению официальных Интернет-сайтов судов общей юрисдикции Российской Федерации» (утв. Постановлением Президиума Верховного Суда РФ от 24.11.2004);
2. «Регламент размещения информации о деятельности федеральных судов общей юрисдикции …» (утв. Приказом Судебного департамента при Верховном Суде РФ от 02.11.2015 № 335);
3. Постановление Пленума Верховного Суда РФ от 13.12.2012 № 35 «Об открытости и гласности судопроизводства и о доступе к информации о деятельности судов»;
4. "Концепция информационной политики судебной системы на 2020 - 2030 годы" (одобрена Советом судей РФ 05.12.2019);
5. Может быть, на каком-то из 2500+ сайтов судов есть правила конкретного сайта, но я с таким не сталкивался.
Во всех этих документах про парсинг, скраппинг, автоматизированный сбор данных нет ни слова. На то мы и юристы, чтобы говорить «да» или «нет» в отсутствие конкретного правила.
Есть ряд норм, которые позволяют утверждать, что собирать оттуда данные вполне себе законно (читать нужно возвышенно, с трепетом):
1. Часть 1, 3 статьи 4 Закона № 262-ФЗ: *основными принципами обеспечения доступа к информации о деятельности судов являются 1) открытость и доступность информации о деятельности судов, за исключением случаев, предусмотренных законодательством Российской Федерации; 3) свобода поиска, получения, передачи и распространения информации о деятельности судов любым законным способом*;
2. Часть 1, 2 ст. 8 Закона № 262-ФЗ: *пользователь информацией имеет право 1) получать достоверную информацию о деятельности судов; 2) не обосновывать необходимость получения запрашиваемой информации о деятельности судов, доступ к которой не ограничен.*
В Концепции (п. 4 выше) есть "угроза" парсингу, но она направлена на борьбу с охотниками за персональными данными: «*особую важность приобретает проведение мероприятий по противодействию незаконной обработке и сбору сведений о гражданах, в том числе персональных данных граждан на территории Российской Федерации неуполномоченными и неустановленными лицами, а также используемыми ими техническими средствами*». К слову, аппарат суда обязан сделать так, чтобы информация на сайте была анонимной. В судебных актах даже даты и суммы компенсаций морального вреда затирают, не говоря уже о персональных данных. Поэтому этот пункт концепции вряд ли коснется парсинга в обозримом будущем.
Есть и такой теоретический аргумент: право знать о о судебных делах со своим участием (в т.ч. с использованием парсинга, если законодатель не упростил поиск) – это элемент права на судебную защиту (ч. 1 ст. 46 Конституции РФ).
Учитывая:
1. содержание норм ст. 3, 8 Закона № 262-ФЗ;
2. что информация на сайтах судов != информации на сайтах судов коммерческих;
3. необходимость гласности и открытости судопроизводства;
4. что собирая информацию таким способом, я реализую свое право на судебную защиту,
я склонен толковать отсутствие прямого запрета на парсинг сайтов судов общей юрисдикции в пользу его правомерности. При этом этику парсинга никто не отменял.
Есть и «стахановцы» – Дальневосточный федеральный университет [угрожал](https://www.newsvl.ru/vlad/2020/03/10/188366/#ixzz6GKRXmL30) разработчикам уголовной ответственностью (ст. 272 УК РФ, «Неправомерный доступ к компьютерной информации»). No comments.
III. Разведка боем
------------------
Обобщим и проанализируем собственный пользовательский опыт.
#### 1. Поиск на сайтах судов устроен по-разному, например:
1. Типичный случай - [Центральный районный суд г. Красноярска](https://centr--krk.sudrf.ru/modules.php?name=sud_delo&srv_num=1&name_op=sf&delo_id=1540005): результаты поиска вносит прямо в html-код страницы, делая его удобным для сбора;
2. В противоположность коллегам [Советский районный суд г. Казани](http://sovetsky.tat.sudrf.ru/modules.php?name=sdp2_cases#%7B%22dateValue%22:%2217.07.2022%22%7D) отражает результат через обращение к «[тайным сегментам](https://bsr3.sudrf.ru)» ГАС «Правосудие» с использованием Java Script.
3. Суды Санкт-Петербурга славятся не только диалектизмами, но и [каптчей](https://primorsky--spb.sudrf.ru/modules.php?name=sud_delo&name_op=sf&delo_id=1540005).
4. Суды Москвы, как положено москвичам, имеют абсолютно другой сайт. И по стилю, и по архитектуре, и по кодировке - UTF-8 вместо windows-1251. Он называется «портал» и охватывает все релевантные суды, например: [Бабушкинский районный суд](https://mos-gorsud.ru/rs/babushkinskij). Поиск спора там все равно происходит по отдельному суду.
#### 2. Компания может называться на сайте по-разному, и поисковая выдача будет отличаться
Пример - Министерство финансов:
Ищем дела в Центральном районном суде г. Красноярска с участием «Министерство финансов РФ»:
Ищем дела с участием «Минфин»:
Я проверил 5 случайных дел из 50 (выдача «Минфин»), 2 из них попали в 708 (выдача «Министерство финансов»), а 3 – нет.
Сюда попадают сложные / иностранные названия компаний.
#### 3. Поиск по ИНН не всегда срабатывает
Не все суды указывают его в карточке дела => не все споры попадают в выдачу. Смотреть все равно приходится по названию компании или ФИО лица. Возьмем Минфин в Химкинском городском суде.
Поиск по названию «Министерство финансов РФ»:
Поиск по ИНН Министерства финансов РФ (7710168360):
#### 4. Время отклика сайтов отличается от 2 сек до 2 мин, и они постоянно падают
У меня стабильное подключение к интернету. Несмотря на это один и тот же сайт прогружается с разной скоростью, а иногда и вовсе падает. Обновил еще раз – заработало.
Как-то раз одновременно и ровно на 5 дней упало 12 сайтов из 19.
#### 5. Гражданские и административные дела в первой инстанции == один каталог
Я не нашел ни одного суда из 19, который для поиска административных дел создал бы отдельный каталог для споров с гос.органами. Задача немного проще, т.к. один сайт суда == один каталог.
#### 6. Полезное наблюдение
У каждого сайта есть счетчик дел, которые сайт нашел применительно к конкретной компании:
Однако иски к моему доверителю есть не во всех судах, поэтому может срабатывать и такое:
#### Выводы по итогам разведки:
1. Я пока не умею преодолевать капчи, сайты судов Спб недоступны для меня. Аналогично с сайтами, получающими данные от других сайтов через Java Script. Благо, среди тех 19 сайтов их не оказалось.
2. Написать что-то унифицированное тоже вряд ли получится – сайты различаются.
3. Придется выяснить все возможные названия доверителя, чтобы поисковая выдача была полной.
4. У парсера нужно сделать «вторую попытку» попасть на сайт.
5. Сайт обновляется, смотреть его нужно каждый день и сравнивать результаты с предыдущими наблюдениями.
IV. Что нужно от сайта
----------------------
Стандартная поисковая выдача не-московских судов выглядит так:
У московских - так:
Как видим, указывается № дела, дата поступления, стороны, судья и др. Не всегда поисковая выдача влезает на 1 страницу.
При переходе в конкретное дело появляется справочная информация:
Поскольку доверитель - не частый гость в судах, судебное дело для него – серьезное событие. Появления дела на сайте уже достаточно, чтобы юрист начал тратить на него время: знакомиться с материалами дела, запрашивать информацию у коллег и суда и др. Заставлять парсер считывать и выгружать еще и карточки по конкретным делам не нужно – достаточно уведомить юриста о появлении нового дела в конкретном суде.
Это сильно облегчает задачу - нужен парсер-«будильник», который сообщает о новом деле.
V. Выбор стратегии поиска
-------------------------
Среди вариантов сбора наиболее подходящие:
1. Считаем количество вхождений названия доверителя каждый день, если вхождений стало больше => появилось новое дело.
2. Смотрим на дату: как только а) появилась новая дата (счетчик) или б) дата позднее определенного числа => появилось новое дело. Этот подход очень удобен при ручном сборе данных.
3. У каждого суда есть счетчик дел по конкретному делу. Счетчик по сравнению со вчерашним днем увеличился => появилось новое дело.
Попробовав все варианты по очереди, всласть наигравшись с датами, остановился на варианте № 3 как на самом простом и посильном для меня.
VI. Собираем
------------
Нужно собрать конкретный кусок html-кода с 19 неодинаковых сайтов.
Я разрубил гордиев узел. На сайте вручную нашел нужную поисковую выдачу и скопировал ссылку из браузера. Все. Какой уж там Scrapy или Selenium. Даешь request-хардкор!
Получилось так:
```
import pandas as pd
import os
import requests
import re
import datetime
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
headers = {'user-agent': '__________'}
############################### СОБИРАЕМ ИНФОРМАЦИЮ ПО КАЖДОМУ СУДУ ИЗ СПИСКА ################################
#N-ский районный суд
response = requests.get("https://огромная в 8 строк ссылка на конкретную поисковую выдачу N-ского районного суда", headers=headers)
response.encoding = 'windows-1251'
pattern = re.compile(r'Всего по запросу найдено.....')
c = pattern.findall(response.text)
err = 0
try:
print('N-ский районный суд', datetime.date.today(), c[0][27:]) #индекс переменной c для каждого сайта подбирал руками. Помните? Только request-хардкор!
except IndexError:
try:
print('N-ский районный суд', datetime.date.today(), c[0][27:]) # распечатка нужна для отладки и просмотра работы при запуске в терминале
except IndexError:
err = 1
# N5-ский районный суд, где судов в отношении доверителя нет вовсе
response5 = requests.get('https://',
headers=headers)
pattern5 = re.compile(r'ничего не найдено')
c5 = pattern5.findall(response5.text)
err5 = 0
if c5 == ['ничего не найдено']:
print("N5-ский районный суд ", datetime.date.today(), 0)
else:
try:
print("N5-ский районный суд ", datetime.date.today(), c5[0][27])
except IndexError:
try:
print("N5-ский районный суд ", datetime.date.today(), c5[0][27])
except IndexError:
err5 = 1
```
После получения ссылки находим в ней нужные слова, потом выводим результат, проиндексировав pattern.
И так применительно ко всем 19 судам по одному наименованию доверителя. Там, где кодировка UTF-8, я ее не указывал, но все работало. На создание ссылок ушло 30 минут. Даже подумал, что парсер не нужен, надо выписать эти ссылки в отдельный документ и просто каждое утро открывать их в браузере руками.
Если нужно было бы обработать 200+ сайтов судов - задача заиграла бы новыми красками.
VII. Записываем
---------------
Прежде чем записывать собранную информацию, создадим переменные дат, чтобы хранить и сравнивать результаты в .txt-файлах. Сравнивать будем за 3 дня.
```
date = datetime.date.today()
filename_today = str(datetime.date.today()) + str('.txt')
filename_yesterday = str(datetime.date.today()-datetime.timedelta(days=1)) + str('.txt')
filename_2_days_ago = str(datetime.date.today()-datetime.timedelta(days=2)) + str('.txt')
```
При написании этой истории для Хабра меня осенило, что это можно было проще запилить через MySQL, но это уже «на будущее».
Формируем строку для записи:
```
# N-ский районный суд
if err == 1: #на случай, если сайт не прогрузился или упал.
N-sk = str('N-ский районный суд ') + str(date) + ' ' + str(0.1) # указываем десятичную дробь, чтобы при сравнении датасетов было видно, что информация с сайта не получена
else:
N-sk = str('N-ский районный суд ') + str(date) + ' ' + str(c[0][27:])
# N5-ский районный суд, где судов в отношении доверителя нет вовсе
if c5 == ['ничего не найдено']:
N5-sk = str('N5-ский ') + str(date) + ' ' + str(0)
elif err4 == 1:
N5-sk = str('N5-ский ') + str(date) + ' ' + str(0.1)
else:
N5-sk = str('N5-ский ') + str(date) + ' ' + str(c15[0][2]
```
VIII. Формируем датасеты для сравнения и отчёт
----------------------------------------------
```
x = pd.read_csv(filename_today, sep=" ", header=None)
y = pd.read_csv(filename_yesterday, sep=" ", header=None)
z = pd.read_csv(filename_2_days_ago, sep=" ", header=None)
col1 = x[2]
col2 = y[2]
col3 = z[2]
consolidated_table = z.join(col2, rsuffix='Вчера').join(col1)
consolidated_table.rename(columns={0: 'Название суда', 1: 'Дата', '2': 'Позавчера', 2: 'Сегодня'}, inplace=True)
consolidated_table['Сравнение'] = (consolidated_table['Сегодня'] == consolidated_table['Позавчера']) & (consolidated_table['Сегодня'] == consolidated_table['2Вчера'])
html_table = consolidated_table.to_html()
```
Как ни крутил .join, так и не смог в итоговой выдаче избавиться от "**2**Вчера".
IX. Отправляем отчёт себе или коллегам на почту
-----------------------------------------------
```
msg = MIMEMultipart()
message = 'Report'
# определяем параметры сообщения
password = ""
msg['From'] = ""
msg['To'] = ""
msg['Subject'] = "Report"
# добавляем текст сообщения
html_table = MIMEText(html_table, 'html')
msg.attach(html_table)
# создаем сервер
server = smtplib.SMTP('smtp._______: 587')
server.starttls()
# логинимся для отправки
server.login(msg['From'], password)
# отправляем
server.send_message(msg)
server.quit()
print("Отправлено: %s:" % (msg['To']))
```
Хотя подключение и разрешения для отправки писем и предусмотрено стандартными почтами, мне пришлось повозиться с подключением и разрешениями отправлять письма с этого адреса. К своему стыду не сразу понял, что письма с отчетами автоматически улетали в спам.
Вот так выглядит результат анализа, который приходит на почту каждые 8 часов (спасибо планировщику задач, который запускает программу по расписанию):
Итоговый код выложил на Гитхабе [здесь](https://github.com/ArtemSabirov/scrapping_coutrs).
X. Заключение
-------------
Из моих мытарств случился рабочий код, который экономит время. Отсмотрел код в очередной раз и теперь не уверен, что это "приложение" можно назвать парсером в чистом виде.
Что дальше:
1. Краулеры под отдельные типы сайтов или хотя бы функция, которая перебирает словарь, чтобы код было удобнее сопровождать и проводить отладку.
2. Доставать данные с сайтов судов, которые обращаются к другим через Java Script, обходить питерские каптчи. Интересно какие еще сюрпризы таят в себе 2500+ сайтов.
3. Уйти от сравнения данных через .txt файлы, при долговременном использовании неудобно.
Буду благодарен за критику. | https://habr.com/ru/post/679514/ | null | ru | null |
# Статическое тестирование безопасности опенсорсными инструментами
Уязвимости в своём коде хочется находить как можно быстрее, а значит нужно автоматизировать этот процесс. Как именно автоматизировать поиск уязвимостей? Существует динамическое тестирование безопасности, существует статическое — и у обоих свои преимущества и недостатки. Сегодня подробно разберёмся со статическим на опыте его применения в Одноклассниках.
По каким принципам можно выбирать инструмент для статического тестирования? С какими сложностями сталкиваешься, когда уже выбрал? Как писать собственные правила анализа, расширяющие стандартную функциональность? Я занималась всеми этими вопросами — и теперь делюсь с Хабром тем, что узнала.
Речь пойдёт о Java, веб-приложениях, SonarQube и Find Security Bugs, но рассказанное применимо также для других языков и технологий.
В основу поста лёг мой доклад с конференции Heisenbug: если вам удобнее видеоформат — можете посмотреть его, если текст — читайте дальше.
План:
-----
* [Предисловие](#intro)
* [Теория](#theory)
* [Выбираем статический анализатор](#benchmark)
* [Практика](#practice)
Предисловие
-----------
Очевидным способом автоматизировать тестирование безопасности веб приложений является использования сканеров уязвимостей, например [OWASP ZAP](https://owasp.org/www-project-zap/) или [Accunetix](https://www.acunetix.com/).
Такие сканеры применяют [фаззинг](https://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%B7%D0%B7%D0%B8%D0%BD%D0%B3), что сопряжено с рядом проблем:
* Наблюдается комбинаторный взрыв количества запросов, выполняемых в ходе тестирования: умножаем количество параметров в приложении на размер списка значений для фаззинга и получаем нагрузку, которую может выдержать не каждая тестовая инфраструктура;
* Фаззер не запоминает состояние приложения и не учитывает логику его работы, и поэтому некоторые уязвимости пропускает;
* При добавлении в приложение новых форм, страниц, API требуется дополнительно обучать сканер.
В сложной системе всё это осложняет процесс тестирования безопасности, и мы обратились к статическому анализу.
Что нам было нужно?
* Дешёвое масштабирование: автоматизированный инструмент, который можно запускать часто, на большом количестве приложений, и это не будет требовать значительного количества ручного труда;
* Возможность воспользоваться уже существующими у нас знаниями о ранее найденных уязвимостях (если мы какие-то баги уже исправили, то было бы неплохо найти все похожие);
* Способ искать уязвимости не только в вебе, но и в мобильных приложениях.
С таким списком ожиданий мы попробовали внедрить у себя статический анализ.
Но прежде чем перейти к рассказу об этом посмотрим, как статический анализ может использоваться для поиска уязвимостей и насколько это укладывается в вышеперечисленные пожелания.
Теория
------
Идея статического анализа (применения формальных методов для анализа программы) не нова. Первый известный человечеству статический анализатор — это Lint, выпущенный в 1979 году, то есть он старше многих читателей этого текста. Lint воспринимал код как текст и искал подстроки — по сути, не отличался от grep.
По большому счету, для поиска уязвимостей статический анализ может предложить два подхода:
Первый применяется для поиска конструкций в коде, которые потенциально могут приводить к проблемам с безопасностью: вызовов небезопасного API, задепрекейченных функций, захардкоженных паролей или ключей шифрования и так далее.
Второй подход — анализ потока данных или потока управления программы. Если мы можем построить модель, описывающую в каком порядке выполняются конструкции в коде или как распространяются данные, то можем и делать утверждения об особенностях этого распространения, и таким образом находить уязвимости.
Чтобы объяснить статическому анализатору, как именно выглядит уязвимость в программе, нам нужно написать правило. Иногда статические анализаторы называют их детекторами.
Детектор формулирует требование к исходному коду (например, “строки SQL запросов не содержат изменяемых извне данных”) и используют построенные статическим анализатором модели чтобы проверить, выполняется ли это требование.
Какая информация доступна детекторам?
Во-первых, это абстрактное синтаксическое дерево (AST). AST в своих узлах содержит метаинформацию о каждом элементе программы. Это практически дерево разбора, которое строит компилятор.
Фрагмент Java-кода в виде абстрактного синтаксического дерева будет выглядеть как-то так:
Вот некоторые правила, которые можно было бы реализовать на основе данных из AST:
— “класс, переопределяющий equals(), должен переопределить и hashCode()”;
— “строковые литералы не должны присваиваться переменным с названиями password или secret”.
Во-вторых, статические анализаторы строят граф потока управления (Control Flow Graph, CFG). CFG описывает переходы между базовыми блоками в программе, позволяя получить все возможные пути исполнения.
Граф потока управления строится на основе абстрактного синтаксического дерева. Детекторы используют CFG для проверки утверждений о порядке выполнения инструкций. Так же CFG используется для построения другой важной модели — графа потока данных, которая, в свою очередь, нужна для taint analysis.
Адекватного русского перевода этого термина, похоже, не существует, а что это такое, проще всего объяснить на примере. Вот распространенная уязвимость cross-site scripting (XSS) в самой простой реализации:
```
String foo = request.getParameter("foo");
response.getWriter().write(foo);
```
В этих двух строках сервлет умудряется дать возможность атакующему выполнить произвольный JavaScript в браузере пользователя.
Что здесь происходит? Мы видим переменную «foo», которая содержит значение из параметра запроса в неизменном виде. Приложение записываем его в тело ответа. То есть, если в параметре foo передана строка, содержащая html тэги, то браузер пользователя будет интерпретировать ее как фрагмент HTML-разметки.
Taint analysis используется для того, чтобы искать подобные уязвимости: разного рода инъекции, cross site scripting, утечки персональных данных — всё, что связано с передачей параметров в программе.
Как это работает? Сначала анализатор определяет все точки, в которых в программу могут попасть данные, изменяемые извне. Их называют tainted, от английского «taint» — «портить», «заражать». В нашем примере параметр foo является tainted, потому что getParameter возвращает значение, контролируемое атакующим.
Как соответствующий детектор понимает, какие из методов могут поставлять изменяемые извне параметры? Он содержит в себе список сигнатур. Понятно, что этот список будет специфичен для языка, технологии, фреймворка. Можно рассчитывать, что статический анализатор содержит правила для стандартных или популярных API “из коробки”,. но вы можете дополнять их, если у вас есть какие-то специальные знания про ваш код.
Итак, мы нашли точку входа, которая может быть источником уязвимости. Следующий шаг — найти все попытки использовать эту переменную в потенциально небезопасных контекстах. В примере выше значение из переменной используется при формировании ответа сервера и делает приложение уязвимым к XSS; использование ее при генерации SQL-запроса означало бы всем известную SQL-инъекцию. Использование такой переменной в имени файла могло бы дать атакующему доступ к файловой системе и так далее.
Для обнаружения потенциально небезопасных вызовов детектор поступает здесь по аналогии с tainted: ищет по заранее известному списку сигнатур и обозначает как sink, от английского «просачиваться», «проникать».
И если в анализируемом приложении существует путь от tainted к sink, то можно сделать вывод о наличии потенциальной уязвимости.
Предположим, что мы исправили уязвимость и экранируем все специальные html символы впараметре foo, что делает его дальнейшее использование безопасным. На этот случай у анализатора есть ещё и список сигнатур санитайзеров — методов, которые очищают данные. Они прерывают цепочку между tainted и sink. То есть, если на пути от tainted к sink у нас встречается метод, очищающий данные, то предупреждения об уязвимости быть не должно.
Казалось бы у нас есть, всё, чтобы искать уязвимости в нашем коде.
Как всегда, всё не так просто, как выглядит. К сожалению, у статического анализа есть ряд ограничений. Два самых досадных для мира web-приложений рассмотрим ниже.
Первое — использование reflection. Reflection активно используется в Dependency Injection-фреймворках и не только, мешая статическому анализатору построить граф потока управления и, соответственно, провести taint analysis.
Понятно, почему это происходит. Cтатический анализатор не понимает, что в приведенном фрагменте кода вызывается метод bar(). Соответственно, если метод bar() включен в какой-то список сигнатур sink, то анализатор не поймет, что он был вызван.
Эту проблему можно частично решить добавлением дополнительных правил, учитывающих особенности конкретного проекта
Другим ограничением для статического анализа является генерация исходного кода во время исполнения программы
Если мы говорим про web-приложения, то самый распространенный пример — это шаблонизаторы. В отличии от JSP, которые прекомпилируются в Java-код и могут быть проанализированы, современные шаблонизаторы — это статические HTML-файлы с возможностью включения вычисляемых выражений. Эти выражения вычисляются в рантайме и результаты подставляются в шаблон.
В этом случае мы не можем отследить цепочку вызовов, и taint analysis, вероятно, будет неполным.
Выбираем статический анализатор
-------------------------------
Статических анализаторов для Java много: есть и проекты в опенсорс, и коммерческие продукты. Нужно определиться с требованиями к инструменту. Вот такие пожелания сформулировали мы:
* Первое очевидно: поддержка тех технологий, которые мы используем. В Одноклассниках мы пишем на Java, у нас есть JavaScript и TypeScript, а ещё мы хотим сканировать мобильные приложения, поэтому нужна поддержка Android-а.
* Второе: мы однозначно хотим taint analysis. Как мы только что выяснили, эта штука нужна, чтобы находить инъекции и подобные им баги, а они составляют значительную часть всех проблем.
* Мы поняли, что не ограничимся набором стандартных правил, потому что в нашем коде есть конструкции, которые статический анализатор «из коробки» не понимает, возможность кастомизации правил нам важна.
* Хотим, чтобы у разработчиков была единая «точка правды» про наш статический анализ: чтобы все использовали одну и ту же версию правил, знали статус сканирования на данный момент, видели какие из найденных ошибок являются ложными срабатываниями, а какие настоящими багами. В общем, нам нужен collaboration сервер.
* Наконец, мы хотим, чтобы добавление двух строчек кода в наш проект не повлекло необходимость переделывать всё. Если мы уже разобрали результаты сканирования на настоящие баги и ложные срабатывания, то следующее сканирование с небольшими изменениями позволяло бы переиспользовать предыдущие результаты.
В открытом доступе можно найти исследования, сравнивающие различные статические анализаторы. Посмотрим на одно из них, сделанное проектом OWASP (Open Web Application Security Project) в 2016-м (<https://github.com/OWASP/benchmark>). OWASP написал бенчмарк — приложение на Java с уязвимостями в заранее известных местах и просканировал его несколькими сканерами. Результат ниже:
Диаграмму не назвать интуитивно понятной, но разберёмся, что здесь изображено. Красная пунктирная линия — это результат, соответствующий случайному угадыванию. Все, что выше этой линии — лучше.
Также диаграмме можно заметить взаимосвязь между полнотой (сколько из всех багов было найдено) и точностью (сколько из найденного действительно является багами) анализатора. Сканеры с меньшим количеством ложных срабатываний пропускали больше багов.
Если это учесть, то мы видим, что все инструменты дают примерно одинаковый результат, нет явного лидера. У всех по-разному настроен баланс между настоящими уязвимостями и ложными срабатываниями, а в целом соотношение примерно одинаковое. Явного лидера нет, и коммерческие сканеры не показывают принципиально другие результаты по сравнению с опенсорсными.
Также OWASP протестировал один и тот же сканер Find Security Bugs с разными наборами правил, и в этом случае видно, что чем больше правил, тем больше уязвимостей обнаруживается. То есть добавление правил очевидно приносит результат.
Какой вывод мы можем сделать? Вероятно, выбор движка в статическом анализаторе не так важен для нас, как мощность набора правил и возможность дописывать детекторы под свои нужды.
Мы решили использовать опенсорсный [Find Security Bugs](https://find-sec-bugs.github.io/). Это плагин для всем известного статического анализатора для Java, который раньше назывался FindBugs, а теперь называется SpotBugs. Find Security Bugs добавляет разнообразные детекторы, связанные с безопасностью, в том числе и для Android.
Также это единственный опенсорсный анализатор для Java, позволяющий добавлять свои правила taint analysis.
Всё, что связано с коллаборацией, с работой внутри команды и с серверной частью нашего инструмента, отдано [SonarQube](https://www.sonarqube.org/). У Find Security Bugs есть плагин для SonarQube, позволяющий загружать отчеты на сервер и управлять результатами сканирования.
Практика
--------
Давайте попробуем применить описанное на практике. Для примера — уязвимое веб приложение на Spring и Thymeleaf.
Я специально выбрала фреймворки, которые в стандартном наборе правил Find Security Bugs не поддерживаются, чтобы мы могли написать свои детекторы. Код примеров есть [на GitHub](https://github.com/alexandra-s/heisenbug-demo).
### Пример 1
В посте уже упоминался такой баг — это XSS, использование значения из параметра запроса при формировании HTML-разметки.
```
@ExceptionHandler({IllegalArgumentException.class})
public void oops(HttpServletRequest request, HttpServletResponse response) {
String originalURL = request.getRequestURL() + "?" +
URLDecoder.decode(request.getQueryString());
// ...
PrintWriter writer = response.getWriter();
writer.write("Error procesing page " + originalURL + "
========================================
");
writer.flush();
// …
}
```
Мы уже знаем, как работают статические анализаторы.
originalURL будет отмечен как tainted, потому что request.getQueryString() использует значение из HttpServletRequest без предварительной проверки.
А в writer.write() у нас есть sink, потому что мы записываем “испорченное” значение в тело ответа.
Запускаем анализатор, и он готовит отчет, где действительно указано, что в этих строках содержится потенциальная уязвимость:
### Пример 2
```
@GetMapping("/photo")
public String photo(@RequestParam("id") long id, Model model) {
Photo photo = photoRepository.findOne(id);
// …
m.addAttribute("photo", photo)
// …
return "/photo";
}
```
```
```
Здесь у нас Spring endpoint, который выводит пользователю фотографию с комментариями. Статический анализатор не находит проблемы. Но действительно ли всё нормально в этом коде?
На самом деле нет. Вызов photoRepository.findOne(id) может вернуть данные, содержащие пользовательский ввод, то есть это taint. Дальше эти значения используются в шаблоне небезопасным способом (th:utext выводит строку без изменений). Если в тексте комментария будут HTML-теги, они сломают разметку и будут интерпретированы браузером HTML.
Поможем Find Security Bugs найти уязвимость в этом коде.
В данном случае можно придумать два варианта детектора.
Первый: можем сказать нашему анализатору, что вообще все попытки вывести в шаблонах какой-то текст без экранирования (то есть все упоминания «ph:utext») — это потенциальные уязвимости. Мы, вероятно, найдем все уязвимости и ещё какое-то количество ложных срабатываний.
Другой способ: искать все попытки добавить непроверенные данные в контекст шаблонизатора.
Добавим правило, помечающее addAttribute() как sink, и тогда наш анализатор сможет построить цепочку вызовов от taint к sink и отследить потенциальные уязвимости.
Find Security Bugs позволяет нам задавать списки этих сигнатур в конфиг файле. Мы можем просто передать ему файл с сигнатурами этих методов. Вызов Find Security Bugs и cодержимое файла может выглядеть так:
В нижней строке описан sink — метод addAttribute(). Здесь есть полное имя класса, название метода, список аргументов, тип возвращаемого значения, а также указан номер аргумента, в который, собственно, и нельзя передавать “испорченные” значения.
Очень хорошо, что Find Security Bugs не заставляет нас писать такие строки руками, а предоставляет [калькулятор](https://find-sec-bugs.github.io/signature-helper/), который позволяет генерировать эти сигнатуры из Java-интерфейсов.
### Пример 3
```
@GetMapping("/photo")
public String photo(@RequestParam("id") long id, Model model) {
Photo photo = photoRepository.findOne(id);
// …
model.addAttribute("photo", photo);
return "/photo";
}
```
У нас снова Spring endpoint, который показывает фотографию пользователю. Есть ли проблема в этом фрагменте кода?
Да! Мы забыли проверить права доступа, разрешено ли текущему пользователю просматривать фотографию. Возникает IDOR — Insecure Direct Object Reference.
Вот так выглядело бы исправление этого бага:
```
@GetMapping("/photo")
public String photo(@RequestParam("id") long id, Model model) {
Photo photo = photoRepository.findOne(id);
// …
User currentUser = getCurrentUser = getCurrentUser();
if (!canAccess(currentUser, author)) {
return "/error/302";
}
model.addAttribute("user", author);
model.addAttribute("photo", photo);
return "/photo";
}
```
Вопрос: можем ли научить статический анализатор искать такие уязвимости? Недостаточный контроль доступа, кажется, тесно связан с бизнес-логикой приложения, и не получится написать универсальный детектор для подобного рода проблем. У нас нет единого способа объяснить анализатору, что такое контроль доступа и как именно он реализован в нашей системе.
Но мы можем проверить соблюдение в нашем коде определенных, оговоренных заранее правил авторизации и контроля доступа, когда мы уже знаем как они реализованы в этом конкретном приложении.
В данном случае, можно сказать «анализатор, найди, пожалуйста, все Spring endpoint-ы и проверь, что каждый из них вызывает метод canAccess(). А если не вызывает, то это и есть потенциальная уязвимость».
Давайте попробуем такое правило написать. Правило для Find Security Bugs — это программа на Java.
```
import edu.umd.cs.findbugs.Detector;
public class IdorDetector implements Detector {
@Override
public void vistClassContext(ClassContext classContext) {
}
@Override
public void report() {
}
}
```
В Find Security Bugs все детекторы должны реализовывать интерфейс Detector. Библиотека содержит некоторое количество базовых детекторов, которые можно переиспользовать, но мы попробуем написать правило с нуля.
Итак, нам нужно реализовать два метода: visitClassContext(), который будет осуществлять анализ, и report(), сообщающий о проблеме, если она найдена.
Как найти баг из примера? Как сказано выше, найдём все Spring endpoint-ы и проверим, что каждый из них вызывает метод, реализующий контроль доступа:
```
public void visitClassContext(ClassContext classContext) {
List endpoints = findEndpoints(classContext);
for (Method m : endpoint) {
checkCanAccessCalled(classContext, m);
}
```
Как найти все Spring endpoint-ы? А как это делает сам Spring? Найдем все методы, отмеченные соответствующими аннотациями.
```
REQUEST_MAPPING_ANNOTATION_TYPES = Arrays.asList(
"Lorg/springframework/web/bind/annotation/GetMapping;",
"Lorg/springframework/web/bind/annotation/PostMapping;",
// …
private List findEndpoints(JavaClass javaClass) {
// …
for (Method m : javaClass.getMethods()) {
for (AnnotationEntry ae : m.getAnnotationEntries())) {
if (REQUEST\_MAPPING\_ANNOTATION\_TYPES
.contains(ae.getAnnotationType())) {
endpoints.add(m);
}
}
}
// …
```
Перечисляем все аннотации, которые используют Spring (их на самом деле больше, я опустила часть для краткости). Получаем от анализатора абстрактное синтаксическое дерево, в нём выбираем все методы всех классов и проверяем, есть ли в этих методах нужные аннотации. Если есть, добавляем в список для проверки.
Остаётся проверить каждый метод. Как мы это делаем? Вспоминаем о control flow graph, то есть получаем описание порядка выполнения инструкций в нашем коде.
```
private void checkCanAccessCalled(ClassContext classContext, Method m) {
// …
CFG cfg = classContext.getCFG(m);
for (Iterator i = cfg.locationIterator(); i.hasNext(); ) {
Instruction inst = i.next().getHandle().getInstruction();
if (inst instanceof INVOKESPECIAL) {
if (CAN\_ACCESS\_METHOD\_NAME.equals(invoke.getMethodName(cpg)) &&
className.equals(invoke.getClassName(cpg» {
found = true;
}
}
}
// ...
```
Получаем CFG для каждого endpoint-а и проверяем в нём каждую инструкцию. Для всех вызов методов, проверяем не совпадает ли название с искомым.
```
// ...
if (!found) {
bugReporter.reportBug(
new BugInstance(this, "IDOR", Priorities.NORMAL_PRIORITY)
.addClass(javaClass)
.addMethod(javaClass, method));
}
// ...
```
Для всех endpoint, в которых его не нашли, рапортуем возможную уязвимость.
Find Security Bugs предоставляет возможность управлять приоритетами багов в отчете, делить баги на категории, указывать для каждой категории описание в свободной форме.
Всё, детектор готов. Если запустим его, то отчет действительно будет содержать уязвимый метод.
Но идеален ли наш детектор?
Кроме реальных уязвимостей, он, вероятно, будет генерировать ещё какое-то количество ложных срабатываний.
Рассмотрим примеры конструкций, которые наш детектор ошибочно примет за уязвимости:
Наследование контроллеров:
```
public abstract class BaseController {
protected boolean canAccess() {
return false;
}
}
public class Controller extends BaseController {
@GetMapping("foo")
public String foo() {
//…
canAccess()
//...
}
```
Вложенные вызовы:
```
public class Controller {
private boolean canAccess() {
//…
}
private boolean canAccessEx() {
canAccess()
//…
}
@GetMapping("foo")
public String foo() {
//…
canAccessEx()
//…
}
}
```
Ветвление:
```
public class Controller {
private boolean canAccess() {
//…
}
private boolean canAccessEx() {
if (x) {
canAccess()
} else {
//…
}
//…
}
@GetMapping("foo")
public String foo() {
//…
canAccessEx()
//…
}
}
```
Предлагаю тебе, хабраюзер, в качестве упражнения самостоятельно исправить код детектора так, чтобы учесть приведенные выше примеры :).
Выводы
------
Не отменяя необходимости динамического тестирования безопасности, статический анализ позволяет быстрее и дешевле, чем динамические сканеры, находить типовые уязвимости в коде.
К сожалению, в реальном мире результаты работы сканера “из коробки” не всегда имеют ожидаемое качество, что приводит к необходимости добавления новых, специфичных для приложения, правил анализа.
Опенсорсный Find Security Bugs предоставляет и набор стандартных правил, и фреймворк для разработки собственных, что делает статическое тестирование безопасности доступным для всех проектов на Java.
Немного полезных ссылок напоследок:
* [Страница OWASP о статическом анализе](https://www.owasp.org/index.php/Static_Code_Analysis)
* [Find Security Bugs](https://find-sec-bugs.github.io)
* [Руководство Find Security Bugs по написанию своего детектора](https://github.com/find-sec-bugs/find-sec-bugs/wiki/Writing-a-detector)
* [О taint analysis в FindBugs](https://www.ysofters.com/2015/08/31/taint-analysis-added-to-findbugs/)
* [Common Weakness Enumeration](https://cwe.mitre.org)
* [OWASP Application Security Verification Standard Project](https://www.owasp.org/index.php/Category:OWASP_Application_Security_Verification_Standard_Project) | https://habr.com/ru/post/486722/ | null | ru | null |
# Продакшн-реди eBPF, или как мы исправили BSD socket API
Разрабатывая новые продукты, мы зачастую выводим нашу операционную систему — Linux — за рамки общепринятых возможностей. Распространенной темой было использование [eBPF](https://ebpf.io/what-is-ebpf/) для создания технологии, которая в противном случае потребовала бы модификации ядра. Например, мы создали систему [защиты от DDoS](https://blog.cloudflare.com/l4drop-xdp-ebpf-based-ddos-mitigations/) и [балансировщик нагрузки](https://blog.cloudflare.com/unimog-cloudflares-edge-load-balancer/) и используем ее для [мониторинга нашего серверного парка](https://blog.cloudflare.com/introducing-ebpf_exporter/).
Это программное обеспечение обычно состоит из маленькой программы eBPF, написанной на языке C и выполняемой в контексте ядра, и более крупного компонента пространства пользователя, который загружает eBPF в ядро и управляет его жизненным циклом. Выяснилось, что соотношение кода eBPF и кода пространства пользователя различается на порядок и более. Наша цель — пролить свет на проблемы, с которыми сталкивается разработчик при работе с eBPF, и предложить наши решения для создания надежных, продакшн-реди приложений, содержащих eBPF.
С этой целью мы предоставляем продакшн-инструменты с открытым исходным кодом, которые были созданы для [хука sk\_lookup](https://www.kernel.org/doc/html/latest/bpf/prog_sk_lookup.html), внесенного нами в ядро Linux, под названием **tubular**. Он существует потому, что [мы переросли BSD sockets API](https://blog.cloudflare.com/its-crowded-in-here/). Чтобы поставлять некоторые продукты, нам нужны функции, которые просто невозможно реализовать с помощью стандартного API.
* Наши сервисы доступны на миллионах IP-адресов.
* Несколько сервисов, использующих один и тот же порт на разных адресах, должны сосуществовать, например, резольвер [1.1.1.1](https://1.1.1.1/?_gl=1*j983b8*_ga*MTM3ODU5NTU4My4xNjQ5NDc4NzAx*_gid*MzcyMjE0MzEwLjE2NDk0Nzg3MDE.) и наш авторитетный DNS.
* Наш продукт Spectrum [должен прослушивать все 2^16 портов](https://blog.cloudflare.com/how-we-built-spectrum/).
Исходный код tubular находится по адресу <https://github.com/cloudflare/tubular>, и он позволяет делать все вышеперечисленные вещи. Возможно, самой интересной особенностью является то, что вы можете менять адреса служб на лету — посмотрите видео [на странице оригинала](https://blog.cloudflare.com/tubular-fixing-the-socket-api-with-ebpf/).
**Принцип работы tubular**
tubular располагается в критической точке стека Cloudflare, поскольку ему приходится проверять каждое соединение, прерванное сервером, и решать, какое приложение должно его получить.
В противном случае соединения будут обрываться или перенаправляться сотни раз в секунду. Поэтому он должен быть невероятно надежным во время повседневной работы. Мы поставили перед tubular следующие цели:
* **Релизы должны быть автоматизированными, не требующими контроля, и происходить в режиме онлайн.** tubular работает на тысячах машин, поэтому мы не можем нянчиться с этим процессом или выводить серверы из продакшна.
* **Релизы должны быть безопасными.** При сбое в процессе необходимо, чтобы была запущена предыдущая версия tubular, иначе мы можем сбросить соединения.
* **Уменьшить влияние сбоев (в пользовательском пространстве).** Когда появляется неизбежная ошибка, нам хочется минимизировать радиус поражения.
В прошлом мы создали пробный вариант концепции управления для `sk_lookup` под названием [inet-tool](https://github.com/majek/inet-tool), который доказал, что можно обойтись без постоянного сервиса, управляющего eBPF. Аналогично, tubular имеет tubectl: кратковременные вызовы производят необходимые изменения, а сохраняющееся состояние обрабатывается ядром в виде [карт eBPF](https://www.kernel.org/doc/html/latest/bpf/maps.html). Следуя этой схеме, мы получили устойчивость к сбоям по умолчанию, но при этом нам пришлось решать задачу маппирования пользовательского интерфейса, который мы хотели, с инструментами, доступными в экосистеме eBPF.
**Пользовательский интерфейс tubular**
tubular состоит из программы BPF, которая подключается к хуку `sk_lookup` в ядре, и пользовательского кода Go, который управляет программой BPF. Команда tubectl оборачивает обе программы таким образом, чтобы их было легко распределять.
tubectl управляет двумя видами объектов: биндингами и сокетами. Биндинг кодирует правило, по которому осуществляется матчинг входящего пакета. Сокет — это указатель на TCP или UDP сокет, который может принимать новые соединения или пакеты.
Биндинги и сокеты "склеиваются" вместе с помощью произвольных строк, называемых метками. В принципе, биндинг присваивает метку некоторому трафику. Затем метка используется для поиска нужного сокета.
Чтобы создать биндинг, который направляет трафик порта 80 (он же HTTP), предназначенный для 127.0.0.1, на метку "foo", мы используем tubectl bind:
```
$ sudo tubectl bind "foo" tcp 127.0.0.1 80
```
Благодаря возможностям `sk_lookup` мы можем использовать гораздо более мощные конструкции, чем BSD API. Например, мы можем перенаправлять соединения со всеми IP-адресами в 127.0.0.0/24 на один сокет:
```
$ sudo tubectl bind "bar" tcp 127.0.0.0/24 80
```
Побочным эффектом такой способности является вероятность создания биндингов, которые "перекрывают" друг друга:
```
1: tcp 127.0.0.1/32 80 -> "foo"
2: tcp 127.0.0.0/24 80 -> "bar"
```
Первый биндинг говорит, что HTTP-трафик на localhost должен идти на "foo", а второй утверждает, что HTTP-трафик в подсети localhost должен идти на "bar". Это создает противоречие, какой же из вариантов биндинга выбрать? tubular решает эту проблему, определяя правила приоритета для биндингов:
1. Префикс с более длинной маской является более специфичным, например, 127.0.0.1/32 превосходит 127.0.0.0/24.
2. Порт более конкретен, чем подстановочный символ порта, например, порт 80 превосходит значение "все порты" (0).
Применяя это к нашему примеру, HTTP-трафик на все IP-адреса в 127.0.0.0/24 будет направлен на bar, за исключением 127.0.0.1, который идет на foo.
**Получение доступа к сокетам**
`sk_lookup` нуждается в указателе на TCP или UDP сокет, чтобы перенаправить на него трафик. Однако сокет обычно доступен только процессу, который создал его с помощью системного вызова socket. Например, HTTP-сервер создает прослушивающий TCP-сокет, привязанный к порту 80. Как мы можем получить доступ к прослушивающему сокету?
Достаточно известное решение — заставить процессы сотрудничать, передавая дескрипторы файлов сокетов через сообщения [SCM\_RIGHTS](https://blog.cloudflare.com/know-your-scm_rights/) демону tubular. Затем этот демон может предпринять необходимые шаги для подключения сокета с помощью `sk_lookup`. Этот подход имеет несколько недостатков:
1. Требуется модификация процессов для отправки SCM\_RIGHTS.
2. Требуется демон tubular, который может выйти из строя.
Есть еще один способ получить доступ к сокетам с помощью `systemd`, при условии, что используется [активация сокета](https://www.freedesktop.org/software/systemd/man/systemd.socket.html). Он работает путем создания дополнительного сервисного юнита с правильной настройкой [Sockets](https://www.freedesktop.org/software/systemd/man/systemd.service.html#Sockets=). Другими словами: мы можем использовать действие `systemd oneshot`, выполняемое при создании службы systemd socket, регистрируя сокет в tubular. Например:
```
[Unit]
Requisite=foo.socket
[Service]
Type=oneshot
Sockets=foo.socket
ExecStart=tubectl register "foo"
```
Поскольку мы можем положиться на `systemd` в выполнении tubectl в нужное время, нам не нужен никакой демон. Однако реальность такова, что многие популярные программы не используют активацию сокетов `systemd`. Работа с сокетами `systemd` сложна и не располагает к экспериментам. Что в итоге приводит нас к финальному приему: [pidfd\_getfd](https://www.man7.org/linux/man-pages/man2/pidfd_getfd.2.html):
Системный вызов `pidfd_getfd()` аллоцирует новый файловый дескриптор в рамках процесса вызова. Этот новый файловый дескриптор является дубликатом существующего дескриптора, `targetfd`, в процессе, на который ссылается PID файлового дескриптора `pidfd`.
Мы можем использовать его для итерации всех файловых дескрипторов чужого процесса и выбора интересующего нас сокета. Возвращаясь к нашему примеру, мы можем использовать следующую команду, чтобы найти TCP-сокет, привязанный к 127.0.0.1 порту 8080 в процессе httpd, и зарегистрировать его под меткой "foo":
```
$ sudo tubectl register-pid "foo" $(pidof httpd) tcp 127.0.0.1 8080
```
Если возникнет необходимость, это легко подключить с помощью [ExecStartPost](https://www.freedesktop.org/software/systemd/man/systemd.service.html#ExecStartPre=) от systemd.
```
[Service]
Type=forking # or notify
ExecStart=/path/to/some/command
ExecStartPost=tubectl register-pid $MAINPID foo tcp 127.0.0.1 8080
```
**Хранение состояния в картах eBPF**
Как упоминалось ранее, tubular полагается на ядро для хранения состояния, используя [структуры данных BPF ключ/значение, также известные как карты](https://prototype-kernel.readthedocs.io/en/latest/bpf/ebpf_maps.html). Используя [системный вызов BPF\_OBJ\_PIN](https://www.kernel.org/doc/html/latest/userspace-api/ebpf/syscall.html), мы можем сохранять их в /sys/fs/bpf:
```
/sys/fs/bpf/4026532024_dispatcher
├── bindings
├── destination_metrics
├── destinations
├── sockets
└── ...
```
Характер структуры состояния отличается от того, как интерфейс командной строки представляет его пользователям. Ярлыки типа "foo" удобны для людей, но они имеют переменную длину. Работа с данными переменной длины в BPF громоздка и медленна, поэтому программа BPF вообще не обращается к меткам. Вместо этого код пространства пользователя аллоцирует числовые идентификаторы (ID), которые затем используются в BPF. Каждый идентификатор представляет собой кортеж (label, domain, protocol), который для внутреннего пользования называется destination.
Например, добавление биндинга для "foo" tcp 127.0.0.1 ... аллоцирует идентификатор для ("foo", AF\_INET, TCP). Включение (domain) домена и (protocol) протокола в пункт назначения (destination) позволяет использовать более простые структуры данных в BPF. Каждая аллокация также отслеживает, сколько биндингов указывают на пункт назначения, чтобы мы могли повторно использовать неиспользуемые идентификаторы. Эти данные сохраняются в хэш-таблице пунктов назначения, которая имеет ключ (`Label`, `Domain`, `Protocol`) и содержит (`ID`, `Count`). Метрики для каждого пункта назначения отслеживаются в `destination_metrics` в виде счетчиков для каждого процессора.
`bindings` — это [древовидная структура матчинга самого длинного префикса (LPM)](https://en.wikipedia.org/wiki/Trie), которая хранит маппинг от (protocol, port, prefix) до (ID, prefix length). ID используется как ключ к карте сокетов, которая содержит указатели на структуры сокетов ядра. Идентификаторы аллоцированы таким образом, что они могут использоваться в качестве индекса массива, это позволяет использовать более простую BPF sockmap (массив) вместо хэш-таблицы сокетов. Длина префикса дублируется в значении, чтобы обойти недостатки API BPF.
**Кодирование приоритета биндингов**
Как уже говорилось, биндинги имеют приоритет, ассоциированный с ними. Повторим предыдущий пример:
```
1: tcp 127.0.0.1/32 80 -> "foo"
2: tcp 127.0.0.0/24 80 -> "bar"
```
Для первого биндинга необходимо сделать матчинг раньше, чем для второго. Необходимо как-то закодировать это в BPF. Одна из идей — сгенерировать код, выполняющий биндинги в порядке убывания их специфичности; этот прием мы с успехом использовали в [l4drop](https://blog.cloudflare.com/l4drop-xdp-ebpf-based-ddos-mitigations/):
```
1: if (mask(ip, 32) == 127.0.0.1) return "foo"
2: if (mask(ip, 24) == 127.0.0.0) return "bar"
...
```
У этого есть обратная сторона: программа становится длиннее, чем больше будет добавлено биндингов, тем медленнее она будет выполняться. Кроме того, такие длинные программы трудно анализировать и отлаживать. Взамен мы используем специализированную карту матчинга самого длинного префикса (LPM) BPF для выполнения тяжелой работы. Это позволяет просмотреть содержимое программы из пространства пользователя и выяснить, какие биндинги активны, что было бы очень сложно, если компилировать их (биндинги) в BPF. Карта LPM использует древовидную структуру в качестве основы, поэтому [сложность поиска пропорциональна длине ключа](https://en.wikipedia.org/wiki/Trie#Searching), а не линейна, как в "наивном" решении.
Однако использование карты требует определенных ухищрений для кодирования приоритета биндингов в ключ, который потом можно отыскать. Вот упрощенная версия такого кодирования, которая игнорирует IPv6 и использует метки вместо идентификаторов. Чтобы вставить биндинг tcp 127.0.0.0/24 80 в префиксное дерево (trie), мы сначала преобразуем IP-адрес в число.
```
127.0.0.0 = 0x7f 00 00 00
```
Поскольку нас интересуют только первые 24 бита адреса, можно записать весь префикс в виде
```
127.0.0.0/24 = 0x7f 00 00 ??
```
где "?" означает, что значение не определено. Выберем число 0x01 для обозначения TCP и добавим его и номер порта (80 в десятичной системе равно 0x50 в шестнадцатеричной) для создания полного ключа:
```
tcp 127.0.0.0/24 80 = 0x01 50 7f 00 00 ??
```
Преобразование tcp 127.0.0.1/32 80 происходит точно так же. После того как преобразованные значения вставлены в trie, LPM trie концептуально содержит следующие ключи и значения.
```
LPM trie:
0x01 50 7f 00 00 ?? = "bar"
0x01 50 7f 00 00 01 = "foo"
```
Чтобы найти биндинг для TCP-пакета, предназначенного для 127.0.0.1:80, мы снова кодируем ключ и осуществляем поиск.
```
input: 0x01 50 7f 00 00 01 TCP packet to 127.0.0.1:80
---------------------------
LPM trie:
0x01 50 7f 00 00 ?? = "bar"
y y y y y
0x01 50 7f 00 00 01 = "foo"
y y y y y y
---------------------------
result: "foo"
y = byte matches
```
Trie возвращает "foo", поскольку ее ключ имеет самый длинный общий префикс с входными данными. Обратите внимание, что мы прекращаем сравнивать ключи, как только достигаем неопределенных байтов "?", но концептуально "bar" все еще является валидным результатом. Различие становится очевидным во время поиска биндинга для TCP-пакета на 127.0.0.255:80.
```
input: 0x01 50 7f 00 00 ff TCP packet to 127.0.0.255:80
---------------------------
LPM trie:
0x01 50 7f 00 00 ?? = "bar"
y y y y y
0x01 50 7f 00 00 01 = "foo"
y y y y y n
---------------------------
result: "bar"
n = byte doesn't match
```
В этом случае "foo" отбрасывается, так как последний байт не соответствует входным данным. Однако "bar" возвращается, так как его последний байт не определен и следовательно считается валидным матчингом.
**Возможность наблюдения с минимальными привилегиями**
В Linux есть мощный инструмент ss (часть iproute2), позволяющий исследовать состояние сокета:
```
$ ss -tl src 127.0.0.1
State Recv-Q Send-Q Local Address:Port Peer Address:Port
LISTEN 0 128 127.0.0.1:ipp 0.0.0.0:*
```
С появлением tubular этот вывод уже перестал быть достаточно точным. Биндинги tubectl компенсируют данный недостаток:
```
$ sudo tubectl bindings tcp 127.0.0.1
Bindings:
protocol prefix port label
tcp 127.0.0.1/32 80 foo
```
Запуск данной команды требует привилегий суперпользователя, хотя теоретически ее может выполнить любой. Несмотря на то, что такое приемлемо для случайного инспектирования оператором-человеком, это является препятствием для наблюдаемости с помощью пулл-ориентированных систем мониторинга, таких как Prometheus. Стандартный подход заключается в предоставлении метрик через HTTP-сервер, который должен работать с повышенными привилегиями и каким-то образом быть доступным для сервера Prometheus. Вместо этого BPF предоставляет нам инструменты для обеспечения доступа к состоянию tubular только для чтения с минимальными привилегиями.
Ключевым моментом является тщательная установка владельца файла и режим для состояния в /sys/fs/bpf. Создание и открытие файлов в /sys/fs/bpf использует [BPF\_OBJ\_PIN и BPF\_OBJ\_GET](https://www.kernel.org/doc/html/latest/userspace-api/ebpf/syscall.html#bpf-subcommand-reference). Вызов `BPF_OBJ_GET` с `BPF_F_RDONLY` примерно эквивалентен открытию (O\_RDONLY) и позволяет получить доступ к состоянию только для чтения, при условии правильных разрешений на файл. tubular дает полный доступ владельцу, но ограничивает его для группы — только для чтения:
```
$ sudo ls -l /sys/fs/bpf/4026532024_dispatcher | head -n 3
total 0
-rw-r----- 1 root root 0 Feb 2 13:19 bindings
-rw-r----- 1 root root 0 Feb 2 13:19 destination_metrics
```
Легко выбрать, какой пользователь и группа должны распоряжаться состоянием при загрузке tubular:
```
$ sudo -u root -g tubular tubectl load
created dispatcher in /sys/fs/bpf/4026532024_dispatcher
loaded dispatcher into /proc/self/ns/net
$ sudo ls -l /sys/fs/bpf/4026532024_dispatcher | head -n 3
total 0
-rw-r----- 1 root tubular 0 Feb 2 13:42 bindings
-rw-r----- 1 root tubular 0 Feb 2 13:42 destination_metrics
```
Есть еще одно препятствие, [systemd монтирует /sys/fs/bpf](https://github.com/systemd/systemd/blob/b049b48c4b6e60c3cbec9d2884f90fd4e7013219/src/shared/mount-setup.c#L111-L112) таким образом, что он становится недоступным для всех, кроме root. Добавление исполняемого бита в каталог устраняет эту проблему.
```
$ sudo chmod -v o+x /sys/fs/bpf
mode of '/sys/fs/bpf' changed from 0700 (rwx------) to 0701 (rwx-----x)
```
Наконец, мы можем экспортировать метрики без привилегий:
```
$ sudo -u nobody -g tubular tubectl metrics 127.0.0.1 8080
Listening on 127.0.0.1:8080
^C
```
К сожалению, есть оговорка: для действительно непривилегированного доступа требуется включение непривилегированного BPF. Во многих дистрибутивах принято отключать его с помощью `sysctl unprivileged_bpf_disabled`, и в этом случае для скрейпинга метрик требуется `CAP_BPF`.
**Безопасные релизы**
tubular распространяется как единый двоичный файл, но на самом деле состоит из двух частей кода с совершенно разным лайфтаймом. Программа BPF загружается в ядро один раз и затем может быть активна в течение недель или месяцев, пока ее явно не заменят. Фактически, упоминание о программе (и ссылка, см. ниже) сохраняется в /sys/fs/bpf:
```
/sys/fs/bpf/4026532024_dispatcher
├── link
├── program
└── ...
```
Код пространства пользователя выполняется в течение нескольких секунд за раз и заменяется всякий раз, когда бинарный файл на диске изменяется. Это означает, что пользовательское пространство должно быть способно как-то справиться со "старой" программой BPF в ядре. Самый простой способ добиться этого — сравнить то, что загружено в ядро, с BPF, поставляемым в составе tubectl. Если они не совпадают, мы возвращаем ошибку:
```
$ sudo tubectl bind foo tcp 127.0.0.1 80
Error: bind: can't open dispatcher: loaded program #158 has differing tag: "938c70b5a8956ff2" doesn't match "e007bfbbf37171f0"
```
tag — это усеченный хэш инструкций, составляющих программу BPF, который ядро делает доступным для каждой загруженной программы:
```
$ sudo bpftool prog list id 158
158: sk_lookup name dispatcher tag 938c70b5a8956ff2
...
```
Сравнивая этот тег, tubular утверждает, что имеет дело с поддерживаемой версией программы BPF. Конечно, простого возврата ошибки недостаточно. Должен быть способ обновить программу ядра, чтобы вновь стало безопасно вносить изменения.
Именно здесь в игру вступает постоянная ссылка в /sys/fs/bpf. bpf\_links используются для прикрепления программ к различным BPF-хукам. "Включение" программы BPF — это двухэтапный процесс: сначала загрузите программу BPF, затем прикрепите ее к хуку с помощью `bpf_link`. После этого программа начнет работать при следующем выполнении хука. Обновляя ссылку, мы можем изменять программу на лету, атомарным образом.
```
$ sudo tubectl upgrade
Upgraded dispatcher to 2022.1.0-dev, program ID #159
$ sudo bpftool prog list id 159
159: sk_lookup name dispatcher tag e007bfbbf37171f0
…
$ sudo tubectl bind foo tcp 127.0.0.1 80
bound foo#tcp:[127.0.0.1/32]:80
```
За кадром процедура обновления немного сложнее, поскольку помимо ссылки необходимо обновить упоминание о прикрепленной программе. Мы закрепляем новую программу в /sys/fs/bpf:
```
/sys/fs/bpf/4026532024_dispatcher
├── link
├── program
├── program-upgrade
└── ...
```
После обновления ссылки мы [атомарно переименовываем](https://www.man7.org/linux/man-pages/man2/rename.2.html) программу-обновление, чтобы заменить программу. В будущем мы сможем [использовать RENAME\_EXCHANGE](https://lkml.kernel.org/netdev/20211028094724.59043-5-lmb@cloudflare.com/t/), чтобы сделать обновление еще более безопасным.
**Предотвращение повреждения состояния**
До сих пор мы полностью игнорировали тот факт, что несколько вызовов tubectl могут одновременно модифицировать состояние в /sys/fs/bpf. Очень сложно рассуждать о том, что произойдет в этом случае, так что лучше всего предотвратить подобное. Общим решением для этого являются [рекомендательные блокировки файлов](https://gavv.github.io/articles/file-locks/#differing-features). К сожалению, похоже, что карты BPF не поддерживают блокировку.
```
$ sudo flock /sys/fs/bpf/4026532024_dispatcher/bindings echo works!
flock: cannot open lock file /sys/fs/bpf/4026532024_dispatcher/bindings: Input/output error
```
Это заставило нас немного поломать голову. К счастью, вместо отдельных карт можно собрать общий каталог:
```
$ sudo flock --exclusive /sys/fs/bpf/foo echo works!
works!
```
Каждый вызов tubectl также инициирует [flock()](https://www.man7.org/linux/man-pages//man2/flock.2.html), гарантируя тем самым, что изменения вносит только один процесс.
**Заключение**
Сегодня tubular уже в продакшн у Cloudflare, упростив развертывание Spectrum, а также нашего авторитетного DNS. Он позволил нам отказаться от ограничений API сокетов BSD. Однако самой важной его особенностью является то, что [адреса, по которым доступна служба, можно менять на лету](https://research.cloudflare.com/publications/Fayed2021/). Фактически, мы создали инструментарий, автоматизирующий этот процесс в нашей глобальной сети. Нужно прослушать еще миллион IP-адресов на тысячах машин? Нет проблем, достаточно лишь выполнить HTTP POST.
---
Приглашаем всех желающих на открытый урок «Виртуализация: KVM», на котором рассмотрим:
* Основные виды технологий виртуализации;
* Основные обенности виртуализации ядра линукс;
* KVMQEMUУправление гипервизором при помощи libvirt;
* Основные моменты создания снапшотов (snapshots);
* Аспекты работы с сетью.
Регистрация доступна [**по ссылке.**](https://otus.pw/Nt0s/) | https://habr.com/ru/post/660561/ | null | ru | null |
# TAG_ADD Plugin
**Привет, %username%**
Как-то раз мне пришлось писать форму для добавления постов в блог. Помимо стандартных полей (название, дата, текст и.т.д.) необходимо было привинтить юзабельную форму добавления тегов.
Т.к. я кодю в jQuery, то и выбор был однозначным.
Вот необходимые задачи, которые я поставил перед собой:
1. Легко в настройке
2. Все теги храняться в одном файле (в кэше)
3. Минимальная нагрузка на сервер и клиента
4. Список тегов — подсказок открывается только для выбранного запроса на определенный тег.
Вдаваться в подробности плагина я не буду.
Подключение – стандартное:
--------------------------
> `1. <head>
> 2. <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
> 3. <title>TAG\_ADD. jQuery Plugintitle>
> 4. <script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.3/jquery.min.js">script>
> 5. **"text/javascript"</font> src=<font color="#A31515">"tag\_add\_js/tag\_add.js"</font>><font color="#0000ff"></</font><font color="#800000">script</font><font color="#0000ff">></font></strong></li>
> <li><font color="#0000ff"><</font><font color="#800000">link</font> <font color="#ff0000">rel</font><font color="#0000ff">="stylesheet"</font> <font color="#ff0000">type</font><font color="#0000ff">="text/css"</font> <font color="#ff0000">href</font><font color="#0000ff">="tag\_add\_css/tag\_add.css"></font></li>
> <li><font color="#0000ff"></</font><font color="#800000">head</font><font color="#0000ff">></font></li>
> </ol></code><font color="gray">\* This source code was highlighted with <a href="http://virtser.net/blog/post/source-code-highlighter.aspx"><font color="gray">Source Code Highlighter</font></a>.</font></blockquote><br/>
> <h2>Рисуем форму и вызываем плагин</h2><br/>
> <br/>
> <blockquote><code><a href="http://virtser.net/blog/post/source-code-highlighter.aspx"></a><font color="black"><input type=<font color="#A31515">"text"</font> name=<font color="#A31515">"tag\_input"</font> id=<font color="#A31515">"tag\_input\_id"</font> ><br/>
> <br><br/>
> <em>(введите теги через запятую)</em></p><br/>
> <br/>
> <script><br/>
> jQuery(<font color="#0000ff">document</font>).ready(<font color="#0000ff">function</font>(){<br/>
> $(<font color="#A31515">"#tag\_input\_id"</font>).tag\_add();<br/>
> })<br/>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.**`
Можем его настроить
-------------------
> 1. `</code></li>
> <li><code> jQuery(<font color="#0000ff">document</font>).ready(<font color="#0000ff">function</font>(){</code></li>
> <li><code> $(<font color="#A31515">"#tag\_input\_id2"</font>).tag\_add({</code></li>
> <li><code> </code></li>
> <li><code> <strong>maxitem</strong>:0, <font color="#008000">// макс. кол-во объектов</font></code></li>
> <li><code> <strong>minlength</strong>:2, <font color="#008000">// мин. кол-во символов для запуска</font></code></li>
> <li><code> <strong>maxlength</strong>:10, <font color="#008000">// макс. кол-во символов для запуска</font></code></li>
> <li><code> <strong>loadinfo</strong>: <font color="#A31515">'loadtag.php'</font>, <font color="#008000">//файл содержащий все теги</font></code></li>
> <li><code> </code></li>
> <li><code> });</code></li>
> <li><code> })</code></li>
> <li><code> })</code></li>
> <li><code>`
>
`\* This source code was highlighted with Source Code Highlighter.`
Вот и весь плагин, демо можно посмотреть [тут](http://www.matte26.com/dev/tag_add/index.php)
**Пользуйтесь))** | https://habr.com/ru/post/66125/ | null | ru | null |
# Cron в Linux: история, использование и устройство
Классик писал, что счастливые часов не наблюдают. В те дикие времена ещё не было ни программистов, ни Unix, но в наши дни программисты знают твёрдо: вместо них за временем проследит cron.
Утилиты командной строки для меня одновременно слабость и рутина. sed, awk, wc, cut и другие старые программы запускаются скриптами на наших серверах ежедневно. Многие из них оформлены в виде задач для cron, планировщика родом из 70-х.
Я долго пользовался cron поверхностно, не вникая в детали, но однажды, столкнувшись с ошибкой при запуске скрипта, решил разобраться основательно. Так появилась эта статья, при написании которой я ознакомился с POSIX crontab, основными вариантами cron в популярных дистрибутивах Linux и устройством некоторых из них.
Используете Linux и запускаете задачи в cron? Вам интересна архитектура системных приложений в Unix? Тогда нам по пути!
Содержание
==========
* [Происхождение видов](#proishozhdenie-vidov)
* [POSIX crontab](#posix-crontab)
* [Хит продаж — Vixie cron 3.0pl1](#hit-prodazh--vixie-cron-30pl1)
* [cron в Debian и Ubuntu](#cron-v-debian-i-ubuntu)
* [cronie в Red Hat, Fedora и CentOS](#cronie-v-redhat-fedora-i-centos)
* [cronie в SLES и openSUSE](#cronie-v-sles-i-opensuse)
* [Устройство Vixie cron](#ustroystvo-vixie-cron)
* [Послесловие](#posleslovie)
Происхождение видов
===================
Периодическое выполнение пользовательских или системных программ — очевидная необходимость во всех операционных системах. Поэтому потребность в сервисах, позволяющих централизованно планировать и выполнять задачи, программисты осознали очень давно.
Unix-подобные операционные системы ведут свою родословную от Version 7 Unix, разработанной в 70-х годах прошлого века в Bell Labs в том числе и знаменитым Кеном Томпсоном (англ. Ken Thompson). Вместе c Version 7 Unix поставлялся и cron, сервис для регулярного выполнения задач суперпользователя.
Типичный современный cron — несложная программа, но алгоритм работы оригинального варианта был ещё проще: сервис просыпался раз в минуту, читал табличку с задачами из единственного файл (/etc/lib/crontab) и выполнял для суперпользователя те задачи, которые следовало выполнить в текущую минуту.
Впоследствии усовершенствованные варианты простого и полезного сервиса поставлялись со всеми Unix-подобными операционными системами.
Обобщённые описания формата crontab и базовых принципов работы утилиты в 1992 году были включены в главный стандарт Unix-подобных операционных систем — POSIX — и таким образом cron из стандарта де-факто стал стандартом де-юре.
В 1987 году Пол Викси (англ. Paul Vixie), опросив пользователей Unix на предмет пожеланий к cron, выпустил ещё одну версию демона, исправляющую некоторые проблемы традиционных cron и расширяющую синтаксис файлов-таблиц.
К третьей версии Vixie cron стал отвечать требованиям POSIX, к тому же у программы была либеральная лицензия, вернее не было вообще никакой лицензии, если не считать пожеланий в README: гарантий автор не даёт, имя автора удалять нельзя, а продавать программу можно только вместе с исходным кодом. Эти требования оказались совместимы с принципами набиравшего в те годы популярность свободного ПО, поэтому некоторые ключевые из появившихся в начале 90-х дистрибутивов Linux взяли Vixie cron в качестве системного и развивают его до сих пор.
В частности, Red Hat и SUSE развивают форк Vixie cron — cronie, а Debian и Ubuntu используют оригинальное издание Vixie cron со множеством патчей.
Давайте для начала познакомимся с описанной в POSIX пользовательской утилитой crontab, после чего разберём расширения синтаксиса, представленные в Vixie cron, и использование вариаций Vixie cron в популярных дистрибутивах Linux. И, наконец, вишенка на торте — разбор устройства демона cron.
POSIX crontab
=============
Если оригинальный cron всегда работал для суперпользователя, то современные планировщики чаще имеют дело с задачами обычных пользователей, что более безопасно и удобно.
Сron-ы поставляются комплектом из двух программ: постоянно работающего демона cron и доступной пользователям утилиты crontab. Последняя позволяет редактировать таблицы задач, специфичные для каждого пользователя в системе, демон же запускает задачи из пользовательских и системной таблиц.
В [стандарте POSIX](https://www.unix.com/man-page/POSIX/1posix/crontab/) никак не описывается поведение демона и формализована только пользовательская программа [crontab](https://pubs.opengroup.org/onlinepubs/9699919799/utilities/crontab.html). Существование механизмов запуска пользовательских задач, конечно, подразумевается, но не описано подробно.
Вызовом утилиты crontab можно сделать четыре вещи: отредактировать пользовательскую таблицу задач в редакторе, загрузить таблицу из файла, показать текущую таблицу задач и очистить таблицу задач. Примеры работы утилиты crontab:
```
crontab -e # редактировать таблицу задач
crontab -l # показать таблицу задач
crontab -r # удалить таблицу задач
crontab path/to/file.crontab # загрузить таблицу задач из файла
```
При вызове `crontab -e` будет использоваться редактор, указанный в стандартной переменной окружения `EDITOR`.
Сами задачи описаны в следующем формате:
```
# строки-комментарии игнорируются
#
# задача, выполняемая ежеминутно
* * * * * /path/to/exec -a -b -c
# задача, выполняемая на 10-й минуте каждого часа
10 * * * * /path/to/exec -a -b -c
# задача, выполняемая на 10-й минуте второго часа каждого дня и использующая перенаправление стандартного потока вывода
10 2 * * * /path/to/exec -a -b -c > /tmp/cron-job-output.log
```
Первые пять полей записей: минуты [1..60], часы [0..23], дни месяца [1..31], месяцы [1..12], дни недели [0..6], где 0 — воскресенье. Последнее, шестое, поле — строка, которая будет выполнена стандартным интерпретатором команд.
В первых пяти полях значения можно перечислять через запятую:
```
# задача, выполняемая в первую и десятую минуты каждого часа
1,10 * * * * /path/to/exec -a -b -c
```
Или через дефис:
```
# задача, выполняемая в каждую из первых десяти минут каждого часа
0-9 * * * * /path/to/exec -a -b -c
```
Доступ пользователей к планированию задач регулируется в POSIX файлам cron.allow и cron.deny в которых перечисляются, соответственно, пользователи с доступом к crontab и пользователи без доступа к программе. Расположение этих файлов стандарт никак не регламентирует.
Запускаемым программам, согласно стандарту, должны передаваться по меньшей мере четыре переменные окружения:
1. HOME — домашняя директория пользователя.
2. LOGNAME — логин пользователя.
3. PATH — путь, по которому можно найти стандартные утилиты системы.
4. SHELL — путь к использованному командному интерпретатору.
Примечательно, что POSIX ничего не говорит о том, откуда берутся значения для этих переменных.
Хит продаж — Vixie cron 3.0pl1
==============================
Общий предок популярных вариантов cron — Vixie cron 3.0pl1, представленный в рассылке comp.sources.unix в 1992 году. Основные возможности этой версии мы и рассмотрим подробнее.
Vixie cron поставляется в двух программах (cron и crontab). Как обычно, демон отвечает за чтение и запуск задач из системной таблицы задач и таблиц задач отдельных пользователей, а утилита crontab — за редактирование пользовательских таблиц.
### Таблица задач и файлы конфигурации
Таблица задач суперпользователя расположена в /etc/crontab. Синтаксис системной таблицы соответствует синтаксису Vixie cron с поправкой на то, что в ней шестой колонкой указывается имя пользователя, от лица которого запускается задача:
```
# Запускается ежеминутно от пользователя vlad
* * * * * vlad /path/to/exec
```
Таблицы задач обычных пользователей располагаются в /var/cron/tabs/username и используют общий синтаксис. При запуске утилиты crontab от имени пользователя редактируются именно эти файлы.
Управление списками пользователей, имеющих доступ к crontab, происходит в файлах /var/cron/allow и /var/cron/deny, куда достаточно внести имя пользователя отдельной строкой.
### Расширенный синтаксис
По сравнению с POSIX crontab решение Пола Викси содержит несколько очень полезных модификаций в синтаксисе таблиц задач утилиты.
Стал доступен новый синтаксис таблиц: например, можно указывать дни недели или месяцы поимённо (Mon, Tue и так далее):
```
# Запускается ежеминутно по понедельникам и вторникам в январе
* * * Jan Mon,Tue /path/to/exec
```
Можно указывать шаг, через который запускаются задачи:
```
# Запускается с шагом в две минуты
*/2 * * * Mon,Tue /path/to/exec
```
Шаги и интервалы можно смешивать:
```
# Запускается с шагом в две минуты в первых десять минут каждого часа
0-10/2 * * * * /path/to/exec
```
Поддерживаются интуитивные альтернативы обычному синтаксису (reboot, yearly, annually, monthly, weekly, daily, midnight, hourly):
```
# Запускается после перезагрузки системы
@reboot /exec/on/reboot
# Запускается раз в день
@daily /exec/daily
# Запускается раз в час
@hourly /exec/daily
```
### Среда выполнения задач
Vixie cron позволяет менять окружение запускаемых приложений.
Переменные окружения USER, LOGNAME и HOME не просто предоставляются демоном, а берутся из файла [passwd](https://en.wikipedia.org/wiki/Passwd). Переменная PATH получает значение "/usr/bin:/bin", а SHELL — "/bin/sh". Значения всех переменных, кроме LOGNAME, можно изменить в таблицах пользователей.
Некоторые переменные окружения (прежде всего SHELL и HOME) используются самим cron для запуска задачи. Вот как может выглядеть использование bash вместо стандартного sh для запуска пользовательских задач:
```
SHELL=/bin/bash
HOME=/tmp/
# exec будет запущен bash-ем в /tmp/
* * * * * /path/to/exec
```
В конечном итоге все определённые в таблице переменные окружения (используемые cron или необходимые процессу) будут переданы запущенной задаче.
Для редактирования файлов утилитой crontab используется редактор, указанный в переменной окружения VISUAL или EDITOR. Если в среде, где был запущен crontab, эти переменные не определены, то используется "/usr/ucb/vi" (ucb — это, вероятно, University of California, Berkeley).
cron в Debian и Ubuntu
======================
Разработчики Debian и производных дистрибутивов выпустили [сильно модифицированную версию](https://salsa.debian.org/debian/cron) версию Vixie cron 3.0pl1. Отличий в синтаксисе файлов-таблиц нет, для пользователей это тот же самый Vixie cron. Крупнейшие новые возможности: поддержка [syslog](https://en.wikipedia.org/wiki/Syslog), [SELinux](https://en.m.wikipedia.org/wiki/Security-Enhanced_Linux) и [PAM](https://en.wikipedia.org/wiki/Linux_PAM).
Из менее заметных, но осязаемых изменений — расположение конфигурационных файлов и таблиц задач.
Пользовательские таблицы в Debian располагаются в директории /var/spool/cron/crontabs, системная таблица всё там же — в /etc/crontab. Специфичные для пакетов Debian таблицы задач помещаются в /etc/cron.d, откуда демон cron их автоматически считывает. Управление доступом пользователей регулируется файлами /etc/cron.allow и /etc/cron.deny.
В качестве командной оболочки по умолчанию по-прежнему используется /bin/sh, в роли которого в Debian выступает небольшой POSIX-совместимый шелл [dash](http://man7.org/linux/man-pages/man1/dash.1.html), запущенный без чтения какой-либо конфигурации (в неинтерактивном режиме).
Сам cron в последних версиях Debian запускается через systemd, а конфигурацию запуска можно посмотреть в /lib/systemd/system/cron.service. Ничего особенного в конфигурации сервиса нет, любое более тонкое управление задачами возможно осуществить через переменные окружения, объявленные прямо в crontab каждого из пользователей.
cronie в RedHat, Fedora и CentOS
================================
[cronie](https://github.com/cronie-crond/cronie) — форк Vixie cron версии 4.1. Как и в Debian, синтаксис не менялся, но добавлена поддержка PAM и SELinux, работы в кластере, слежения за файлами при помощи inotify и других возможностей.
Конфигурация по умолчанию находится в обычных местах: системная таблица — в /etc/crontab, пакеты помещают свои таблицы в /etc/cron.d, пользовательские таблицы попадают в /var/spool/cron/crontabs.
Демон запускается под управлением systemd, конфигурация сервиса — /lib/systemd/system/crond.service.
В Red Hat-подобных дистрибутивах при запуске по умолчанию используется /bin/sh, в роли которого выступает стандартный bash. Надо заметить, что при запуске задач cron через /bin/sh командная оболочка bash запускается в POSIX-совместимом режиме и не читает никакой дополнительной конфигурации, работая в неинтерактивном режиме.
cronie в SLES и openSUSE
========================
Немецкий дистрибутив SLES и его дериватив openSUSE используют всё тот же cronie. Демон здесь тоже запускается под systemd, конфигурация сервиса лежит в /usr/lib/systemd/system/cron.service. Конфигурация: /etc/crontab, /etc/cron.d, /var/spool/cron/tabs. В качестве /bin/sh выступает тот же самый bash, запущенный в POSIX-совместимом неинтерактивном режиме.
Устройство Vixie cron
=====================
Современные потомки cron по сравнению с Vixie cron не изменились радикально, но всё же обзавелись новыми возможностями, не требующимися для понимания принципов работы программы. Многие из этих расширений оформлены неаккуратно и путают код. Оригинальный же исходный код cron в исполнении Пола Викси читать одно удовольствие.
Поэтому разбор устройства cron я решил провести на примере общей для обеих ветвей развития cron программы — Vixie cron 3.0pl1. Примеры я упрощу, убрав усложняющие чтение ifdef-ы и опустив второстепенные детали.
Работу демона можно разделить на несколько этапов:
1. Инициализация программы.
2. Сбор и обновление списка задач для запуска.
3. Работа главного цикла cron.
4. Запуск задачи.
Разберём их по порядку.
### Инициализация
При запуске после проверки аргументов процесса cron устанавливает обработчики сигналов SIGCHLD и SIGHUP. Первый вносит в лог запись о завершении работы дочернего процесса, второй — закрывает файловый дескриптор файла-лога:
```
signal(SIGCHLD, sigchld_handler);
signal(SIGHUP, sighup_handler);
```
Демон cron в системе всегда работает один, только в роли суперпользователя и из главной директории cron. Следующие вызовы создают файл-лок с PID-ом процесса-демона, убеждаются, что пользователь правильный и меняют текущую директорию на главную:
```
acquire_daemonlock(0);
set_cron_uid();
set_cron_cwd();
```
Выставляется путь по умолчанию, который будет использоваться при запуске процессов:
```
setenv("PATH", _PATH_DEFPATH, 1);
```
Дальше процесс «демонизируется»: создаёт дочернюю копию процесса вызовом fork и новую сессию в дочернем процессе (вызов setsid). В родительском процессе больше надобности нет — и он завершает работу:
```
switch (fork()) {
case -1:
/* критическая ошибка и завершение работы */
exit(0);
break;
case 0:
/* дочерний процесс */
(void) setsid();
break;
default:
/* родительский процесс завершает работу */
_exit(0);
}
```
Завершение родительского процесса высвобождает лок на файле-локе. Кроме того, требуется обновить PID в файле на дочерний. После этого заполняется база задач:
```
/* повторный захват лока */
acquire_daemonlock(0);
/* Заполнение БД */
database.head = NULL;
database.tail = NULL;
database.mtime = (time_t) 0;
load_database(&database);
```
Дальше cron переходит к главному циклу работы. Но перед этим стоит взглянуть на загрузку списка задач.
### Сбор и обновление списка задач
За загрузку списка задач отвечает функция load\_database. Она проверяет главный системный crontab и директорию с пользовательскими файлами. Если файлы и директория не менялись, то список задач не перечитывается. В противном случае начинает формироваться новый список задач.
Загрузка системного файла со специальными именами файла и таблицы:
```
/* если файл системной таблицы изменился, перечитываем */
if (syscron_stat.st_mtime) {
process_crontab("root", "*system*",
SYSCRONTAB, &syscron_stat,
&new_db, old_db);
}
```
Загрузка пользовательских таблиц в цикле:
```
while (NULL != (dp = readdir(dir))) {
char fname[MAXNAMLEN+1],
tabname[MAXNAMLEN+1];
/* читать файлы с точкой не надо*/
if (dp->d_name[0] == '.')
continue;
(void) strcpy(fname, dp->d_name);
sprintf(tabname, CRON_TAB(fname));
process_crontab(fname, fname, tabname,
&statbuf, &new_db, old_db);
}
```
После чего старая база данных подменяется новой.
В примерах выше вызов функции process\_crontab убеждается в существовании пользователя, соответствующего имени файла таблицы (если только это не суперпользователь), после чего вызывает load\_user. Последняя уже читает сам файл построчно:
```
while ((status = load_env(envstr, file)) >= OK) {
switch (status) {
case ERR:
free_user(u);
u = NULL;
goto done;
case FALSE:
e = load_entry(file, NULL, pw, envp);
if (e) {
e->next = u->crontab;
u->crontab = e;
}
break;
case TRUE:
envp = env_set(envp, envstr);
break;
}
}
```
Здесь либо выставляется переменная окружения (строки вида VAR=value) функциями load\_env / env\_set, либо читается описание задачи (\* \* \* \* \* /path/to/exec) функцией load\_entry.
Сущность entry, которую возвращает load\_entry, — это и есть наша задача, помещаемая в общий список задач. В самой функции проводится многословный разбор формата времени, нас же больше интересует формирование переменных окружения и параметров запуска задачи:
```
/* пользователь и группа для запуска задачи берутся из passwd*/
e->uid = pw->pw_uid;
e->gid = pw->pw_gid;
/* шелл по умолчанию (/bin/sh), если пользователь не указал другое */
e->envp = env_copy(envp);
if (!env_get("SHELL", e->envp)) {
sprintf(envstr, "SHELL=%s", _PATH_BSHELL);
e->envp = env_set(e->envp, envstr);
}
/* домашняя директория */
if (!env_get("HOME", e->envp)) {
sprintf(envstr, "HOME=%s", pw->pw_dir);
e->envp = env_set(e->envp, envstr);
}
/* путь для поиска программ */
if (!env_get("PATH", e->envp)) {
sprintf(envstr, "PATH=%s", _PATH_DEFPATH);
e->envp = env_set(e->envp, envstr);
}
/* имя пользовтеля всегда из passwd */
sprintf(envstr, "%s=%s", "LOGNAME", pw->pw_name);
e->envp = env_set(e->envp, envstr);
```
С актуальным списком задач и работает главный цикл.
### Главный цикл
Оригинальный cron из Version 7 Unix работал совсем просто: в цикле перечитывал конфигурацию, запускал суперпользователем задачи текущей минуты и спал до начала следующей минуты. Этот простой подход на старых машинах требовал слишком много ресурсов.
В SysV была предложена альтернативная версия, в которой демон засыпал либо до ближайшей минуты, для которой определена задача, либо на 30 минут. Ресурсов на перечитывание конфигурации и проверку задач в таком режиме потреблялось меньше, но быстро обновлять список задач стало неудобно.
Vixie cron вернулся к проверке списков задач раз в минуту, благо к концу 80-х ресурсов на стандартных Unix-машинах стало значительно больше:
```
/* первичная загрузка задач */
load_database(&database);
/* запустить задачи, поставленные к выполнению после перезагрузки системы */
run_reboot_jobs(&database);
/* сделать TargetTime началом ближайшей минуты */
cron_sync();
while (TRUE) {
/* выполнить задачи, после чего спать до TargetTime с поправкой на время, потраченное на задачи */
cron_sleep();
/* перечитать конфигурацию */
load_database(&database);
/* собрать задачи для данной минуты */
cron_tick(&database);
/* перевести TargetTime на начало следующей минуты */
TargetTime += 60;
}
```
Непосредственно выполнением задач занимается функция cron\_sleep, вызывающая функции job\_runqueue (перебор и запуск задач) и do\_command (запуск каждой отдельной задачи). Последнюю функцию стоит разобрать подробнее.
### Запуск задачи
Функция do\_command исполнена в хорошем Unix-стиле, то есть для асинхронного выполнения задачи она делает fork. Родительский процесс продолжает запуск задач, дочерний — занимается подготовкой процесса задачи:
```
switch (fork()) {
case -1:
/*не смогли выполнить fork */
break;
case 0:
/* дочерний процесс: на всякий случай еще раз пробуем захватить главный лок */
acquire_daemonlock(1);
/* переходим к формированию процесса задачи */
child_process(e, u);
/* по завершению дочерний процесс заканчивает работу */
_exit(OK_EXIT);
break;
default:
/* родительский процесс продолжает работу */
break;
}
```
В child\_process довольно много логики: она принимает стандартные потоки вывода и ошибок на себя, чтобы потом переслать на почту (если в таблице задач указана переменная окружения MAILTO), и, наконец, ждёт завершения работы основного процесса задачи.
Процесс задачи формируется еще одним fork:
```
switch (vfork()) {
case -1:
/* при ошибки сразу завершается работа */
exit(ERROR_EXIT);
case 0:
/* процесс-внук формирует новую сессию, терминал и т.д.
*/
(void) setsid();
/*
* дальше многословная настройка вывода процесса, опустим для краткости
*/
/* смена директории, пользователя и группы пользователя,
* то есть процесс больше не суперпользовательский
*/
setgid(e->gid);
setuid(e->uid);
chdir(env_get("HOME", e->envp));
/* запуск самой команды
*/
{
/* переменная окружения SHELL указывает на интерпретатор для запуска */
char *shell = env_get("SHELL", e->envp);
/* процесс запускается без передачи окружения родительского процесса,
* то есть именно так, как описано в таблице задач пользователя */
execle(shell, shell, "-c", e->cmd, (char *)0, e->envp);
/* ошибка — и процесс на запустился? завершение работы */
perror("execl");
_exit(ERROR_EXIT);
}
break;
default:
/* сам процесс продолжает работу: ждет завершения работы и вывода */
break;
}
```
Вот, в общем-то, и весь cron. Какие-то интересные детали, например учёт удалённых пользователей, я опустил, но главное изложил.
Послесловие
===========
Сron — на удивление простая и полезная программа, выполненная в лучших традициях мира Unix. Она не делает ничего лишнего, но свою работу выполняет замечательно на протяжении уже нескольких десятилетий. Ознакомление с кодом той версии, что поставляется с Ubuntu, заняло не больше часа, а удовольствия я получил массу! Надеюсь, я смог поделиться им с вами.
Не знаю, как вам, но мне немного грустно осознавать, что современное программирование с его склонностью к переусложнению и переабстрагированию уже давно не располагает к подобной простоте.
Существует множество современных альтернатив cron: systemd-timers позволяют организовать сложные системы с зависимостями, в fcron можно гибче регулировать потребление ресурсов задачами. Но лично мне всегда хватало простейших crontab.
Словом, любите Unix, используйте простые программы и не забывайте читать маны для вашей платформы! | https://habr.com/ru/post/468061/ | null | ru | null |
# Как я изобретал велосипед, изучая технологии
Неоднократно слышал утверждение, что язык программирования изучать лучше всего в процессе создания чего-либо. Не мог с этим не согласиться, и решил, что это распространяется не только на язык, но и на всякие технологии сосуществующие с этим языком.
Протаптывать неизведанную дорожку самому непросто, гораздо легче изучить, как кто-то протаптывает эту дорожку перед тобой. К изучению документаций у меня не лежит душа, ей я пользуюсь как справочником, а изучать что то с нуля отнимает слишком много времени и сил, так как авторы оной обычно предполагают, что у читателя знания обширнее, практически все что нужно он уже знает. Велосипедные темы же освещают именно процесс обучения, хождение по граблям и все прочее. К сожалению, на интересные мне темы достаточно подробных статей не нашел, изучал урывками, и решил все-таки написать статью сам, в надежде упростить жизнь тем, кто может пойти следом.
Больше всего мне хотелось освоить процесс, или подход, ну или идеологию, если хотите, которая именуется TDD, aka Test-Driven Development. Также, в качестве вспомогательной технологии, в части тестов был использован тестовый фреймворк Moq. Забегая вперед, скажу, что полностью правильно разрабатывать не получилось, поскольку навыки «архитектора» у меня также нуждаются в опыте. Приходилось переделывать некоторые блоки, да и сами тесткейсы, которые я писал, еще не полностью осознавая, что и как класс должен делать. Однако дело сдвинулось с мертвой точки, опыт получен, и в следующий раз уже должно быть проще. Вторая технология, которую давно руки чесались освоить, это внедрение зависимостей и IoC контейнеры. В разработке я использовал наиболее импонирующий мне Autofac.
Тема для велосипедостроения
---------------------------
Выбирать долго не пришлось, решение пришло буквально само — писать свой логгер с фильтрацией и конфигурируемым форматом вывода. Свою первую статью я хотел написать об ASP.Net, и фреймворке MVC3. Хотя теперь уже имеет смысл перемещаться в сторону MVC4. Среди технологий, кстати, предполагалось использовать Entity Framework. На хабре уже есть статья на эту тему, но автор исчез, так и не доделав обещанного.
Итак, почему я прервался на логгер? В процессе создания того приложения, естественно, возникла необходимость логгирования. Мне посоветовали взять имеющийся в NuGet-ах NLog, но поизучав его, я пришел к выводу, что написание своего логгера не только интересно, но еще и оправдано. Сам не проверял, но, судя по отзывам в интернетах, log4net работает медленнее его, посему рассматривать его я не стал.
Сам я работаю в телекоме, и с логгером поработать мне уже пришлось, когда появилась необходимость в функциональности, которая в стандартных сислогах отсутствовала. Это фильтрация по идентификатору. Когда сайт обрабатывает 30 тысяч звонков в час, то, даже если баг воспроизводим на нем на 100%, найти ее в мегабайтах и даже гигабайтах логов не так уж просто. Да и не все системы позволяют хранить гигабайты логов, кое где есть системы, у которых в ротацию логов попадает лишь несколько минут траффика в час пик и сам звонок может быть больше по длине, то есть в лог может не попасть начало звонки или конец. Посему «сверху» и пришла идея — выделить нужное, пометив звонок, чтобы в логи попал только он один. Ну, или несколько звонков, но только на тот номер, где периодически случается этот баг. Сислог был успешно заменен на макрос, который сравнивает идентификатор в сессии со списком заданных оператором идентификаторов. Идентификатор привязывался как к уникальному адресу терминала, так и к набираемому номеру. В моем же ASP.Net приложении фильтровать предполагалось по userid. Конечно, тут это может быть и не очень оправдано, но раз уж я решил, что логгеру нужна эта фича, то так тому и быть.
Второй вело-повод я нашел, поизучав исходники NLog-а. В нем практически все действия совершаются в контексте вызывающего потока, асинхронно производится лишь непосредственная запись в target. Что, в чем я позже убедился, наносит немалый ущерб производительности.
Вынесение операций в отдельный поток
------------------------------------
Эту операцию я сразу же инкапсулировал в отдельный класс. Класс запустит поток, в котором все сообщения будут обрабатываться, и позволит в этот поток эти сообщения передавать. Сообщение будет содержать текст лога, уровень, и прочую информацию. Нужно это для решения поставленной задачи — минимизировать количество действий в контексте потока, отправляющего логи.
За основу я взял пример ThreadSync из Language Samples, которые имеются в составе Visual Studio. Сначала интерфейс класса:
```
public delegate void ReceiveHandler(T item);
public interface IQueued
{
event ReceiveHandler OnReceive;
event Action OnTimeout;
bool Active { get; }
void setTimeout(int timeout);
void Send(T msg);
void Terminate();
}
```
Флаг выставляется в начале внутреннего метода ThreadRun, и сбрасывается в конце. Событие OnReceive наступает в случае, когда потоком получено новое сообщение. Тип делегата события создан, чтобы избежать приведения типа аргумента. Таймаут создан для того, чтобы позволить не писать сразу на диск, а сначала в буфер, например в StringBuilder. Через указанное время после получения последнего сообщения будет один раз вызвано событие OnTimeout, чтобы последний полученный лог гарантированно попал на диск.
Варианта у класса два, можно выбрать в зависимости от каких либо причин. Один вариант запускает свой поток, но нуждается в вызове Terminate.
```
thread = new Thread(ThreadRun);
thread.Start();
```
Второй класс, реализующий тот же интерфейс, добавляет свой метод в стандартный ThreadPool. У него свои недостатки, в частности если основное приложение уже использует несполько потоков из пула, то этот поток может очень задержаться со стартом. Одна радость – его не надо завершать вызовом Terminate(), он закроется сам по закрытию приложения.
```
ThreadPool.QueueUserWorkItem(ThreadRun);
```
На вход конструктор принимает ManualResetEvent, который можно скормить нескольким классам, орудующим с потоками, а потом использовать его, как централизованное событие завершения приложения. В логгере я не стал этим пользоваться, но на всякий случай добавил такую возможность. Кроме события завершения, для работы также используется событие, означающее, что в очередь попало новое сообщение. Выглядит это так
```
EventWaitHandle[] events = new EventWaitHandle[2];
...
events[0] = new AutoResetEvent(false);
events[1] = terminateEvent ?? new ManualResetEvent(false);
```
Тут вполне очевидно, что задача метода Terminate в том, чтобы установить events[1] в единицу.
Для хранения переданных сообщений я использовал Queue queue; Метод Send() просто срисован с примера:
```
lock (queSync)
{
queue.Enqueue(msg);
}
events[0].Set();
```
Для приема же сообщений на другой стороне я решил прибегнуть к небольшой хитрости, чтобы максимально снизить время блокировки очереди «собирающим» потоком. Именно поэтому lock производится не на самой очереди, а на отдельно созданном объекте. Принимающий поток крутится внутри бесконечного цикла, выход из которого будет произведен, если индекс будет равен единице, что означает, что сработал events[1], вызванный либо из метода Terminate, либо извне, как я говорил ранее.
```
while ((index = WaitHandle.WaitAny(events, currentTimeout)) != 1)
```
Метод WaitAny блокирует поток до срабатывания одного из событий, либо таймаута, по умолчанию равного Infinite. То есть поток логгера будет спать и никак не влиять на производительность приложения, пока то не начнет посылать логи. При срабатывании в первую очередь мы проверяем был ли таймаут, и активируем соответствующее событие.
```
if (index == WaitHandle.WaitTimeout)
{
OnTimeout();
currentTimeout= Timeout.Infinite;
}
```
Вторая строчка здесь появилась именно благодяря юнит-тестам, при кодировании я ее проморгал. Далее, в противном случае, сообщения из очереди надо извлечь, и с каждым из них вызвать событие OnReceive. «Хитрость», о которой я говорил ранее, видна в коде.
```
Queue replacement = new Queue();
Queue items;
lock (queSync)
{
items = queue;
queue = replacement;
}
foreach (T t in items)
{
OnReceive(t);
}
currentTimeout = timeout;
```
По всем критичным моментам этого класса, ну или модуля, я прошелся, полностью его код, как и всех остальных классов, можно будет найти в репозитории, ссылку повешу в конце статьи и далее этот дисклеймер повторять не буду,
Уже во время написания статьи в голову пришла шальная идея сделать тоже самое используя ConcurrentQueue, естественно уже без вышеописанной хитрости, но зато полностью без блокировки. И при этом надо как то оставить возможность создания обоих типов потоков. Поэтому принято решение инкапсулировать создание потока позади своего интерфейса, который я назову IStarter, состоять классы будут из единственного метода каждый. Кстати, тут вполне можно было бы воспользоваться лямбда-выражением, но эстет во мне воспротивился этому. В результате то, что должно получиться будет похоже на известный паттерн бридж, где «по эту сторону моста» два класса, один с блокировками, другой с интерлоком, а «по ту сторону моста» два варианта запуска потока для них, и использоваться они между собой смогут в любых комбинациях. Вся прелесть идеологии «взаимодействовать с интерфейсом, а не с реализацией»(с)GoF тут выражается не только в том, что остальные классы, взаимодействующие с данным не надо будет трогать, но и в том, что юнит-тесты так же не надо менять. Совсем-совсем. Нужно только лишь изменить полиморфный метод создания конкретных объектов, который этим тестам скормит все варианты.
Зачатки TDD
-----------
Немного потеоретизирую на тему. Поначалу, на примере класса, который был первым, да и со вторым было то же самое, поведение разработки не получилось подвести под TDD, где сначала тесты, потом сам код. Путь моей разработки проходил через следующие этапы — написание рабочего кода, затем написание тесткейсов, затем корректирование, как первого, так и второго, доведение до кондиции. После чего тесты «признаются верными», и рефакторинг, который позже следует, вполне может на них опираться. Почему я считаю, что этот подход имеет право на жизнь, по крайней мере, для новичка: Если рассмотреть простейшую функцию A = B + C, то тестирование данной функции напрашивается формулой С1 = А — В, и далее вывод успешности теста на основе сравнения С == С1. Ошибки тут могут содержаться как в тестируемой функции, так и в тестирующей. Даже более того, поскольку в ней больше действий, ошибка более вероятна. На этом моменте можно задаться вопросом, зачем вообще тогда нужно тестирование, но ответ естественно уже есть, все сформулировано до нас. Чтобы тест показал «пройдено», нужно чтобы выполнилось одно из условий. Отсутствие ошибок в обеих функциях, или одновременное наличие ошибки и там и там. Вероятность того, что возникнут обе ошибки меньше, чем вероятность каждой ошибки в отдельности, тем более самого наличия тут недостаточно, надо еще, чтобы ошибки были синергичны, то есть компенсировали влияние друг друга, вероятность чего еще ниже. То есть, все усилия по написанию тестов напрямую направлены на снижение вероятности ошибок. Правда, при написании и тестов и кода одним и тем же человеком, вероятность того, что он допустит одну и ту же ошибку несколько выше. Ну да ладно, как мне кажется, для велосипеда и то, что есть — уже хорошо.
Перейдем к написанию первых тестов. Для этого сначала создаем шаблон теста, нажав на имени интерфейса IQueued правой кнопкой и выбрав соответствующий пункт меню. Итак, что же нужно, чтобы протестировать этот класс. Тестировать его предполагается в изоляции, то нужно сделать моки(имитаторы) классов, которые с сабжевым классом взаимодействуют. Еще один момент — поскольку целью теста выбран интерфейс, а конкретных классов, которые надо протестировать, вначале было два, а позднее стало 4 комбинации 2 по 2, то свежесозданный тестовый класс имеет смысл сразу наградить модификатором abstract и добавить ему generic параметр .
```
[TestClass()]
public abstract class IQueuedTest
```
Поскольку класс абстрактный, непосредственно на нем тесты производиться, естественно, не будут, вместо этого будут выполняться все тестовые классы, унаследованные от него.
В первую очередь нам нужен имитатор класса потребителя услуги.
```
class Tester
```
Класс этот будет подписываться на события тестируемого класса, считать срабатывания событий, и запоминать, что в этом событии пришло.
```
public Tester(IQueued tested)
{
tested.OnReceive += Received;
tested.OnTimeout += TimeOut;
}
void TimeOut()
{
timedCount++;
}
void Received(T1 item)
{
Thread.Sleep(delay);
receivedCount++;
lastItem = item;
}
```
Кроме этого внутреннего класса, понадобятся методы для создания конкретных объектов, которые мы обяжем всех наследников переопределить.
```
protected abstract IQueued createSubject();
protected abstract T CreateItem();
```
Итак, собственно к написанию тестов. Кстати, при прочтении подобных статей, я замечал, что авторы опускают грабли, и приводят уже готовое решение. Я же постараюсь на некоторых граблях остановиться чуть подробнее. Первая проблема, с которой я столкнулся, это та самая задержа старта в пуле потоков. При запуске приложения, пул держит лишь несколько потоков, а новые запускает лишь с задержкой, которая измеряется в десятых долях секунды. А тестовый фреймворк, похоже исполняет тесты параллельно. Из-за этого тесты с «ручным» потоком проходили успешно, а с потоком из пула некоторые проходили, некоторые валились. Посему есть два варианта, выделить все тесты в один и тот же «длинный» метод, который будет исполняться быстрее, но выдаст лишь один общий вердикт, либо придумывать обходные маневры. Я придумал следущее:
```
void ActivationTestHelper(Tester tester, IQueued subject)
{
int retry = 30;
while (!subject.Active && retry > 0)
{
retry--;
Thread.Sleep(SleepDelay);
}
Assert.AreEqual(true, subject.Active);
}
```
30 попыток «подождать» пока поток не активируется, после чего только приступать к тесту. Хелпер будет вызываться непосредственно после создания.
И, еще раз – итак, к написанию тестов. Первый тест на отправку-получения сообщения. Поскольку мы знаем, что задача класса – передать другому потоку, то надо убедиться, что класс тестер не получает сообщение в контексте передающего потока, потом убедиться, что успешно получает после. Именно для этого(для первого), кстати, в коде метода Received у тестера стоит задержка, в 50мс. Если эта задержка произойдет в вызывающем потоке, то первый Assert зафейлит тест.
```
[TestMethod()]
public void SendTest()
{
var subject = createSubject();
var tester = new Tester(subject);
ActivationTestHelper(tester, subject);
T item = CreateItem();
tester.delay = SleepDelay;
subject.Send(item);
Assert.AreEqual(0, tester.receivedCount);
```
Далее, чтобы убедиться, что сообщение передано, мы подождем 100мс и проверим полученное. В принципе эти значения можно и уменьшить, главное, чтоб вторая задержка была больше первой, но тут, я думаю это непринципиально. Не забыть завершить поток, чтобы «дать дорогу» следующим тестам.
```
Thread.Sleep(SleepDelay2);
Assert.AreEqual(1, tester.receivedCount);
Assert.IsTrue(tester.lastItem.Equals(item));
subject.Terminate();
}
```
Далее, тест таймаута. Также создадим объекты, выполним хелпер активации. Зададим таймаут и проверим также, что он не вызвался в контексте вызывающего потока, но вызвался после. Причем только один раз.
```
[TestMethod()]
public void TimeoutTest()
{
var subject = createSubject();
var tester = new Tester(subject);
subject.setTimeout(SleepDelay);
ActivationTestHelper(tester, subject);
T item = CreateItem();
subject.Send(item);
Assert.AreEqual(0, tester.timedCount);
Thread.Sleep(SleepDelay3);
Assert.AreEqual(1, tester.timedCount);
}
```
Для этого теста задана задержка в 200мс, вчетверо больше значения таймаута, и именно этот тест у меня поймал мою первую ошибку-недопечатку, о которой я говорил ранее. Этим и приятны оказались юнит-тесты, что абсолютное большинство ошибок не доходит не только до «продакшена», а даже до альфа триала. Эти ошибки, естественно, были бы там обнаружены, но работу, потраченную на написание тестов, все равно бы пришлось совершить уже для отладки. Получился этакий прием тайм-менеджмента, который перемещает некий объем работ из периода, когда аврал, в период «ленивой» разработки. И это все даже без упоминания о неоценимом подспорье в рефакторинге, который я сам себе придумывал по ходу дела.
Оставшийся тест – завершение потока. Надо убедиться, что поток остановлен и ничего никуда не передается. Опустив общие для всех тестов шаги, получаем следующее:
```
public void TerminateTest()
{
...
subject.Terminate();
subject.Send(item);
Thread.Sleep(SleepDelay3);
Assert.AreEqual(0, tester.receivedCount);
Assert.AreEqual(0, tester.timedCount);
}
```
В интерфейсе всего три теста, но конкретных класса два, еще два варианта запуска потока и сверх этого, я решил раздельно проверить, как оно работает и с классами и со структурами в качестве передаваемого сообщения. Для чего создаются 8 конкретных тестовых классов, один из которых я приведу, а количество конкретных тесткейсов получается 24. Тестовая структура:
```
public struct TestMessageStruct
{
public string message; //object reference field
public int id; //value field
}
```
И собственно конкретный тестовый класс, который тестирует вариант: блокируемая очередь, обычный поток, структура.
```
[TestClass()]
public class IQueuedLockRegTest : IQueuedTest
{
protected override IQueued createSubject()
{
return new LockQueued(new RegularThreadStarter());
}
protected override TestMessageStruct CreateItem()
{
var item = new TestMessageStruct();
var rnd = new Random();
item.id = rnd.Next();
item.message = string.Format("message {0}", item.id);
return item;
}
}
```
Именно конкретные тестовые классы, создающие конкретные подопытные объекты и пришлось переделать в связи с этим, если это можно так назвать, рефакторингом. И еще пришлось увеличить их количество вдвое, но, как видно, это занимает существенно меньше времени и сил, чем при написании и обдумывании самих тестов.
Интерфейс логгера и первый слой фильтрации
------------------------------------------
Интерфейс наружу я решил сделать как у NLog, не мудрствуя лукаво. Только назвал статический класс LogAccess, почему-то по смыслу он мне показался более логичным. Сам он ничего не делает, только проксирует вызовы. В тестах он по этой причине не участвует, посему останавливаться на нем не буду, лишь перечислю основные из методов видных «снаружи», первый метод позволяет получить собственно логгер, чтобы спамить сообщения, следующие два управляют фильтрацией по уровню, последние по id. Имя, или категория, логгера, присутствующая в первом слое фильтрации, означает, что выполнение этой фильтрации до прохождения через класс, описанный в предыдущем разделе, то есть уровень можно отдельно задавать для каждой категории логов. Отсутствие же категории на втором слое фильтрации соответственно означает, что это фильтрация производится уже позади, в потоке логгера.
```
Logger GetLogger(string category)
void SetLevel(string category, int level)
void SetLevelForAll(int level)
void FilterAddID(int id)
void FilterRemoveID(int id)
```
Второй класс, который виден извне, это LogLevel. Уровни по смыслу я взял из телекома. Тут решил относительно NLog упростить, и использовать обычный int в качестве уровня, чтобы не мудрить со сравнением уровней и т.п.
Добавил лишь уровень All, чтобы сделать два уровня дебага, сокращенный и подробный, чего порой не хватало на практике.
```
public const int Invalid = 0;
public const int Always = 1;
public const int Fatal = 2;
public const int Error = 3;
public const int Warning = 4;
public const int Info = 5;
public const int Event = 6;
public const int Debug = 7;
public const int All = 8;
public const int Total = 9;
```
Также включил в класс свойство Default, для задания уровня из LogAccess.
Ну и самое главное, что видно снаружи, это интерфейс Logger. Умышленно не стал добавлять ему приставку I. Некоторые методы из него приведу.
```
public interface Logger
{
///
/// Method for unrecoverable errors.
///
///
///
void Fatal(string message, Exception ex = null);
///
/// Method for external errors, such as user input or file access.
///
///
///
///
void Warning(string message, int id = 0, Exception ex = null);
///
/// Method for regular debug logging.
///
///
///
void Debug(string message, int id = null);
}
```
Методы для ошибок не привязаны к идентификаторам, только уровни Warning и выше.
Далее, рассмотрю класс конкретного логгера, чтобы показать. каким способом достигается собственно минимализация производительности, отнимаемой логгером у вызывающего потока. Кстати у интерфейса логгера есть расширенная версия, не видная снаружи, добавляющая метод SetLevel.
```
class CheckingLogger : InternalLogger
{
bool[] levels = new bool[LogLevel.Total];
Sender send;
string category;
public CheckingLogger(string category, Sender sender, int level)
{
this.send = sender;
this.category = category;
SetLevel(level);
}
public void SetLevel(int level)
{
for (int n = LogLevel.Fatal; n < LogLevel.Total; n++)
{
levels[n] = (n <= level);
}
}
public void Error(string message, Exception ex = null)
{
if (levels[LogLevel.Error])
{
send(new LogItem(category, LogLevel.Error, message, ex: ex));
}
}
```
Для рассмотрения достаточно одного спамящего метода, видно, что он проверяет булевое значение из массива, и отсылает посредством делегата Sender. Второй вариант логгера вместо булевого массива использует массив Sender-ов, в выключенный уровень вставляется делегат на пустой метод, а в методе отсылки отсутствует проверка, сразу посылка. По результатам тестирования разница в производительности незначительная, возможно тестирование на разных платформах тут дало бы ответ. Тесты логгеров достаточно просты, проверяется ушло ли в Sender сообщение, тогда, когда должно, и когда не должно. Тут я тоже наткнулся на опечатки и ошибки копипаста, т.к. много почти одинаковых методов, разницы беглым взглядом не видно.
Не придумал в какой раздел вписать класс, точнее структуру LogItem, использующуюся для собственно передачи логов, приведу здесь, опуская конструктор, только наполнение. Из него, кстати, видно, что id для одного сообщения можно задать более одного, это нужно либо для броадкаста, либо, в случае звонка, чтобы указать два идентификатора: звонящего и отвечающего на звонок. Методы в предыдущих классах продублированы с этой целью, только обделены вниманием.
```
struct LogItem
{
public readonly String category;
public readonly String message;
public readonly int[] ids;
public readonly int level;
public readonly Exception ex;
public readonly DateTime time;
}
```
Внедрение зависимостей
----------------------
В этом разделе я приведу пример использования IoC контейнера. Следующий на очереди рассматриваемый класс — контейнер логгеров. Имя с контейнером IoC не связано, просто совпало. Он предоставляет метод GetLogger, куда и проксируется метод класса LogAccess. NLog, судя по комментариям в коде, не гарантирует того, что дважды вызванный метод GetLogger с одной и той же категорией даст один и тот же экземпляр логгера. Я же подумал и решил, что этот метод не будет узким местом, и поставил общую синхронизацию на нем, в этом случае экземпляр должен быть гарантировано одним и тем же. Контейнер логов хранит все ранее созданные логгеры и раздает им SetLevel, так же проксируемый из LogAccess.
Итак, создаем IoC контейнер, дальнейшая конфигурация помещается между следующими двумя строчками:
```
var builder = new ContainerBuilder();
IContainer container = builder.Build();
```
Из вышеописанного понятно, что класс должен быть синглтоном. Достигается это достаточно просто:
```
builder
.RegisterType()
.SingleInstance();
```
И следующим методом мы можем получить ссылку на наш синглтон.
```
Container
.Resolve();
```
Чтобы контейнер логов сам мог воспользоваться услугами IoC контейнера из которого создан, я добавил ему в конструктор параметр IComponentContext. Это позволяет вынести создание класса наружу, и менять конкретные классы, например на классы с расширенной функциональностью, не меняя использующий код, а лишь изменением конфигурации, которую в т.ч. можно и не задавать в коде вообще, а подгружать из xml. Собственно эта замена внутреннего создания на внешнее создание и называется внедрением зависимости. Собственно, метод, который получает с контекста конкретный логгер:
```
private InternalLogger CreateLogger(string category)
{
return context
.Resolve(new NamedParameter[]{
new NamedParameter("category", category),
new NamedParameter("level",LogLevel.Default)
});
}
```
Кроме этого, данный пример показывает, как задать конкретному классу параметры для конструктора из места вызова, а не в конфигурации контейнера, которая в данном случае остается такой же простой, как и в предыдущем случае. Отличие лишь в том, что у нас не синглтон и точка доступа здесь интерфейс, а не сам класс.
```
builder
.RegisterType()
.As();
```
Тут виден некоторый негатив, с которым я не знаю, как дальше жить, разве что в комментариях к интерфейсу писать какие входные параметры по имени и типу должны присутствовать в конструкторе конкретного класса. Трудно диагностируемые ошибки, которые в обычном случае отсеял бы компилятор, просто таки ждут, чтобы тут случиться. Изменяя конфигурацию контейнера, об этом можно и не узнать, ибо для этого нужно будет делать поиск референсов на интерфейс. Вероятно в этом случае лучше использовать «классическую» фабрику.
Далее о том, что дает использование IoC: контейнера при юнит-тестировании. Для теста можно и нужно создать свой контейнер:
```
[TestClass()]
public class LoggerContainerTest
{
IContainer testContainer;
public LoggerContainerTest()
{
var builder = new ContainerBuilder();
builder
.Register((c, p) => new LoggerContainer(c.Resolve()));
builder
.RegisterType()
.As();
testContainer = builder.Build();
}
```
Здесь проиллюстрирована еще одна фича, которая есть в Autofac, он позволяет сконфигурировать старый добрый new, который собственно и будет вызываться при Resolve, что работает, естественно, существенно быстрее, чем рефлексия.
Осталось привести фрагмент одного из тестовых методов.
```
LoggerContainer lc=
testContainer
.Resolve();
var logger1 = lc.GetLogger(cat1);
var logger2 = lc.GetLogger(cat2);
var logger3 = lc.GetLogger(cat1);
Assert.AreEqual(logger1, logger3);
Assert.AreNotEqual(logger1, logger2);
```
Тестовый фреймворк Moq
----------------------
Еще одна полезная технология, позволяющая упростить написание тестов. Я покажу ее применение на примере следующего класса, который я назвал сборщиком логов или LogCollector-ом. Он использует тот самый IQueued для развязки с отсылающими потоками, осуществляет фильтрацию по идентификатору, и второй зависимостью имеет класс записывающий в файл и осуществляющий ротацию.
Не буду подробно расписывать, как он работает, все достаточно просто и очевидно, остановлюсь в общих чертах еще на одном классе, который перед записью в файл осуществляет конструирование строки из LogItem. Его я решил сделать конфигурируемым, давно было интересно решить такую задачу.
Пример конфигурации NLog: layout="${longdate} ${uppercase:${level}} ${message}".
И пример конфигурации моего логгера LogMessageFormat=\d \l \m\r\n.
Выводится в точно таком же виде, дата, уровень, само сообщение и перевод строки. Специально подгонял формат вывода, чтобы можно было непосредственно сравнивать производительность. Также именно в этой строке я сделал возможность добавлять идентификатор, исключение с его стектрейсом, ну и прозвольные строки между всеми этими идентификаторами. Конструирование идет по цепочке, каждый следующий конструктор накидывает в StringBuilder из передаваемого LogItem свою часть сообщения. Цепочка выстраивается один раз, при распарсивании задающей строки.
Основная задача класса достаточно проста, поэтому не буду приводить код, ее осуществляющий, немного остановлюсь на фильтрации. Поскольку тут также стоит задача синхронизации, то есть вызов метода, добавляющего или удаляющего идентификатор, происходит из другого потока. Один способ — блокировать список, ну или HashSet, окажет влияние на производительность. Я же пошел немного другим путем, тоже давно видел такую возможность, предоставляемую языком и хотел найти ей применение. Суть решения в передаче анонимного метода Action через неблокируемую очередь. filterQue = new ConcurrentQueue>();
Фильтрующий метод при каждой попытке фильтрации проверяет пуста ли очередь, что должно работать быстрее, чем захват монитора, и если она не пуста, то выполняет полученный метод в контексте потока логгера.
```
Action> refresh;
while (!filterQue.IsEmpty)
{
if (filterQue.TryDequeue(out refresh) && refresh != null)
{
refresh(filter);
}
}
```
Вызывающий же метод, вместо обращения непосредственно к сету, кладет нужный делегат в очередь.
```
filterQue.Enqueue((x)=>
{
x.Add(id);
});
```
Возвращаясь к Moq — в вышеописанных классах я создавал моки самостоятельно, что требует достаточно много дополнительного кода, и может быть неудобно, да и некрасиво, в особенности когда нужно протестировать единственный метод класса. Moq позволяет автоматически создать класс либо реализующий заданный интерфейс, либо наследующий заданный класс с переопределением всех виртуальных методов. Тут сразу видно ограничение — нельзя сделать мок на класс с невиртуальными методами. Но, как завещали нам GoF, программировать нужно «к интерфейсу», то есть желательно все классы должны быть снабжены оным, что, вобщем-то и позволяет применять все вышеописанные приемы и технологии, не считая того, что облегчает, и формализует чтоли, разработку вообще.
Еще один нюанс работы с Moq — при создании тестов, в некоторых случаях студия сама вносит в сборку атрибут, позволяющий доступ к internal классам из сборки тестового проекта, иногда надо вносить самому, а для того, чтобы Moq также имел доступ к классам и интерфейсам, которые нужно сымитировать, надо добавить доступ и для него. Для этого в проекте надо найти файл AssemblyInfo.cs и добавить, либо модифицировать строчку, чтобы она выглядела следующим образом:
```
[assembly: System.Runtime.CompilerServices.InternalsVisibleTo("LoggerTest"),
System.Runtime.CompilerServices.InternalsVisibleTo("DynamicProxyGenAssembly2")]
```
Первое, что нужно протестировать, это чтобы сборщик передал полученное сообщение в класс, создающий развязку потока.
На само сообщение мок решил не делать, поскольку он этим классом только передается туда-сюда, и никак с ним не контактирует, не вызывает его методы, не считывает его поля.
```
LogItem message = new LogItem(category, level, msg, ids, GetException());
var qThread = new Mock>(MockBehavior.Strict);
var writer = new Mock(MockBehavior.Strict);
qThread
.Setup(s => s.Send(It.IsAny()));
writer
.Setup(s => s.GetTimeout())
.Returns(timeout);
qThread
.Setup(s => s.SetTimeout(It.IsAny()));
LogCollector target = new LogCollector(qThread.Object, writer.Object);
qThread
.Verify(s => s.SetTimeout(It.Is(a => a == timeout)));
target.Send(message);
qThread
.Verify(s => s.Send(It.Is(i => i.Equals(message))), Times.Once());
}
```
На случай, если нужны пояснения: первые две строчки создают ими таторы зависимостей. Параметр Strict означает, что мок выбросит исключение, если у классов будут вызваны методы, которые не сконфигурены перед использованием, тем самым зафейлив тест.
Следующий вызов маркирует метод Send у IQueued мока, обозначая, что он будет вызван в процессе теста. Тут также можно указать предусловия, если методов несколько, то после теста можно все предусловия проверить вызовом VerifyAll(). Я же остановился на подробном, избыточном описании теста. Следующая строчка означает, что должен быть вызван метод GetTimeout, и также указывает моку, что он должен вернуть. Следующая строчка также маркирует метод SetTimeout.
Далее мы создаем объект сборщика, и скармливаем ему его зависимости, после чего убеждаемся, что сборщик вызвал GetTimeout у одной зависимости и передал значение в другую зависимость. Тут лучше было создать отдельный тестметод для тестирования конструктора, но я оставил как есть, беспричинно, спонтанно. Далее мы посылаем сообщение, и убеждаемся, что оно было переправлено в развязку.
Тут уже видно, что код теста является законченным, и не вынуждает при ревью или редизайне смотреть дополнительные файлы с объявленными вручную моками, а зачит сокращает потенциальные временные издержки, что само по себе уже достаточно веская причина использовать Moq.
Нагрузочное тестирование
------------------------
Я ожидал увидеть превосходство своего подхода перед NLog, готов был корпеть над микрооптимизациями, экономить копейки ради того, чтобы оправдать ожидания еще чуть лучше. Но результаты уже первых тестов меня поразили, отбив такое желание.
Для нагрузочного теста я создал консольное приложение в котором брал логгер и в цикле слал в него сообщения.
```
var log = SharpLogger.LogAccess.GetLogger("flooder " + tid);
foreach (var x in Enumerable.Range(0, messageCount))
{
log.Info("Message", x);
if (x % 1000 == 0)
Thread.Sleep(0);
}
```
И точно такой же метод для NLog.
```
var log = NLog.LogManager.GetLogger("flooder " + tid);
foreach (var x in Enumerable.Range(0, messageCount))
{
log.Info("Message");
if (x % 1000 == 0)
Thread.Sleep(0);
}
```
В методе виден tid, означающий, что выполнение происходит в несколько потоков.
Тестов я, конечно же, провел немало, но думаю, что вполне достаточно привести один тест. Три потока посылают по 200 тысяч сообщений. На скриншоте таскменеджера загрузка процессора. Первый маленький всплеск — мой логгер, далее, через 5 секунд задержки — работа NLog. Результирующие логфайлы получились идентичны, за исключением несовпадающего времени.
Еще также приведу говорящий сам за себя результат замера самой тестовой программой.
При перекомпиляции под x64 результат почти не меняется.
Конечно нужно упомянуть один нюанс — ведь я использую дополнительный поток, который не использует Nlog, и замеряю я только то процессорное время, которое операция отсылки отняла у вызывающих потоков, а процессорную нагрузку, которую создает этот поток, обхожу стороной. На это я тоже решил посмотреть, запустив тест уже из 40 потоков, отсылающих по полмиллиона сообщений.
Результат, который выдала программа — 7.15 секунд., но на графике видно, что поток логгера еще примерно 25 секунд отрабатывал запись в файл. Это, несомненно, недостаток, поскольку и программа может завершиться раньше логгера, до полной записи, что исключено в случае NLog и, дополнительно к этому, поток будет есть один процессор полностью даже тогда, когда нагрузка в основной программе уже кончилась. Утешительным моментом тут является то, что NLog при таком количество логов убъет процессор на шесть часов по примерным прикидкам, что дает основание с указанным недостатком примириться.
И еще один момент, который надо бы упомянуть — влияние неблокирующей очереди на производительность относительно обычной очереди с блокировкой.
Делал два теста, в первом 3 потока слали по 15 миллионов сообщений, неблокирующая очередь сократила замеренное время с 22.2 секунды до 17.8. При увеличении количества потоков до 30, и при сохранении общего количества сообщений, то есть по 1.5 миллиона на поток, очередь с блокировкой еще чуть замедлила выполнение теста до 23.7 секунд, а неблокирующая же наоборот немного ускорила до 17.4, увеличив разрыв.
Как видно по скриншотам, тестирование проводилось на 4х ядерном i5 с частотой 4ГГц, на windows 8.
Проект можно скачать с гитхаба по ссылке <https://github.com/repinvv/SharpLogger>
Ошибки, опечатки и прочие комментарии – велкам. | https://habr.com/ru/post/151641/ | null | ru | null |
# Alias DNS-записи: что это и когда использовать
Привет, Хабр! Меня зовут Виктор, я разработчик в Selectel. Часто ко мне обращаются клиенты и спрашивают, в каких ситуациях использовать DNS-записи типа alias. Вопросы появляются на почве ограничений и нюансов RFC. Пора разложить все по полочкам!
> **Дисклеймер:** большую часть информации из статьи можно найти в RFC по каждому из типов записей. В статье дали выдержку самого важного и показали варианты практического применения. Материал поможет нашим клиентам правильно настроить DNS-записи.
Какие DNS-записи бывают?
------------------------
DNS-записи позволяют протянуть взаимосвязи между IP-адресами и доменами. Именно с помощью них серверы делятся информацией о доменах с другими серверами. Поэтому важно ответственно подойти к настройкам — они разные, в зависимости от типов записей.
Например, есть A-записи, которые нужны исключительно для связи IP с доменом, CNAME, которые работают с поддоменами, MX, позволяющие настроить почтовые домены, и другие. Далее будем говорить только о DNS-записях типа alias, так как они, по моему опыту, вызывают наибольшее количество вопросов.
### Записи типа alias
Всего существует пять основных записей типа alias — CNAME, ALIAS, ANAME, BNAME и DNAME. Но больше всего работают именно с ALIAS и CNAME. В Selectel DNS есть только эти два типа — это связано с тем, что ANAME, BNAME и DNAME оказались неудачными попытками и не смогли найти массового практического применения.
Теперь разберемся, когда эти записи нужны. За отправную точку возьмем самую популярную запись из этого класса — CNAME.
[](https://selectel.ru/services/additional/dns/?utm_source=habr.com&utm_medium=referral&utm_campaign=dns_article_alias_260123_banner)
CNAME: запись для перенаправления поддоменов
--------------------------------------------
CNAME позволяет установить связь, например, между [www.google.com](http://www.google.com) и google.com. Но этим список возможностей этой записи не ограничивается: с помощью CNAME можно, например, перенаправить с storage.example.com на 123456.selcdn.ru, чтобы получить «красивую» ссылку.
> CNAME — это запись, отвечающая за привязку поддоменов к каноническим доменам. Она дублирует все ресурсные записи домена для поддоменов таким образом, чтобы при обращении к последнему был проброс на соответствующие адреса и настройки.
По сути, запись CNAME состоит из пары значений. Первое определяет псевдоним — например, субдомен вроде *www* или *mail* — для которого создается запись, а второе — домен, на который он указывает.
Принципиальное отличие CNAME от A-записи в том, что она связывает сервисы с доменными именами, а не с физическими IP-адресами. В случае изменения адреса не нужно переписывать все записи CNAME, достаточно изменить А-запись у оригинального домена. Несмотря на это, у CNAME есть ограничения:
* Запись CNAME нельзя добавить для домена второго уровня вроде selectel.ru или google.com. Для таких целей нужно использовать ALIAS.
* Если для поддомена добавлена запись CNAME, то другую запись для него добавить нельзя. Это связано с особенностями технической реализации CNAME: она заставляет провайдеров «копировать» все записи у оригинальных доменов. Поэтому, чтобы случайно не столкнуться с тем же конфликтом двух A-записей на разные ресурсы, ввели это ограничение.
* Если для поддомена добавлены другие записи, то добавить CNAME нельзя. Причина та же, что в предыдущем пункте.
* CNAME невозможно использовать для «перенаправления», так как HTTP-редирект в рамках системы DNS организовать нельзя.
Если помнить об этих ограничениях, проблем с CNAME не будет.
### Когда использовать CNAME
Разберем сценарий на примере [CDN-ресурса](https://selectel.ru/services/additional/cdn/?utm_source=habr.com&utm_medium=referral&utm_campaign=cdn_article_alias_260123_content) в панели управления. К нему по умолчанию мы предоставляем домены вот такого вида:
Допустим, домен по умолчанию не нравится и вы хотите, чтобы сайт CDN был доступным через собственный (*cdn.tarrydvcie.ru)* — без использования домена Selectel. Для этого вы решаете создать А-запись следующего вида:
```
cdn.tarrydvice.ru. IN A 92.53.68.16
```
*Здесь cdn.tarrydvice.ru — нужный поддомен, A — тип записи, 92.53.68.16 — адрес сервера CDN.*
Но что произойдет, если изменится IP-адрес для домена по умолчанию, например, на *92.53.68.17*? Придется в срочном порядке менять A-запись для *cdn.tarrydvice.ru* — это может привести к временной недоступности к сайту.
Наиболее простое и удобное решение в этой ситуации — использовать CNAME-запись. Тогда при изменении IP-адреса на *92.53.68.17* для *домена по умолчанию* автоматически подтянутся и для *cdn.tarrydvice.ru*.
### Подключение и настройка записи в панели
Чтобы решить задачу с доступом через «красивый» домен cdn.tarrydvice.ru, нужно добавить CNAME-запись и сослаться на стандартный домен. Это можно сделать через панель управления доменами.
После добавления CNAME, новую запись можно увидеть с помощью команды *dig*.
```
-----------
dig cdn.tarrydvice.ru CNAME
;; QUESTION SECTION:
;cdn.tarrydvice.ru. IN CNAME
;; ANSWER SECTION:
cdn.tarrydvice.ru. 3600 IN CNAME ab7b4245-9d7a-4b1b-90ba-d4115b72d63e.selcdn.net.
...
```
В качестве последнего действия нужно добавить новый домен во вкладке CDN.
Супер — все готово, теперь к CDN можно подключиться по «красивому» домену.
ALIAS: как CNAME, только выше
-----------------------------
> Принцип работы ALIAS похож на механику CNAME: она также копирует данные целевого домена. Однако не может быть добавлена для основного и «существовать» с другими записями в пределах одного поддомена.
Каждый раз, когда на серверы DNS поступает запрос типа записи A или AAAA, вызывается специальный обработчик, который преобразует ALIAS в адрес IPv4 или IPv6 соответственно.
При подключении ALIAS есть несколько ограничений, которые нужно учитывать:
* Для домена / поддомена с ALIAS-записью не может быть записи A или AAAA.
* Запись ALIAS нарушит DNSSEC на основном домене (@), поскольку в ответах @ A и @ AAAA будут отсутствовать записи RRSIG.
Нет какого-либо «черновика» и стандарта в RFC по подключению ALIAS-записи, поэтому от провайдера к провайдеру наблюдается разное поведение этой записи. Например, некоторые провайдеры умеют отправлять только типы записи A.
### Когда использовать ALIAS
Теперь разберем сценарий на базе настройки [объектного хранилища](https://selectel.ru/services/cloud/storage/?utm_source=habr.com&utm_medium=referral&utm_campaign=storage_article_alias_260123_content). Во вкладке «Хранилище» можно увидеть домен вида *288028.selcdn.ru* — это персональный домен, который используется в публичных ссылках для доступа к файлам.
Здесь ситуация аналогична CNAME: нам выгоднее использовать ALIAS-запись на красивый домен *tarrydvcie.ru*, ведь изменения IP-адреса на *92.53.68.17* для *288028.selcdn.ru* автоматически подтянутся и для *tarrydvice.ru*.
### Подключение и настройка записи в панели
Для создания ALIAS-записи перейдем во вкладку «Cетевые сервисы» → «DNS-хостинг» и откроем домен *tarrydvice.ru*.
Далее нужно добавить запись и заполнить соответствующие поля:
После этого в списке записей появится ALIAS — это можно также увидеть с помощью команды *dig*:
```
dig tarrydvice.ru ALIAS
;; QUESTION SECTION:
;tarrydvice.ru. IN A
;; ANSWER SECTION:
tarrydvice.ru. 563 IN A 92.53.68.16
```
Для удобства получения ссылок в объектном хранилище осталось выполнить последний шаг: в управлении доменами нужно добавить *tarrydvice.ru*.
Теперь при получении ссылки на файл можно увидеть дополнительную URL с «красивым» доменом.
---
**Поделитесь в комментариях, с какими трудностями вы сталкивались при подключении DNS-записей. Мы выберем интересные случаи и постараемся их разобрать.**
> **Возможно, эти тексты тоже вас заинтересуют:**
>
>
>
> → [SD – это Linux, а Midjourney – Mac: краткое полное руководство по Stable Diffusion](https://habr.com/ru/company/selectel/blog/712316)
>
> → [Расширяем возможности «малинки» в 2023 году: дополнительные модули и аксессуары для Raspberry Pi Pico](https://habr.com/ru/company/selectel/blog/709666)
>
> → [«Крутое пике» для жестких дисков: продажи упали почти вдвое, но растут продажи ленточных накопителей. Что происходит?](https://habr.com/ru/company/selectel/blog/711376) | https://habr.com/ru/post/712722/ | null | ru | null |
# Устройство и работа портов ввода-вывода микроконтроллеров AVR. Часть 2
**Подключение светодиода к линии порта ввода/вывода**
Изучив данный материал, в котором все очень детально и подробно описано с большим количеством примеров, вы сможете легко овладеть и программировать порты ввода/вывода микроконтроллеров AVR.
* [Часть 1. Работа портов ввода/вывода](http://habrahabr.ru/post/253213/)
* [Часть 2. Подключение светодиода к линии порта ввода/вывода](http://habrahabr.ru/post/253961/)
* [Часть 3. Подключение транзистора к линии порта ввода/вывода](http://habrahabr.ru/post/255715/)
* [Часть 4. Подключение кнопки к линии порта ввода/вывода](http://habrahabr.ru/post/256269/)
Пример будем рассматривать на микроконтроллере ***ATMega8***.
Программу писать будем в ***Atmel Studio 6.0***.
Эмулировать схему будем в ***Proteus 7 Professional***.
Первым примером в изучении микроконтроллеров является подключение и управление светодиодом, это самый простой и наглядный пример. Этот пример стал классическим при изучении микроконтроллеров, как программа «Hello World!» при изучении прочих языков программирования.
Максимальный ток, который способен пропустить каждый порт ввода/вывода составляет 40 mA.
Максимальный ток, который способна пропускать каждая линия порта ввода/вывода составляет 20 mA.
Прежде чем подключать нагрузку, в том числе и светодиод к линиям порта ввода/вывода нужно знать, что можно спалить микроконтроллер превысив допустимую нагрузку на линию порта ввода/вывода.
Что бы ограничить ток, который протекает через линии порта ввода/вывода микроконтроллера нужно рассчитать и подключить резистор.
Рис: Рапиновка светодиода.
Рис: Подключение светодиода анодом к микроконтроллеру.
Рис: Подключение светодиода катодом к микроконтроллеру.
Сопротивление токоограничивающего резистора подключаемого к линиям портов ввода/вывода при подключении светодиода рассчитывается по формуле:
где:
— **Vs** — напряжение источника питания;
— **Vsp** — падение напряжения на линии порта ввода/вывода;
— **Vd** — прямое падения напряжения на светодиоде;
— **Id** — прямой ток на светодиоде;
— **Кn** — коэффициент надежности роботы светодиода;
Пример:
— напряжение источника питания – **5В**;
— прямое падения напряжения на светодиоде – **2В** *(Берётся с datasheet на светодиод)*;
— прямой ток на светодиоде – **10мА** *(Берётся с datasheet на светодиод)*;
— коэффициент надежности роботы светодиода – **75%** *(Берётся с datasheet на светодиод)*;
— падение напряжения на линии порта ввода/вывода – **0,5В** *(Берётся с datasheet на микроконтроллер: Vol(output low voltage) – если ток втекает, и Voh (output high voltage) – если ток вытекает)*;
Таким образом номинал резистора **R = 166,66 Om**, подбирается ближайшее большее значение сопротивления.
Если не известно прямое напряжение светодиода, сопротивление можно рассчитать по закону Ома.
где:
— **U** — напряжение, приложенное к участку цепи;
— **I** — номинальный ток линии порта ввода/вывода.
Пример:
— напряжение, приложенное к участку цепи – **4,5В**;
— номинальный ток линии порта ввода/вывода – **20мА**.
Определив номинал резистора **R**, необходимо рассчитать мощность **P**, измеряемая в ваттах, которая будет выделяться в резисторе, в виде тепла при протекании тока в цепи.
где:
— **U** – напряжение, приложенное к участку цепи;
— **I** — номинальный ток линии порта ввода/вывода.
Пример:
— напряжение, приложенное к участку цепи – **4,5В**;
— прямой ток на светодиоде – **20мА**.
Рассчитав выделяемую мощность на резисторе, выбираем ближайшее большее значение мощности резистора. Если рассеиваемой мощности резистора будет недостаточной, то он может выйти из строя.
***— подключения маломощного светодиода анодом к линии порта ввода/вывода:***
```
// Подключаем внешние библиотеки
#include
#include
// Основная программа
int main(void)
{
// Настраиваем порты ввода/вывода
DDRC = 0b11111111; //Настраиваем все разрады порта С на режим "Выход"
PORTC = 0b11111111; //Устанавливаем все разряды порта C в лог.«1» (Навыходе порта напряжение равное Vcc)
// Вечный цикл
while (1)
{
}
}
```
***— подключения маломощного светодиода катодом к линии порта ввода/вывода:***
```
// Подключаем внешние библиотеки
#include
#include
// Основная программа
int main(void)
{
// Настраиваем порты ввода/вывода
DDRC = 0b11111111; //Настраиваем все разряды порта С на режим "Выход"
PORTC = 0b00000000; //Устанавливаем все разряды порта C в лог.«0» (На выходе порта напряжение равное GND)
// Вечный цикл
while (1)
{
}
}
```
***— подключения маломощного светодиода анодом и катодом к линии порта ввода/вывода:***
```
// Подключаем внешние библиотеки
#include
#include
// Основная программа
int main(void)
{
// Настраиваем порты ввода/вывода
DDRD = 0b11111111; //Настраиваем все разряды порта D на режим "Выход"
PORTD = 0b11111111; //Устанавливаем все разряды порта D в лог.«1» (На выходе порта напряжение равное Vcc)
DDRC = 0b11111111; //Настраиваем все разряды порта C на режим "Выход"
PORTC = 0b00000000; //Устанавливаем все разряды порта C в лог.«0» (На выходе порта напряжение равное GND)
// Вечный цикл
while (1)
{
}
}
``` | https://habr.com/ru/post/253961/ | null | ru | null |
# Робот-тележка на ROS. Часть 8. Управляем с телефона-ROS Control, GPS-нода
Продолжение цикла статей.
Посты серии:
[8. Управляем с телефона-ROS Control, GPS-нода](https://habr.com/ru/post/474650/)
[7. Локализация робота: gmapping, AMCL, реперные точки на карте помещения](https://habr.com/ru/post/472984/)
[6. Одометрия с энкодеров колес, карта помещения, лидар](https://habr.com/ru/post/471028/)
[5. Работаем в rviz и gazebo: xacro, новые сенсоры.](https://habr.com/ru/post/467665/)
[4. Создаем симуляцию робота, используя редакторы rviz и gazebo.](https://habr.com/ru/post/467241/)
[3. Ускоряемся, меняем камеру, исправляем походку](https://habr.com/ru/post/463147/)
[2. Софт](https://habr.com/ru/post/461131/)
[1. Железо](https://habr.com/ru/post/460755/)
При построении карт на роботе в рамках ограниченного пространства проблем не возникает. Управляя роботом с клавиатуры со станции-управления или на самом роботе, можно визуально наблюдать его перемещения и вовремя избегать нежелательные препятствия. Ситуация осложняется, если помещений несколько. И здесь есть несколько вариантов как наблюдать за роботом, строящим карту, если он покинул помещение оператора:
— подключить к непосредственно к роботу камеру;
— воспользоваться существующей системой видеонаблюдения вне робота;
— управлять с wi-fi, bluetooth клавиатуры, находясь рядом с роботом
— «поносить робота на руках», чтобы лидар собрал данные;
— поуправлять роботом с телефона.
Последний вариант может показаться удобным. Управлять роботом с телефона, просто наклоняя его (телефон) в нужную сторону, пока робото строит карту. Такая миссия возможна.
Рассмотрим как порулить роботом с телефона, отправляя соответствующие сообщения в топики ROS на роботе.
Писать отдельное приложение на телефоне для заявленных целей нет необходимости. Чтобы воспользоваться уже существующими наработками достаточно скачать на телефон и установить android приложение с маркета — «ROS Control».
### Настроим приложение ROS Control на телефоне.
Приложение интуитивно понятно — знаком "+" добавляется робот, задается его ip:
**картинка**
Далее выбираем «Show advanced options» и прописываем топики для робота-тележки:
**картинка**
**картинка**
В эти топики будут улетать сообщения с телефона, а также приниматься в формате, который понимает ROS.
В приложении нам доступны топики:
— joystick topic — управление с телефона;
— laser scan topic — данные с лидара;
— nav sat topic — данные gps робота;
— odom — одометрия (все, что туда попадает с энкодеров и/или imu и/или лидара);
— pose — «позиция», расположение робота.
### Освоим joystick topic.
Сам по себе робот не поедет, поэтому запустим на роботе топик с драйвером движения, который неоднократно уже фигурировал в предыдущих постах:
1-й терминал:
`rosrun rosbots_driver part2_cmr.py`
На телефоне в приложении ROS Control нажмем на строку с названием робота и провалимся в меню управления роботом:
**картинка**
Теперь, если потянуть пальцем джойстик (в любом направлении) тележка поедет.Здесь все просто.
Если посмотреть, что происходит с топиком драйвера двигателя, запущенном на raspberry, то увидим, что телефон публикует, а драйвер принимает сообщения в соответствующем формате:
По такому же принципу работают все остальные топики.
\*Если все же, что-то пошло не так, то необходимо, находясь в режиме управления роботом, нажать на три параллельные полоски слева вверху экрана приложения. Провалиться в «Preferences» и далее выбрать «Topics»:
**картинка**
**картинка**
Далее, нажимая на соответствующий топик, прописать пути (Value):
**картинка**
### Посмотрим, что представляет из себя лидар в приложении.
На роботе запустим ноду-лидар:
`roslaunch rplidar_ros rplidar.launch`
Если перезайти в приложение, то на экране управления роботом увидим характерные точки и синюю стрелку:
**картинка**
\*Можно также поездить просто наклоняя телефон в разные стороны и выбрав режим управления (Control Mode) Tilt:
**картинка**
Существуют и другие режимы «езды», даже с возможностью указать точку на карте, прямо на телефоне, но так как карта весьма условна, так же условна будет и поездка, то есть в никуда.
### C топиками движения, как и камеры (ее рассматривать не будем) все более-менее понятно, разберемся с gps.
В помещении от gps толку мало, но посмотреть как он работает, интересно.
Для тестов подойдет любой gps-свисток. Мой вариант следующий —
**картинка**
Чтобы все заработало, надо для начала установить ноду gps на raspberry.
Но для начала проверим, работает ли gps-свисток, иначе все остальные разговоры будут в пользу бедных.
Поставим пакеты на raspberry:
`sudo apt-get install gpsd
sudo apt-get install gpsd-clients`
Проверим, что gps-свисток определился среди устройств usb:
`lsusb`
Теперь, проверим, что gps что-то принимает:
`gpscat -s 9600 /dev/ttyACM1`
\*Вместо ttyACM1 могут быть иные значения (ttyACM0, ttyUSB0, ttyAMA0) в зависимости, на какой порту gps-свисток.
В терминал посыпятся сообщения gps:
**картинка**
Более структурированные (приятные глазу) данные можно получить так:
`gpsmon /dev/ttyACM1`
**картинка**
\*координаты не мои, что странно. Пока не ясно, с чем это связано.
Установим ноду gps на raspberry:
`sudo apt-get install libgps-dev
cd catkin_ws/src
git clone https://github.com/ros-drivers/nmea_navsat_driver
git clone https://github.com/ros/roslint
cd /home/pi/rosbots_catkin_ws
catkin_make`
Теперь, когда собрали gps-ноду, запустим ее (на роботе):
`rosrun nmea_navsat_driver nmea_serial_driver _port:=/dev/ttyACM1 _baud:=9600`
Если взглянуть на топики (в другом терминале робота), то можно увидеть, что телефон подписан на один топик, а публикация gps-ноды идет в другой:
**картинка**
Поменяем принимающий топик на телефоне на топик /fix через настройки как было указано выше.
После изменения публикация и прием в одном топике:
**картинка**
А на телефоне можно наблюдать координаты:
**картинка**
### Одометрия (топик /odom).
Если запустить ноду одометрии из предыдущих постов то, при движении робота, можно получить на телефоне также линейную и угловую скорости робота (скорости рассчитываются не с помощью gps).
На роботе:
`cd /home/pi/rosbots_catkin_ws/src/rosbots_driver/scripts/rosbots_driver
python diff_tf.py`
На телефоне:
**картинка** | https://habr.com/ru/post/474650/ | null | ru | null |
# Оптимизация сборки мусора в высоконагруженном .NET сервисе
Ежедневно в сервисе Pyrus работают десятки тысяч сотрудников из нескольких тысяч организаций по всему миру. Отзывчивость сервиса (скорость обработки запросов) мы считаем важным конкурентным преимуществом, так как она напрямую влияет на впечатление пользователей. Ключевой метрикой для нас является «процент медленных запросов». Изучая ее поведение, мы заметили, что раз в минуту на серверах приложений возникают паузы длиной около 1000 мс. В эти промежутки сервер не отвечает и возникает очередь из нескольких десятков запросов. О поиске причин и устранении узких мест, вызванных сборкой мусора в приложении, пойдет речь в этой статье.
Современные языки программирования можно разделить на две группы. В языках типа C/C++ или Rust используется ручное управление памятью, поэтому программисты тратят больше времени на написание кода, управление временем жизни объектов, а затем на отладку. При этом баги из-за неправильного использования памяти — одни из самых сложных в отладке, поэтому большинство современной разработки ведется на языках с автоматическим управлением памятью. К ним относятся, например, Java, C#, Python, Ruby, Go, PHP, JavaScript, и.т.д. Программисты экономят время разработки, но за это приходится платить дополнительным временем выполнения, которое программа регулярно тратит на сборку мусора — освобождение памяти, занятой объектами, на которые в программе не осталось ссылок. В небольших программах это время ничтожно, однако по мере роста числа объектов и интенсивности их создания сборка мусора начинает давать заметный вклад в общее время выполнения программы.
Веб-серверы Pyrus работают на платформе .NET, где используется автоматическое управление памятью. Большинство сборок мусора — блокирующие ('stop the world'), т.е. на время своей работы останавливают все потоки (threads) приложения. Неблокирующие (фоновые) сборки на самом деле тоже останавливают все потоки, но на очень короткий период времени. Во время блокировки потоков сервер не обрабатывает запросы, имеющиеся запросы подвисают, новые складываются в очередь. В результате напрямую замедляются запросы, которые обрабатывались в момент сборки мусора, также медленнее выполняются запросы сразу по окончании сборки мусора из-за накопившихся очередей. Это ухудшает метрику «процент медленных запросов».
Вооружившись недавно вышедшей книгой [Konrad Kokosa: Pro .NET Memory Management](https://www.amazon.com/Pro-NET-Memory-Management-Performance/dp/148424026X) (о том, как мы за 2 дня привезли в Россию ее первый экземпляр, можно написать отдельный пост), целиком посвященной теме управления памятью в .NET, мы начали исследование проблемы.
Измерение
---------
Для профилирования веб-сервера Pyrus мы воспользовались утилитой PerfView (<https://github.com/Microsoft/perfview>), заточенной под профилирование .NET приложений. Утилита основана на механизме Event Tracing for Windows (ETW) и имеет минимальное влияние на производительность профилируемого приложения, что позволяет использовать ее на боевом сервере. Кроме того, влияние на производительность зависит от того, какие виды событий и какую информацию мы собираем. Не собираем ничего — приложение работает как обычно. Также PerfView не требует ни перекомпиляции, ни перезапуска приложения.
Запустим трассировку PerfView с параметром /GCCollectOnly (время трассировки 1.5 часа). В этом режиме он собирает только события сборок мусора и оказывает минимальное влияние на производительность. Посмотрим на отчет трассировки Memory Group / GCStats, а в нем на сводку событий сборщика мусора:
Тут мы видим сразу несколько интересных показателей:
* Среднее время паузы сборки во 2-м поколении — 700 миллисекунд, а максимальная пауза около секунды. Данная цифра показывает время, на которое останавливаются все потоки в .NET приложении, в частности во все обрабатываемые запросы добавится эта пауза.
* Количество сборок 2-го поколения сравнимо с 1-м поколением и ненамного меньше количества сборок 0-го поколения.
* В столбце Induced указано 53 сборки во 2-м поколении. Induced-сборка — это результат явного вызова GC.Collect(). В нашем коде мы не нашли ни одного вызова этого метода, значит, виновата какая-то из используемых нашим приложением библиотек.
Поясним наблюдение про количество сборок мусора. Идея разделить объекты по времени их жизни основана на гипотезе о поколениях ([generational hypothesis](https://www.quora.com/What-is-the-generational-hypothesis-in-the-context-of-garbage-collection)): значительная часть создаваемых объектов умирает быстро, а большинство остальных живут долго (другими словами, мало объектов, имеющих «среднее» время жизни). Именно под этот режим и заточен сборщик мусора .NET, и в этом режиме сборок второго поколения должно быть гораздо меньше, чем 0-го поколения. То есть, для оптимальной работы сборщика мусора мы должны подгонять работу нашего приложения под гипотезу о поколениях. Сформулируем правило так: объекты должны либо умирать быстро, не доживая до старшего поколения, либо доживать до него и жить там вечно. Это правило применяется и для других платформ, где используется автоматическое управление памятью с разделением по поколениям, например, таким как Java.
Интересные для нас данные можно извлечь из другой таблицы в отчете GCStats:
Здесь перечислены случаи, когда приложение пытается создать большой объект (в .NET Framework объекты размером > 85000 байт создаются в LOH — Large Object Heap), и ему приходится ждать окончания сборки 2-го поколения, которая происходит параллельно в фоне. Эти паузы аллокатора не настолько критичны, как паузы сборщика мусора, так как они влияют только на один поток. До этого мы использовали версию .NET Framework 4.6.1, а в версии 4.7.1 Microsoft доработали сборщик мусора, теперь он позволяет выделять память в Large Object Heap во время фоновой сборки 2-го поколения: <https://docs.microsoft.com/ru-ru/dotnet/framework/whats-new/#common-language-runtime-clr>
Поэтому мы обновились до последней на тот момент версии 4.7.2.
Сборки 2-го поколения
---------------------
Почему же у нас так много сборок старшего поколения? Первое предположение — мы имеем утечку памяти. Для проверки этой гипотезы посмотрим на размер второго поколения (мы настроили в Zabbix мониторинг соответствующих счетчиков производительности). Из графиков размера 2-го поколения для 2-х серверов Pyrus видно, что его размер сначала растет (в основном из-за заполнения кэшей), но затем стабилизируется (большие провалы на графике — штатный перезапуск веб-сервиса для обновления версии):
Это означает, что нет заметных утечек памяти, то есть, большое количество сборок 2-го поколения возникает по другой причине. Следующая гипотеза — большой трафик памяти, т.е., во 2-е поколение попадает много объектов, и много объектов там умирает. Для нахождения таких объектов в PerfView имеется режим /GCOnly. Из отчетов трассировки обратим внимание на 'Gen 2 Object Deaths (Coarse Sampling) Stacks', который содержит выборку объектов, умирающих во 2-м поколении, вместе со стеками вызовов мест, где эти объекты были созданы. Тут мы видим следующие результаты:
Раскрыв строку, внутри мы видим стек вызовов тех мест в коде, которые создают объекты, доживающие до 2-го поколения. Среди них:
* System.Byte[] Если заглянуть внутрь, то мы увидими, что больше половины — это буферы для сериализации в JSON:
* Slot[System.Int32][] (это часть реализации HashSet), System.Int32[], и т.д. Это наш код, который вычисляет клиентские кэши — те справочники, формы, списки, друзей и т.п., которых видит данный пользователь, и которые кэшируются у него в браузере или в мобильном приложении:
Интересно, что буферы для JSON и для вычисления клиентских кэшей — это всё временные объекты, которые живут в течение одного запроса. Почему же они доживают до 2-го поколения? Обратим внимание, что все эти объекты — массивы достаточно большого размера. А при размере > 85000 байт память под них выделяется в Large Object Heap, которая собирается только вместе со 2-ым поколением.
Для проверки откроем в результатах perfview /GCOnly раздел 'GC Heap Alloc Ignore Free (Coarse Sampling) stacks'. Там мы видим строку LargeObject, в которой PerfView группирует создание больших объектов, а внутри мы увидим все те же самые массивы, которые мы видели в предшествующем анализе. Мы подтверждаем основную причину проблем со сборщиком мусора: мы создаем много временных больших объектов.
Изменения в системе Pyrus
-------------------------
По результатам измерений мы выделили основные направления дальнейшей работы: борьба с большими объектами при вычислении клиентских кэшей и сериализации в JSON. Есть несколько вариантов решения этой проблемы:
* Самое простое — не создавать больших объектов. Например, если большой буфер B используется в последовательных преобразованиях данных A->B->C, то иногда эти преобразования можно объединить, превратив в A->C, и избавившись от создания объекта B. Этот вариант не всегда применим, но при этом он самый простой и эффективный.
* Пул объектов. Вместо того, чтобы постоянно создавать новые объекты и выкидывать, нагружая сборщик мусора, мы можем хранить коллекцию свободных объектов. В простейшем случае, когда нам нужен новый объект, то мы берем его из пула, или создаем новый, если пул пустой. Когда объект нам больше не нужен, мы возвращаем его в пул. Хороший пример — ArrayPool в .NET Core, который также доступен в .NET Framework в составе Nuget-пакета System.Buffers.
* Использовать вместо больших объектов маленькие.
Рассмотрим по отдельности оба случая больших объектов — вычисление клиентских кэшей и сериализацию в JSON.
Вычисление клиентских кэшей
---------------------------
Web-клиент и мобильные приложения Pyrus кэшируют данные, доступные пользователю (проекты, формы, пользователи, и т.п.) Кэширование используется для ускорения работы, также оно необходимо для работы в оффлайн-режиме. Кэши вычисляются на сервере и передаются на клиент. Они индивидуальны для каждого пользователя, так как зависят от его прав доступа, и достаточно часто обновляются, например, при изменении справочников, к которым он имеет доступ.
Таким образом, на сервере регулярно происходит много вычислений клиентских кэшей, при этом создается много временных короткоживущих объектов. Если пользователь состоит в большой организации, то он может получить доступ к многим объектам, соответственно клиентские кэши для него будут большими. Именно поэтому мы видели выделение памяти под большие временные массивы в Large Object Heap.
Проанализируем предложенные варианты избавления от создания больших объектов:
* Полное избавление от больших объектов. Этот подход неприменим, так как в алгоритмах подготовки данных используются среди прочего сортировка и объединение множеств, а для них требуются временные буферы.
* Использование пула объектов. У этого подхода есть сложности:
+ Разнообразие используемых коллекций и типов элементов в них: используются HashSet, List и Array (2 последних можно объединить). В коллекциях хранятся Int32, Int64, а также всевозможные классы данных. Для каждого используемого типа понадобится свой пул, который к тому же будет хранить коллекции разных размеров.
+ Сложное время жизни коллекций. Чтобы получить преимущества от пула, объекты в него придется возвращать после использования. Это можно сделать, если объект используется в одном методе. Но в нашем случае ситуация сложнее, так как многие большие объекты путешествуют между методами, кладутся в структуры данных, перекладываются в другие структуры, и т.д.
+ Реализация. Есть ArrayPool от Microsoft, но нам нужны еще List и HashSet. Мы не нашли какой-нибудь подходящей библиотеки, поэтому классы пришлось бы реализовывать самим.
* Использование маленьких объектов. Большой массив можно разбить на несколько маленьких кусочков, которые не буду нагружать Large Object Heap, а будут создаваться в 0-м поколении, а дальше идти стандартным путем в 1-е и 2-е. Мы надеемся, что они не доживут до 2-го, а будут собраны сборщиком мусора в 0-м, или в крайнем случае в 1-м поколении. Плюс этого подхода в том, что изменения имеющегося кода минимальные. Сложности:
+ Реализация. Мы не нашли подходящих библиотек, поэтому классы пришлось бы писать самим. Отсутствие библиотек объяснимо, так как сценарий «коллекции, не нагружающие Large Object Heap» — это очень узкая область применения.
Мы решили пойти по 3-му пути и изобрести свой велосипед написать List и HashSet, не нагружающие Large Object Heap.
Кусочный список
---------------
Наш ChunkedList реализует стандартные интерфейсы, включая IList, благодаря этому требуются минимальные изменения имеющегося кода. Да и используемая нами библиотека Newtonsoft.Json автоматически умеет его сериализовывать, так как он реализует IEnumerable :
```
public sealed class ChunkedList : IList, ICollection, IEnumerable, IEnumerable, IList, ICollection, IReadOnlyList, IReadOnlyCollection
{
```
У стандартного списка List имеются следующие поля: массив для элементов и количество заполненных элементов. В ChunkedList имеется массив массивов элементов, количество полностью заполненных массивов, количество элементов в последнем массиве. Каждый из массивов элементов при этом которых меньше 85000 байт:
```
private T[][] chunks;
private int currentChunk;
private int currentChunkSize;
```
Так как ChunkedList устроен довольно сложно, то на него мы написали подробные тесты. Любую операцию нужно тестировать как минимум в 2-х режимах: в «маленьком», когда весь список умещается в один кусок размером до 85000 байт, и «большом», когда он состоит более, чем из одного куска. При этом для методов, изменяющих размер (например, Add), сценариев еще больше: «маленький» -> «маленький», «маленький» -> «большой», «большой» -> «большой», «большой» -> «маленький». Тут возникает довольно много запутанных граничных случаев, с которыми хорошо справляются юнит-тесты.
Ситуация упрощается тем, что часть методов из интерфейса IList не используются, и их можно не реализовывать (такие, как Insert, Remove). Их реализация и тестирование были бы довольно накладными. Кроме того, написание юнит-тестов упрощается тем, что нам не нужно придумывать новый функционал, ChunkedList должен вести себя так же, как и List. То есть все тесты устроены так: создаем List и ChunkedList, проводим над ними одинаковые операции и сравниваем результаты.
Мы провели замер производительности с помощью библиотеки BenchmarkDotNet, чтобы убедиться, что мы не сильно замедлим наш код при переходе с List на ChunkedList. Протестируем, например, добавление элементов в список:
```
[Benchmark]
public ChunkedList ChunkedList()
{
var list = new ChunkedList();
for (int i = 0; i < N; i++)
list.Add(i);
return list;
}
```
И такой же тест с использованием List для сравнения. Результаты при добавлении 500 элементов (все помещается в один массив):
| | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Method | Mean | Error | StdDev | Gen 0/1k Op | Gen 1/1k Op | Gen 2/1k Op | Allocated Memory/Op |
| StandardList | 1.415 us | 0.0149 us | 0.0140 us | 0.6847 | 0.0095 | - | 4.21 KB |
| ChunkedList | 3.728 us | 0.0238 us | 0.0222 us | 0.6943 | 0.0076 | - | 4.28 KB |
Результаты при добавлении 50000 элементов (разбивается на несколько массивов):
| | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Method | Mean | Error | StdDev | Gen 0/1k Op | Gen 1/1k Op | Gen 2/1k Op | Allocated Memory/Op |
| StandardList | 146.273 us | 3.1466 us | 4.8053 us | 124.7559 | 124.7559 | 124.7559 | 513.23 KB |
| ChunkedList | 287.687 us | 1.4630 us | 1.2969 us | 41.5039 | 20.5078 | - | 256.75 KB |
**Подробное описание колонок в результатах**
```
BenchmarkDotNet=v0.11.4, OS=Windows 10.0.17763.379 (1809/October2018Update/Redstone5)
Intel Core i7-8700K CPU 3.70GHz (Coffee Lake), 1 CPU, 12 logical and 6 physical cores
[Host] : .NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.3324.0
DefaultJob : .NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.3324.0
// * Hints *
Outliers
ListAdd.StandardList: Default -> 2 outliers were removed
ListAdd.ChunkedList: Default -> 1 outlier was removed
// * Legends *
Mean : Arithmetic mean of all measurements
Error : Half of 99.9% confidence interval
StdDev : Standard deviation of all measurements
Gen 0/1k Op : GC Generation 0 collects per 1k Operations
Gen 1/1k Op : GC Generation 1 collects per 1k Operations
Gen 2/1k Op : GC Generation 2 collects per 1k Operations
Allocated Memory/Op : Allocated memory per single operation (managed only, inclusive, 1KB = 1024B)
1 us : 1 Microsecond (0.000001 sec)
```
Если посмотреть на столбец 'Mean', в котором отображено среднее время выполнения теста, видно, что наша реализация медленнее стандартной всего в 2-2.5 раза. С учетом того, что в реальном коде операции со списками — лишь малая часть всех выполняемых действий, эта разница становится несущественной. Зато столбец 'Gen 2/1k op' (количество сборок 2-го поколения за 1000 выполнений теста) показывает, что мы добились цели: при большом количестве элементов ChunkedList не создает мусора во 2-м поколении, что и было нашей задачей.
Кусочное множество
------------------
Аналогично ChunkedHashSet реализует интерфейс ISet. При написании ChunkedHashSet мы повторно использовали логику разбиения на небольшие куски, уже реализованную в ChunkedList. Для этого мы взяли готовую реализацию HashSet из .NET Reference Source, доступного по лицензии MIT, и заменили в ней массивы на ChunkedList-ы.
В юнит тестах тоже воспользуемся тем же трюком, что и для списков: будем сравнивать поведение ChunkedHashSet с эталонным HashSet.
Наконец, тесты производительности. Основная операция, которую мы используем — объединение множеств, поэтому именно ее мы и протестируем:
```
public ChunkedHashSet ChunkedHashSet(int[][] source)
{
var set = new ChunkedHashSet();
foreach (var arr in source)
set.UnionWith(arr);
return set;
}
```
И точно такой же тест для стандартного HashSet. Первый тест для небольших множеств:
```
var source = new int[][] {
Enumerable.Range(0, 300).ToArray(),
Enumerable.Range(100, 600).ToArray(),
Enumerable.Range(300, 1000).ToArray(),
}
```
| | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Method | Mean | Error | StdDev | Gen 0/1k Op | Gen 1/1k Op | Gen 2/1k Op | Allocated Memory/Op |
| StandardHashSet | 30.16 us | 0.1046 us | 0.0979 us | 9.3079 | 1.6785 | - | 57.41 KB |
| ChunkedHashSet | 73.54 us | 0.5919 us | 0.5247 us | 9.5215 | 1.5869 | - | 58.84 KB |
Второй тест для больших множеств, которые вызывали проблему с кучей больших объектов:
```
var source = new int[][] {
Enumerable.Range(0, 30000).ToArray(),
Enumerable.Range(10000, 60000).ToArray(),
Enumerable.Range(30000, 100000).ToArray(),
}
```
| | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Method | Mean | Error | StdDev | Gen 0/1k Op | Gen 1/1k Op | Gen 2/1k Op | Allocated Memory/Op |
| StandardHashSet | 3,031.30 us | 32.0797 us | 28.4378 us | 699.2188 | 667.9688 | 664.0625 | 4718.23 KB |
| ChunkedHashSet | 7,189.66 us | 25.6319 us | 23.9761 us | 539.0625 | 265.6250 | 7.8125 | 3280.71 KB |
Результаты схожи со списками. ChunkedHashSet медленнее в 2-2.5 раза, но при этом на больших множествах нагружает 2-е поколение на 2 порядка меньше.
Сериализация в JSON
-------------------
Веб-сервер Pyrus предоставляет несколько API, в которых используется разная сериализация. Мы обнаружили создание больших объектов в API, используемом ботами и утилитой синхронизации (далее Public API). Заметим, что в основном API используется собственная сериализация, которая не подвержена данной проблеме. Мы об этом писали в статье <https://habr.com/ru/post/227595/>, в разделе «2. Вы не знаете, где узкое место вашего приложения». То есть, основной API уже работает хорошо, а проблема проявилась в Public API по мере роста количества запросов и объемов данных в ответах.
Займемся оптимизацией Public API. На примере основного API мы знаем, что можно возвращать ответ пользователю в потоковом режиме. То есть, нужно не создавать промежуточные буферы, содержащие ответ целиком, а писать сразу ответ в поток (stream).
При ближайшем рассмотрении мы выяснили, что в процессе сериализации ответа мы создаем временный буфер для промежуточного результата ('content' — массив байтов, содержащий JSON в кодировке UTF-8):
```
var serializer = Newtonsoft.Json.JsonSerializer.Create(...);
byte[] content;
var sw = new StreamWriter(new MemoryStream(), new UTF8Encoding(false));
using (var writer = new Newtonsoft.Json.JsonTextWriter(sw))
{
serializer.Serialize(writer, result);
writer.Flush();
content = ms.ToArray();
}
```
Проследим, где используется content. По историческим причинам Public API основан на WCF, для которого стандартным форматом запросов и ответов является XML. В нашем случае в XML-ответе имеется единственный элемент 'Binary', внутри которого записан JSON, закодированный в Base64:
```
public class RawBodyWriter : BodyWriter
{
private readonly byte[] _content;
public RawBodyWriter(byte[] content)
: base(true)
{
_content = content;
}
protected override void OnWriteBodyContents(XmlDictionaryWriter writer)
{
writer.WriteStartElement("Binary");
writer.WriteBase64(_content, 0, _content.Length);
writer.WriteEndElement();
}
}
```
Заметим, что временный буфер здесь не нужен. JSON можно писать сразу в буфер XmlWriter, который нам предоставляет WCF, на лету кодируя его в Base64. Таким образом, мы пойдем по первому пути, избавившись от выделения памяти:
```
protected override void OnWriteBodyContents(XmlDictionaryWriter writer)
{
var serializer = Newtonsoft.Json.JsonSerializer.Create(...);
writer.WriteStartElement("Binary");
Stream stream = new Base64Writer(writer);
Var sw = new StreamWriter(stream, new UTF8Encoding(false));
using (var jsonWriter = new Newtonsoft.Json.JsonTextWriter(sw))
{
serializer.Serialize(jsonWriter, _result);
jsonWriter.Flush();
}
writer.WriteEndElement();
}
```
Здесь Base64Writer — это простая обертка над XmlWriter, реализующая интерфейс Stream, которая пишет в XmlWriter в виде Base64. При этом из всего интерфейса достаточно реализовать только один метод Write, который вызывается в StreamWriter:
```
public class Base64Writer : Stream
{
private readonly XmlWriter _writer;
public Base64Writer(XmlWriter writer)
{
_writer = writer;
}
public override void Write(byte[] buffer, int offset, int count)
{
_writer.WriteBase64(buffer, offset, count);
}
<...>
}
```
Induced GC
----------
Попробуем разобраться с загадочными индуцированными сборками мусора. Мы 10 раз перепроверили наш код на наличие вызовов GC.Collect, но это не дало результатов. Удалось поймать эти события в PerfView, но стек вызовов не особо показателен (событие DotNETRuntime/GC/Triggered):
Есть маленькая зацепка — вызов RecycleLimitMonitor.RaiseRecycleLimitEvent перед индуцированной сборкой мусора. Проследим стек вызовов метода RaiseRecycleLimitEvent:
```
RecycleLimitMonitor.RaiseRecycleLimitEvent(...)
RecycleLimitMonitor.RecycleLimitMonitorSingleton.AlertProxyMonitors(...)
RecycleLimitMonitor.RecycleLimitMonitorSingleton.CollectInfrequently(...)
RecycleLimitMonitor.RecycleLimitMonitorSingleton.PBytesMonitorThread(...)
```
Названия методов вполне соответствуют их функциям:
* В конструкторе RecycleLimitMonitor.RecycleLimitMonitorSingleton создается таймер, с определенным интервалом вызывающий PBytesMonitorThread.
* PBytesMonitorThread собирает статистику по использованию памяти и при каких-то условиях вызывает CollectInfrequently.
* CollectInfrequently вызывает AlertProxyMonitors, получает в результате bool, и вызывает GC.Collect(), если получает true. Также он следит за временем, прошедшим с прошлого вызова сборщика мусора, и не вызывает его слишком часто.
* AlertProxyMonitors проходит по списку запущенных IIS веб-приложений, для каждого поднимает соответствующий объект RecycleLimitMonitor, и вызывает RaiseRecycleLimitEvent.
* RaiseRecycleLimitEvent поднимает список IObserver. Обработчики получают в качестве параметра RecycleLimitInfo, в котором они могут установить флаг RequestGC, который и возвращается в CollectInfrequently, вызывая индуцированную сборку мусора.
Дальнейшее расследование показывает, обработчики IObserver добавляются в методе RecycleLimitMonitor.Subscribe(), который вызывается в методе AspNetMemoryMonitor.Subscribe(). Также в классе AspNetMemoryMonitor вешается обработчик IObserver по умолчанию (класс RecycleLimitObserver), который чистит кэши ASP.NET, и иногда запрашивает сборку мусора.
Загадка Induced GC почти разгадана. Осталось выяснить вопрос, для чего вызывается эта сборка мусора. RecycleLimitMonitor следит за использованием памяти IIS (точнее, за цифрой private bytes), и когда ее использование приближается к определенному пределу, начинает по довольно запутанному алгоритму вызывать событие RaiseRecycleLimitEvent. В качестве предела памяти используется значение AspNetMemoryMonitor.ProcessPrivateBytesLimit, а в нем в свою очередь находится следующая логика:
* Если для Application Pool в IIS настроено значение 'Private Memory Limit (KB)', то значение в килобайтах берется оттуда
* Иначе для 64-битных систем берется 60% физической памяти (для 32-битных логика сложнее).
Вывод расследования такой: ASP.NET по использованию памяти приближается к своему пределу и начинает регулярно вызывать сборку мусора. Для 'Private Memory Limit (KB)' не было установлено значение, поэтому ASP.NET ограничивался 60% от физической памяти. Проблема маскировалась тем, что на сервере Task Manager показывал много свободной памяти и казалось, что ее хватает. Мы повысили значение 'Private Memory Limit (KB)' в настройках Application Pool в IIS до 80% от физической памяти. Это стимулирует ASP.NET использовать больше имеющейся памяти. Также мы добавили мониторинг счетчика производительности '.NET CLR Memory / # Induced GC', чтобы не пропустить, когда в следующий раз ASP.NET решит, что он приближается к пределу использования памяти.
Повторные измерения
-------------------
Посмотрим, что же произошло со сборками мусора после всех этих изменений. Начнем с perfview /GCCollectOnly (время трассировки — 1 час), отчет GCStats:
Видно, что сборок 2-го поколения теперь на 2 порядка меньше, чем 0-го и 1-го. Также, время этих сборок уменьшились. Индуцированных сборок больше не наблюдается. Посмотрим на список сборок 2-го поколения:
Из столбца Gen видно, что все сборки 2-го поколения стали фоновыми ('2B' означает 2-е поколение, Background). То есть, большая часть работы выполняется параллельно с выполнением приложения, а все потоки блокируются ненадолго (столбец 'Pause MSec'). Посмотрим на паузы при создании больших объектов:
Видно, что количество таких пауз при создании больших объектов упало в разы.
Итоги
-----
Благодаря описанным в статье изменениям удалось значительно снизить количество и продолжительность сборок 2-го поколения. Удалось найти причину индуцированных сборок, и избавиться от них. Увеличилось количество сборок 0-го и 1-го поколения, но при этом уменьшилась их средняя продолжительность (с ~200 мсек до ~60 мсек). Максимальная продолжительность сборок 0-го и 1-го поколений уменьшилась, но не так заметно. Сборки 2-го поколения стали быстрее, длинные паузы до 1000мс полностью ушли.
Что касается ключевой метрики — «процент медленных запросов», она уменьшилась на 40% после всех изменений.
Благодаря проведенной работе мы поняли, какие счетчики производительности нужны для оценки ситуации с памятью и сборкой мусора, добавив их в Zabbix для постоянного мониторинга. Вот список самых важных, на которые мы обращаем внимание, и выясняем причину (например, повышенный поток запросов, большой объем передаваемых данных, баг в приложении):
| | | |
| --- | --- | --- |
| Счетчик производительности | Описание | Когда стоит обратить внимание |
| \Process(\*)\Private Bytes | Количество памяти, выделенной для приложения | Значения сильно превышают порог. В качестве порога можно взять медиану за 2 недели от максимальных дневных показателей. |
| \.NET CLR Memory(\*)\# Gen 2 Collections | Объем памяти в старшем поколении |
| \.NET CLR Memory(\*)\Large Object Heap size | Объем памяти для больших объектов |
| \.NET CLR Memory(\*)\% Time in GC | Процент времени, потраченный на сборку мусора | Значение больше 5%. |
| \.NET CLR Memory(\*)\# Induced GC | Количество индуцированных сборок | Значение больше 0. | | https://habr.com/ru/post/452298/ | null | ru | null |
# ‘Hello World’ tutorial — Ваше первое приложение на Play framework (Часть 2)
Это очень поверхностное руководство, которое только познакомит с базовым функционалом Play framework на примере создания приложения ‘Hello World’.
[(Часть 1)](http://habrahabr.ru/blogs/java/111420/)
Создание формы
==============
Начнём Наше приложение ‘Hello World’ с создания формы, где можно будет ввести имя.
Отредактируйте helloworld/app/views/Application/index.html следующим образом:
```
#{extends 'main.html' /}
#{set title:'Home' /}
```
Мы используем @ {...} обозначение для того, что бы Play автоматически сгенерировал URL на Application.sayHello. Теперь, обновите домашнюю страницу в браузере.
К сожалению, вы получите ошибку. Это потому, что вы ссылаетесь на несуществующее действие Application.sayHello. Давайте создадим его в helloworld/app/controllers/Application.java:
```
package controllers;
import play.mvc.*;
public class Application extends Controller {
public static void index() {
render();
}
public static void sayHello(String myName) {
render(myName);
}
}
```
Мы объявили myName параметр в методе sayHello, поэтому он будет автоматически заполняется значением параметра myName которое будет получено по HTTP. И мы вызываем функцию render() для отображения шаблона, которой передали myName, поэтому она будет доступна в шаблоне оформления.
Теперь, если вы попытаетесь ввести свое имя и отправить форму, вы получите другую ошибку:
Понять причину этой ошибки довольно просто. Play пытается вызвать шаблон по умолчанию для этого действия, но он не существует. Давайте создадим его helloworld/app/views/Application/sayHello.html:
```
#{extends 'main.html' /}
#{set title:'Home' /}
Hello ${myName ?: 'guest'}!
===========================
[Back to form](@{Application.index()})
```
Обновите теперь страницу.
Посмотрите, как мы использовали оператор Groovy ?:. Он переключается на значение по умолчанию, если переменная myName не заполнена. Так что если вы пытаетесь представить форму без ввода имени, он будет отображать ‘Hello guest’.
Настройка ЧПУ
=============
Если Вы посмотрите на URL созданной страницы, Вы увидите нечто вроде:
<http://localhost:9000/application/sayhello?myName=guillaume>
Это происходит потому, что Play использует маршрут по умолчанию для всех действий контроллеров:
`* /{controller}/{action} {controller}.{action}`
Мы можем задать лучший URL, указав путь для пользовательских действий Application.sayHello. Измените helloworld/conf/routes добавив после первой строки следующее:
`GET /hello Application.sayHello`
Теперь вернемся к форме и введём своё имя повторно, что бы убедиться, что всё работает.
Настройка шаблона вывода
========================
Так как шаблоны наследуют шаблон main.html, Вы можете легко изменить все шаблоны. Измените helloworld/app/views/main.html:
```
...
The Hello world app.
---
#{doLayout /}
...
```
Строка «The Hello world app.» появилась на всех страницах.
Проверка входных данных
=======================
Добавим проверку в форму. Форма должна быть заполнена перед отправкой. Для этого можем использовать Play validation framework.
Измените sayHello в helloworld/app/controllers/Application.java контроллере следующим образом:
```
...
public static void sayHello(@Required String myName) {
if(validation.hasErrors()) {
flash.error("Oops, please enter your name!");
index();
}
render(myName);
}
...
```
Не забудьте импортировать play.data.validation .\*, чтобы использовать @Required аннотацию. Play будет автоматически проверять что бы поле myName было заполнено или будет добавлять объект содержащий ошибку. Тогда, если существует какая-либо ошибка, мы добавим сообщение и перенаправим в корень сайта.
Flash объект позволяет сохранять сообщения при перенаправлении на страницу.
Теперь вы просто должны показать сообщение об ошибке, если таковые имеются. Измените helloworld/app/views/Application/index.html:
```
#{extends 'main.html' /}
#{set title:'Home' /}
#{if flash.error}
${flash.error}
#{/if}
```
Проверим как это работает:
Автоматизированное тестирование
===============================
Закончим руководство написанием теста для приложения. Так как нет логики в Java коде для проверки, нам необходимо проверить, веб-приложение. Поэтому, мы будем писать тест для Selenium.
Для начала запустим приложение в режиме тестирования. Остановите приложение и перезапустите его командой:
`$ play test`
Команда play test почти такая же, как play run, за исключением того, что дополнительно загружается модуль Test Runner, который позволяет запустить набор тестов непосредственно из браузера.
Откройте следующий адрес в браузере <http://localhost:9000/@tests>, чтобы увидеть тесты. Попробуйте выбрать все тесты по умолчанию и запускать их, все должны быть зеленого цвета… Но это стандартные тесты, которые в общем то ничего и не тестируют.
Тесты для Selenium обычно пишутся как HTML файл. Написание тестов для Selenium немного утомительно (форматирование используя элементы таблицы HTML). Хорошей новостью будет то, что Play поможет вам сгенерировать его с помощью Play template engine, который поддерживает упрощенный синтаксис для сценариев Selenium.
При создании приложения Play автоматически создал тесты, в том числе тесты для Selenium. Откройте helloworld/test/Application.test.html:
```
*{ You can use plain selenium command using the selenium tag }*
#{selenium}
// Open the home page, and check that no error occurred
open('/')
assertNotTitle('Application error')
#{/selenium}
```
Этот тест должен отработать без каких-либо проблем. Он просто открывает главную страницу и убеждается, что страницы не содержат текст 'Application error'.
Напишем тест для нашего приложения. Измените содержание теста:
```
#{selenium}
// Откроем корневую страницу и проверим, что ни каких ошибок не произошло
open('/')
assertNotTitle('Application error')
// Проверим что это форма
assertTextPresent('The Hello world app.')
// Отправим форму
clickAndWait('css=input[type=submit]')
// Проверим что произошла ошибка
assertTextPresent('Oops, please enter your name!')
// Впишем имя и отправим форму
type('css=input[type=text]', 'bob')
clickAndWait('css=input[type=submit]')
// Проверим результат
assertTextPresent('Hello bob!')
assertTextPresent('The Hello world app.')
// Вернёмся к форме
clickAndWait('link=Back to form')
// Домашняя страница?
assertTextNotPresent('Hello bob!')
#{/selenium}
```
Мы полностью протестировали приложения. Просто выберит еэтот тест в Test Runner и нажмите «Пуск». Все должно быть зелёным!
Хотите больше?
==============
Это был очень простой урок. Если вы хотите узнать больше о Play framework, читайте [«Tutorial — Play guide, a real world app step-by-step»](http://www.playframework.org/documentation/1.1/guide1). | https://habr.com/ru/post/111464/ | null | ru | null |
# Интересные способы использования Go каналов (перевод)
*Предлагаю вам перевод статьи [Gary Willoughby](http://nomad.so/author/admin/) [«Interesting ways of using Go channels»](http://nomad.so/2016/01/interesting-ways-of-using-go-channels/).*
*Статья предназначена для тех, кто уже немного разбирается в Go.*
[](https://habrahabr.ru/post/278349/)
Интересные способы использования Go каналов
-------------------------------------------
Я написал этот пост, чтобы задокументировать доклад про Go каналы Джона Грэм-Камминга на конференции GopherCon 2014. Доклад назывался «Краткое руководство по каналам» и он доступен для просмотра на [youtube.com](https://www.youtube.com/watch?v=SmoM1InWXr0).
На протяжении доклада нам представляют интересные способы использования Go каналов и раскрывают возможности и преимущества конкурентного программирования. Лично мне этот доклад открыл глаза на несколько новых способов структурирования программ и новых техник для синхронизации по нескольким ядрам процессора.
Следующие примеры демонстрируют различные техники, как использовать каналы в Go. Код был специально упрощен для их понимания. Не стоит его использовать для продакшн версий. Например, пропущены все обработки ошибок.
### Сигналы
#### Ожидание события
В этом примере горутина запускается, делает какую-то работу (в данном случае ждет 5 секунд), затем закрывает канал. Небуферизированные каналы всегда останавливают выполнение текущей горутины, пока не придет сообщение. Закрытие канала сигнализирует горутине, что она может продолжить свое выполнение, потому что больше никаких данных не может быть получено. Закрытые каналы никогда не останавливают выполнение горутины.
```
package main
import (
"fmt"
"time"
)
func main() {
c := make(chan bool)
go func() {
// ... выполняем что-нибудь
time.Sleep(time.Second * 5)
close(c)
}()
// Останавливает выполнение до получения сообщения из канала или его закрытия.
<-c
fmt.Println("Done")
}
```
#### Координирование нескольких горутин
В этом примере сотня горутин запускается, ждет передачи данных через канал start (или его закрытия). В случае, когда он будет закрыт, все горутины запустятся.
```
package main
func worker(start chan bool) {
<-start
// ... выполняем что-нибудь
}
func main() {
start := make(chan bool)
for i := 0; i < 100; i++ {
go worker(start)
}
close(start)
// ... все worker's запустятся сейчас
}
```
#### Скоординированное прекращение worker’ов
В этом примере, сотня горутин запускается, ждет передачи данных через канал die (или его закрытия). В случае, когда он будет закрыт, все горутины прекратят выполнение.
```
package main
func worker(die chan bool) {
for {
select {
// ... выполняем что-нибудь в других case
case <-die:
return
}
}
}
func main() {
die := make(chan bool)
for i := 0; i < 100; i++ {
go worker(die)
}
// Остановить всех worker'ов.
close(die)
}
```
#### Проверка прекращения работы worker’ов
В этом примере горутина запускается, ждет передачи данных от канала die (или его закрытия). В случае, когда придет сигнал, горутина выполнит завершающие действия и пошлет сигнал в функцию main (через этот же канал die) о том, что она завершена.
```
package main
func worker(die chan bool) {
for {
select {
// ... выполняем что-нибудь в других case
case <-die:
// ... выполняем необходимые действия перед завершением.
die <- true
return
}
}
}
func main() {
die := make(chan bool)
go worker(die)
die <- true
// Ждем, пока все горутины закончат выполняться
<-die
}
```
### Инкапсулируем состояние
#### Уникальный ID сервиса
В этом примере горутина запускается для генерации уникальных шестнадцатиричных id’шников. Каждый id посылается через канал id и горутина приостанавливается, пока сообщение из канала не будет прочитано. Каждый раз, когда канал будет прочитан, горутина инкрементирует счетчик и посылает его значение.
```
package main
import "fmt"
func main() {
id := make(chan string)
go func() {
var counter int64 = 1
for {
id <- fmt.Sprintf("%x", counter)
counter += 1
}
}()
fmt.Printf("%s\n", <-id) // will be 1
fmt.Printf("%s\n", <-id) // will be 2
}
```
#### Повторное использование памяти
В этом примере, горутина запускается для повторного использования буферов памяти. Канал give получает старые буферы памяти и сохраняет их в список. В это время канал get распределяет эти буферы для использования. Если нет доступных буферов в списке, создается один новый.
**От переводчика***Проще говоря, мы активно повторно используем память, чтобы лишний раз ее не выделять (как мы знаем, ОС может выделять память очень долго). Используется список, в котором всегда есть как минимум 1 буфер. А уже использованные буфера отправляем обратно в этот же список.*
```
package main
import "container/list"
func main() {
give := make(chan []byte)
get := make(chan []byte)
go func() {
q := new(list.List)
for {
if q.Len() == 0 {
q.PushFront(make([]byte, 100))
}
e := q.Front()
select {
case s := <-give:
q.PushFront(s)
case get <- e.Value.([]byte):
q.Remove(e)
}
}
}()
// Получаем новый буфер
buffer := <-get
// Возвращаем буфер
give <- buffer
// Получаем буфер снова
buffer = <-get
}
```
#### Ограниченное повторное использование памяти
В этом примере буферизированный канал используется как хранилище буферов. Канал настроен на хранение пяти буферов в любой момент времени. Это значит, что канал не блокирует текущую горутину, если у него есть место еще для одной записи.
Select предоставляет неблокирующий доступ к этому каналу в случае, если он будет заполнен. Первый select создает новый буфер, если невозможно получить его из хранилища. Второй select по умолчанию ничиго не делает, если невозможно положить буфер в хранилище, что вызывает GC для очистки этого буфера.
**От переводчика***Тут опять хочется добавить от себя. Мы просто создаем буферизированный канал, который ограничивает количество буферов, которые мы хотим «переиспользовать». И если нам приходит «лишний» буфер, мы его игнорим, позволяя отрабатывать сборщику мусора. В данном случае, обе функции неблокирующие, то есть не ждут получения данных ни от кого.*
```
package main
func get(store chan []byte) []byte {
select {
case b := <-store:
return b
default:
return make([]byte, 100)
}
}
func give(store chan []byte, b []byte) {
select {
case store <- b:
default:
return
}
}
func main() {
// Создаем хранилище буферов.
store := make(chan []byte, 5)
// Получаем новый буфер из хранилища.
buffer := get(store)
// Возвращаем его обратно в хранилище.
give(store, buffer)
// Получаем буфер еще раз из хранилища.
buffer = get(store)
}
```
### Nil каналы
#### Отключение получения сообщений в операторе case
В этом примере горутина запускается и используется select для получения сообщений из двух каналов. Если канал закрывается, он устанавливается в nil. Поскольку nil каналы всегда блокируют выполнение, данный case больше не выполняется. Если оба канала будут установлены в nil, мы выйдем из горутины, поскольку она больше не может ничего получать.
**От переводчика***В примере второе выводимое значение – false, так как после закрытия c1 мы получили x = false и ok = false. Если бы мы не присвоили каналу c1 значение nil, то в нашем бесконечном цикле мы бы продолжали бесконечно получать x = false, ok = false.*
*Важная мысль. Если вы закрыли канал, то в его case всегда будет приходить значение по умолчанию. Поэтому следует присваивать nil закрытому каналу. А после этого не стоит забывать проверить все каналы на nil, иначе можно навсегда заблокировать вашу горутину.*
```
package main
import "fmt"
func main() {
c1 := make(chan bool)
c2 := make(chan bool)
go func() {
for {
select {
case x, ok := <-c1:
if !ok {
c1 = nil
}
fmt.Println(x)
case x, ok := <-c2:
if !ok {
c2 = nil
}
fmt.Println(x)
}
if c1 == nil && c2 == nil {
return
}
}
}()
c1 <- true
// Отключение первого case из select'a выше.
close(c1)
c2 <- true
}
```
#### Отключение отправки сообщений в операторе case
В этом примере горутина запускается и используется для генерации рандомных чисел и отправки их в канал c. Когда приходит сообщение в канал d, канал c устанавливается в nil, отключая соответствующий оператор case. Отключенная горутина уже больше никогда не генерирует рандомных чисел.
**От переводчика***Вот тут бы не помешала проверка на nil, иначе наша горутина не заканчивает свое выполнение. Она заблокировалась на select, так как первый case уже никогда не выполнится, а второй потерял смысл.*
*Тут есть ошибка в комментарии – c в предпоследней строке не равен nil, nil установили только для локальной переменной src. А deadlock происходит потому, что наш канал c больше никто не записывает.*
```
package main
import (
"fmt"
"math/rand"
)
func main() {
c := make(chan int)
d := make(chan bool)
go func(src chan int) {
for {
select {
case src <- rand.Intn(100):
case <-d:
src = nil
}
}
}(c)
// Печатаем несколько случайных чисел.
fmt.Printf("%d\n", <-c)
fmt.Printf("%d\n", <-c)
// Отключаем генерацию рандомных чисел.
d <- true
// Здесь прекращается выполнение, потому что канал c теперь nil.
fmt.Printf("%d\n", <-c)
}
```
### Таймеры
#### Таймаут
В этом примере горутина запускается, чтобы сделать некоторую работу. Канал timeout создан, чтобы обеспечить исполнение case, если select выполняется слишком долго. В данном случае, горутина завершается после 30 секунд ожидания. Таймаут пересоздается каждую итерацию select’a, чтобы быть уверенным, что он успешно выполнен. В каждой следующей итерации таймаут сбрасывается.
**От переводчика***Тут небольшая опечатка — в коде 5 секунд, а в статье 30.*
```
package main
import "time"
func worker() {
for {
timeout := time.After(5 * time.Second)
select {
// ... выполняем что-нибудь
case <-timeout:
// Закрываем эту горутину после указанного таймаута.
return
}
}
}
func main() {
go worker()
}
```
#### Heartbeat
В этом примере горутина запускается, чтобы делать некоторую работу. Канал heartbeat создан для исполнения оператора case через равные промежутки времени. Канал heartbeat не сбрасывается на каждой итерации, чтобы оператор case всегда исполнялся в срок.
```
package main
import "time"
func worker() {
heartbeat := time.Tick(30 * time.Second)
for {
select {
// ... выполняем что-нибудь
case <-heartbeat:
// ... выполняем что-нибудь по таймеру
}
}
}
func main() {
go worker()
}
```
### Примеры
#### Сетевой мультиплексор
Этот пример демонстрирует простой сетевой мультиплексор. В нашей главной горутине создается канал для обработки передаваемых сообщений и устанавливается сетевое соединение. Затем запускается сотня горутин для генерации строк (которые действуют как наши сообщения) и передачи их через этот канал. Каждое сообщение читается из канала на протяжении бесконечного цикла и посылается в сетевое соединение.
Этот пример не запускается (потому что мы пытаемся соединиться с тестовому домену), но он показывает, как легко запустить множество ассинхронных процессов, посылающих сообщения в единственное сетевое подключение.
```
package main
import "net"
func worker(messages chan string) {
for {
var msg string // ... генерируем сообщение
messages <- msg
}
}
func main() {
messages := make(chan string)
conn, _ := net.Dial("tcp", "example.com")
for i := 0; i < 100; i++ {
go worker(messages)
}
for {
msg := <-messages
conn.Write([]byte(msg))
}
}
```
#### Первый ответ
В этом примере каждый url из массива передается в отдельную горутину. Каждая горутина выполняется ассинхронно и запрашивает переданный ей url. Каждый ответ на запрос передается в канал first, который, конечно, гарантирует, что первый полученный ответ первым попадет в канал. Затем мы можем прочитать этот ответ из канала и соответственно обработать.
**От переводчика***Пример снова не рабочий (ругается на неиспользуемую переменную r). Вот тут похожий пример — [youtube.com](https://youtu.be/f6kdp27TYZs?t=33m43). Рекомендую к просмотру это видео целиком.*
```
package main
import "net/http"
type response struct {
resp *http.Response
url string
}
func get(url string, r chan response) {
if resp, err := http.Get(url); err == nil {
r <- response{resp, url}
}
}
func main() {
first := make(chan response)
for _, url := range []string{"http://code.jquery.com/jquery-1.9.1.min.js",
"http://cdnjs.cloudflare.com/ajax/libs/jquery/1.9.1/jquery.min.js",
"http://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js",
"http://ajax.aspnetcdn.com/ajax/jQuery/jquery-1.9.1.min.js"} {
go get(url, first)
}
r := <-first
// ... выполняем что-нибудь
}
```
#### Передача канала ответа
В этом примере канал w создан для передачи задач в горутину. Горутина получает задачу и делает запрос на url, содержащийся в ней. Канал resp тоже приходит в горутину как часть задачи. Как только запрос будет выполнен, ответ отправляется обратно через канал resp. Это позволяет этой горутине обрабатывать задачи и посылать результат обратно через разные каналы, настроенные для каждой отдельной задачи.
**От переводчика***Если проще, мы для каждой нашей задачи создаем свой канал для ответа, через который горутина нам шлет результаты.*
```
package main
import "net/http"
type work struct {
url string
resp chan *http.Response
}
func getter(w chan work) {
for {
do := <-w
resp, _ := http.Get(do.url)
do.resp <- resp
}
}
func main() {
w := make(chan work)
go getter(w)
resp := make(chan *http.Response)
w <- work{"http://cdnjs.cloudflare.com/jquery/1.9.1/jquery.min.js", resp}
r := <-resp
// ... выполняем что-нибудь
}
```
#### HTTP балансировщик нагрузки
В этом примере создается балансировшщик нагрузки на основе предыдущих примеров. Он обрабатывает прочитанные с stdin url’ы и для каждого запускает горутину для обработки. Каждый запрос проходит через балансировщик нагрузки, чтобы отфильтровать эти задачи на ограниченое число worker’ов. Эти worker’ы обрабатывают запросы и возвращают результаты в единственный канал answer.
Использование балансировщика нагрузки наподобии этого позволяет отправить огромное количество запросов, распределить их по всем доступным ресурсам и обработать их в упорядоченной виде.
```
package main
import (
"fmt"
"net/http"
)
type job struct {
url string
resp chan *http.Response
}
type worker struct {
jobs chan *job
count int
}
func (w *worker) getter(done chan *worker) {
for {
j := <-w.jobs
resp, _ := http.Get(j.url)
j.resp <- resp
done <- w
}
}
func get(jobs chan *job, url string, answer chan string) {
resp := make(chan *http.Response)
jobs <- &job{url, resp}
r := <-resp
answer <- r.Request.URL.String()
}
func balancer(count int, depth int) chan *job {
jobs := make(chan *job)
done := make(chan *worker)
workers := make([]*worker, count)
for i := 0; i < count; i++ {
workers[i] = &worker{make(chan *job, depth), 0}
go workers[i].getter(done)
}
go func() {
for {
var free *worker
min := depth
for _, w := range workers {
if w.count < min {
free = w
min = w.count
}
}
var jobsource chan *job
if free != nil {
jobsource = jobs
}
select {
case j := <-jobsource:
free.jobs <- j
free.count++
case w := <-done:
w.count--
}
}
}()
return jobs
}
func main() {
jobs := balancer(10, 10)
answer := make(chan string)
for {
var url string
if _, err := fmt.Scanln(&url); err != nil {
break
}
go get(jobs, url, answer)
}
for u := range answer {
fmt.Printf("%s\n", u)
}
}
```
### Заключение
Go — язык, который с моей точки зрения имеет проблемы, но это язык, который я готов учить и использовать. Идеи из этой презентации открыли мне новые концепции и после нее захотелось начать новый проект, который будет использовать преимущества фантастичекой поддержки конкурентности в Go. Она также подчеркнула необходимость чтения и понимания стандартной библиотеки, предоставляемой языками, такими как Go, чтобы лучше осознать характер и проектные решения языка. | https://habr.com/ru/post/278349/ | null | ru | null |
# db-tree: поиск и навигация по базе данных
 В этом посте я расскажу об инструменте для быстрого поиска строк в базе данных и навигации по ним. Если вы работаете в поддержке и вам приходится выполнять много запросов к базам данных, если вы устали писать SELECT'ы, прошу под кат.
Мотивация
---------
Некоторое время назад я помогал поддерживать большую учетную систему. В ходе работы требовалось искать информацию по базе данных. Типичный сценарий: звонит пользователь с проблемой по заявке N1. Для диагностики нужно просмотреть некоторые данные по этой заявке в базе. Выполняем запрос:
```
SQL SELECT * FROM ORDER WHERE ID = 'N1'
```
С заявкой связан агрегат, поэтому выполняем следующий запрос для получения информации по агрегату:
```
SQL SELECT * FROM DEVICE WHERE ORDER_ID = 'N1'
```
Затем ищем все заявки, связанные с агрегатом:
```
SQL SELECT * FROM ORDERS WHERE DEVICEID = '92375'
```
И так далее. После выполнения N запросов рано или поздно найдем проблему в данных и примем меры. Недостатки такого подхода очевидны:
* Вручную писать запросы медленно и неудобно. Особенно если структура базы данных сложная и таблиц много. Так можно и до туннельного синдрома доработаться.
* Когда нужно найти связанную строчку по Unique constraint или Foreign Key, приходится писать новый запрос.
* Обычно инструменты для работы с базами данных отображают данные в виде таблиц. Когда колонок в таблице много, таблицу приходится прокручивать горизонтально, либо выбирать колонки в запросе. Опять же, требуется ручная работа.
Идея
----
Сначала нужно упростить поиск. Это действие должно выполняться с помощью минимального количества кликов. Просто вводим искомую строку в текстовое поле, и нажимаем Enter. Обычно первичные ключи индексируются, поэтому можно искать значение сразу по всем колонкам, которые включены в Primary Keys или Unique Constraints.
Затем нужно решить задачу навигации. Как быстро перейти к связанной записи по Foreign Key? Можно представить базу данных как файловую систему: вообразим, что строчка базы данных это директория, связанная строчка по Foreign Key — симлинк, а поле, не являющееся Foreign Key это простой файл. Я не собираюсь писать драйвер файловой системы, это просто аналогия. Так строчки базы данных можно представить в виде иерархической структуры, которую можно отобразить с помощью компонента TreeTable.
Также в компонент TreeTable можно добавить колонку, в которой будет отображаться некоторое осмысленное значение для заданной строки. Это значение можно получить, сконкатенировав значения полей строки базы данных. Например, для строки заявки можно составить выражение:
```
ORDER_NAME + ', ' + ORDER_STATUS + ', ' + ORDER_CUSTOMER
```
Ближайшая аналогия: метод toString() в java.
Реализация
----------
Программирование заняло много месяцев. Сначала я пытался использовать C++ и Qt, но это оказалось трудно: в мире C++ нет чего-то похожего на jdbc-драйверы, да и сам язык существенно сложнее. Поэтому приложение написано на Java.
На скриншоте мы видим поле для поиска, комбобокс для переключения текущего соединения и компонент TreeTable, в котором отображаются иерархические данные.
#### Поиск
В текстовое поле можно ввести строку и нажать Enter. Поиск сейчас работает только по колонкам строковых и числовых типов: VARCHAR, NUMBER, и т. д. Типы даты и времени пока не поддерживаются. По умолчанию инструмент ищет значения в колонках, которые включены в Primary Key. В настройках можно отметить галочками прочие поля, которые будут использованы при поиске.
#### Навигация по ключам
Узлы, помеченные меткой [F], это Foreign Key. В колонке Table мы видим имя таблицы, на которую этот ключ ссылается. Раскрыв узел мы перейдем к связанной строчке. Составные Foreign Key также поддерживаются.
Узлы, помеченные меткой [U], это Unique Constraint или Primary Key. Раскрыв узел можно перейти к связанным строчкам. Посмотрите на скриншот:
Мы ввели в строку поиска значение 10248 и нашли строчку в таблице ORDERS. Раскрыли узел [U] ORDER\_ID и нашли 3 строчки в таблице ORDER\_DETAILS. Затем можно раскрыть каждый узел и перейти к строчкам таблицы ORDER\_DETAILS.
#### Колонка String
Значения первичных ключей часто неинформативны. На предыдущем скриншоте мы видим значения ORDER\_ID=10248,PRODUCT\_ID=11. Эти числа ни о чем нам не говорят. Чтобы их как-то очеловечить, можно составить выражение:
```
'Product: ' + PRODUCT_ID.PRODUCT_NAME + ', Price: ' + UNIT_PRICE
```
и ввести его в ячейку колонки String:
Нажимаем Enter и видим более осмысленные значения:
Технические подробности
-----------------------
Приложение написано на Java, интерфейс на JavaFX. Можно заметить, что в TreeTable используются строки "[U]" и "[F]" вместо иконок, это сделано по причине этого досадного бага: [JDK-8190331](https://bugs.openjdk.java.net/browse/JDK-8190331). Пароли к базам данных хранятся в защищенном хранилище с помощью библиотеки [java-keyring](https://github.com/javakeyring/java-keyring). Для сборки инсталляторов используется OpenJDK 13 и early-access build [jpackage](https://jdk.java.net/jpackage/). Команды сборки можно посмотреть [здесь](https://github.com/db-tree/db-tree-fx/tree/master/deploy).
Сейчас поддерживаются базы данных Oracle, MariaDB и PostgreSQL.
Ссылки
------
Страничка проекта на github: [db-tree-fx](https://github.com/db-tree/db-tree-fx)
Если вы нашли ошибку, или нужно что-нибудь добавить, смело заводите issue или пишите прямо на почту: [db.tree.app@gmail.com](mailto:db.tree.app@gmail.com).
Пакеты для установки
--------------------
Rpm для GNU/Linux: [db-tree-0.0.2-1.x86\_64.rpm](https://github.com/db-tree/db-tree-fx/releases/download/v0.0.2/db-tree-0.0.2-1.x86_64.rpm)
Deb для GNU/Linux: [db-tree\_0.0.2-1\_amd64.deb](https://github.com/db-tree/db-tree-fx/releases/download/v0.0.2/db-tree_0.0.2-1_amd64.deb)
Подписанный dmg для macOS: [db-tree-0.0.2.dmg](https://github.com/db-tree/db-tree-fx/releases/download/v0.0.2/db-tree-0.0.2.dmg)
Подписанный msi для Windows: [db-tree-0.0.2.msi](https://github.com/db-tree/db-tree-fx/releases/download/v0.0.2/db-tree-0.0.2.msi)
Последний релиз можно найти на [github](https://github.com/db-tree/db-tree-fx/releases/latest) | https://habr.com/ru/post/478638/ | null | ru | null |
# Дудл от Гугл на день всех влюбленных
[Гугл](http://google.ru) вывесил на главную дудл ко дню всех влюбленных.
Дудл представляет собой небольшую игру, в которой две карусели играют роль генератора случайных животных. При нажатии на кнопку в центре с сердечком случайно подбирается пара, и можно посмотреть, что из этого получится.
Судя по тому, что на каждом колесе по 8 животных, то разных пар может получиться 8×8=64. Я уже залип минут на 15, и еще ни разу история не повторилась, и даже один раз выпало белке не влюбиться и грустить у телека в одиночестве.
Но главный сюрприз ждет тех, кто кликнет на поиск дудла. Потому что вы будете искать не «Святого Валентина», а [американского инженера Джоджа Ферриса](https://www.google.ru/webhp?hl=ru&tab=ww#q=%D0%94%D0%B6%D0%BE%D1%80%D0%B4%D0%B6+%D0%A4%D0%B5%D1%80%D1%80%D0%B8%D1%81&oi=ddle&ct=valentines_day_and_george_ferris_154th_birthday-1032005-hp&bav=on.2,or.r_gc.r_pw.r_cp.r_qf.&bvm=bv.42452523,d.bGE&fp=35accab7fb424550&biw=1600&bih=898), который прославился тем, что построил первое колесо обозрения в 1893 году.
Приятно убить время в день всех влюбленных! Убейте его со своими любимыми.
P.S.
----
[afsherman](http://habrahabr.ru/users/afsherman/) сообщает, что комиксов всего 10, а не 64 в вышеприведенном псевдо-научном изыскании.
Оставшиеся картинки:
--------------------
Дудл уйдет, а этот пост останется. Размещу оставшиеся картинки:
 | https://habr.com/ru/post/169355/ | null | ru | null |
# Создание игры Tower Defense в Unity — Часть 2
Это вторая часть туториала *«Создание игры Tower Defense в Unity»*. Мы создаём в Unity игру жанра tower defense, и к концу [первой части](https://habr.com/post/413837/), научились размещать и апгрейдить монстров. Также у нас есть один враг, нападающий на печенье.
Однако враг пока не знает, куда ему смотреть! Кроме того, нападение в одиночку выглядит странно. В этой части туториала мы добавим волны врагов и вооружим монстров, чтобы они могли защищать драгоценную печеньку.
Приступаем к работе
-------------------
Откройте в Unity проект, на котором мы остановились в прошлой части. Если вы присоединились к нам только сейчас, то скачайте [проект-заготовку](https://koenig-media.raywenderlich.com/uploads/2017/09/TowerDefense-Part2-Starter.zip) и откройте *TowerDefense-Part2-Starter*.
Откройте *GameScene* из папки *Scenes*.
Поворачиваем врагов
-------------------
В конце предыдущего туториала враг научился двигаться по дороге, но, похоже, понятия не имеет, куда ему смотреть.
Откройте в IDE скрипт *MoveEnemy.cs* и добавьте в него следующий метод, чтобы исправить ситуацию.
```
private void RotateIntoMoveDirection()
{
//1
Vector3 newStartPosition = waypoints [currentWaypoint].transform.position;
Vector3 newEndPosition = waypoints [currentWaypoint + 1].transform.position;
Vector3 newDirection = (newEndPosition - newStartPosition);
//2
float x = newDirection.x;
float y = newDirection.y;
float rotationAngle = Mathf.Atan2 (y, x) * 180 / Mathf.PI;
//3
GameObject sprite = gameObject.transform.Find("Sprite").gameObject;
sprite.transform.rotation = Quaternion.AngleAxis(rotationAngle, Vector3.forward);
}
```
`RotateIntoMoveDirection` поворачивает врага так, чтобы всегда смотрел вперёд. Он делает это следующим образом:
1. Вычисляет текущее направление движения жука, вычитая позицию текущей точки маршрута из позиции следующей точки.
2. Использует `Mathf.Atan2` для определения угла в радианах, в котором направлен `newDirection` (нулевая точка находится справа). Умножает результат на `180 / Mathf.PI`, преобразуя угол в градусы.
3. Наконец, он получает дочерний объект *Sprite* и поворачивает на `rotationAngle` градусов по оси. Заметьте, что мы поворачиваем *дочерний*, а не родительский объект, чтобы полоска энергии, которую мы добавим позже, оставались горизонтальной.
В `Update()`, заменим комментарий `// TODO: поворот в направлении движения` следующим вызовом `RotateIntoMoveDirection`:
```
RotateIntoMoveDirection();
```
Сохраните файл и вернитесь в Unity. Запустите сцену; теперь враг знает, куда он движется.
Теперь жук знает, куда он движется.
Один-единственный враг выглядит не очень впечатляюще. Нам нужны орды! И как в любой игре tower defense, орды набегают волнами!
Информируем игрока
------------------
Прежде чем начать двигать орды, нам нужно предупредить игрока о грядущей битве. Кроме того, стоит отображать в верхней части экрана номер текущей волны.
Информация о волнах требуется нескольким GameObject, поэтому мы добавим её к компоненту *GameManagerBehavior* объекта *GameManager*.
Откройте в IDE *GameManagerBehavior.cs* и добавьте две следующие переменные:
```
public Text waveLabel;
public GameObject[] nextWaveLabels;
```
`waveLabel` хранит ссылку на метку вывода номера волны в верхнем правом углу экрана. `nextWaveLabels` хранит два GameObject, создающие в сочетании анимацию, которую мы будем показывать в начале новой волны:
Сохраните файл и вернитесь в Unity. Выберите *GameManager* в *Hierarchy*. Нажмите на кружок справа от *Wave Label* и в диалоговом окне *Select Text* выберите *WaveLabel* из вкладки *Scene*.
Теперь задайте *Size* для *Next Wave Labels* значение *2*. Теперь выберите для *Element 0* значение *NextWaveBottomLabel*, а для *Element 1* значение *NextWaveTopLabel* так же, как мы сделали с Wave Label.
*Вот как теперь должен выглядеть Game Manager Behavior*
Если игрок проиграет, то он не должен увидеть сообщение о следующей волне. Чтобы обработать эту ситуацию, вернитесь в *GameManagerBehavior.cs* и добавьте ещё одну переменную:
```
public bool gameOver = false;
```
В `gameOver` мы будем хранить значение того, проиграл ли игрок.
Здесь мы снова используем свойство для синхронизации элементов игры с текущей волной. Добавьте в `GameManagerBehavior` следующий код:
```
private int wave;
public int Wave
{
get
{
return wave;
}
set
{
wave = value;
if (!gameOver)
{
for (int i = 0; i < nextWaveLabels.Length; i++)
{
nextWaveLabels[i].GetComponent().SetTrigger("nextWave");
}
}
waveLabel.text = "WAVE: " + (wave + 1);
}
}
```
Создание частной переменной, свойства и геттера уже должно стать для вас привычным действием. Но с сеттером снова всё чуть более интересно.
Мы присваиваем `wave` новое значение `value`.
Затем проверяем, не закончена ли игра. Если нет, то обходим в цикле все метки *nextWaveLabels* — у этих меток есть компонент *Animator*. Чтобы задействовать анимацию *Animator* мы задаём триггер *nextWave*.
Наконец, мы присваиваем `text` у `waveLabel` значение `wave + 1`. Почему `+1`? Обычные люди не начинают отсчёт с нуля (да, это странно).
В `Start()` задаём значение этого свойства:
```
Wave = 0;
```
Мы начинаем счёт с номера *0* `Wave`.
Сохраните файл и запустите сцену в Unity. Метка Wave будет правильно показывать 1.
*Для игрока всё начинается с волны 1.*
Волны: создаём кучи врагов
--------------------------
Может показаться очевидным, но для атаки ордой необходимо создать больше врагов — пока мы этого делать не умеем. Более того, мы не должны создавать следующую волну, пока не уничтожена текущая.
То есть игра должна уметь распознавать наличие врагов в сцене и хорошим способом идентификации игровых объектов здесь являются *теги*.
### Задание тегов врагов
Выберите префаб *Enemy* в Project Browser. В верхней части *Inspector* нажмите на раскрывающийся список *Tag* и выберите *Add Tag*.
Создайте *Tag* с названием *Enemy*.
Выберите префаб *Enemy*. В *Inspector* задайте для него *тег* *Enemy*.
### Задание волн врагов
Теперь нам нужно задать волну врагов. Откройте в IDE *SpawnEnemy.cs* и добавьте перед `SpawnEnemy` следующую реализацию класса:
```
[System.Serializable]
public class Wave
{
public GameObject enemyPrefab;
public float spawnInterval = 2;
public int maxEnemies = 20;
}
```
*Wave* содержит `enemyPrefab` — основу для создания экземпляров всех врагов в этой волне, `spawnInterval` — время между врагами в волне в секундах и `maxEnemies` — количество врагов, создаваемых в этой волне.
Класс является *Serializable*, то есть мы можем изменять его значения в Inspector.
Добавьте в класс `SpawnEnemy` следующие переменные:
```
public Wave[] waves;
public int timeBetweenWaves = 5;
private GameManagerBehavior gameManager;
private float lastSpawnTime;
private int enemiesSpawned = 0;
```
Здесь мы задаём переменные для спаунинга врагов, что очень похоже на то, как мы перемещали врагов между точками маршрута.
Мы задаём волны отдельные врагов в `waves` и отслеживаем количество создаваемых врагов и время их создания в `enemiesSpawned` и `lastSpawnTime`.
После всех этих убийств игрокам нужно время на передышку, поэтому зададим для `timeBetweenWaves` значение 5 секунд.
Заменим содержимое `Start()` следующим кодом.
```
lastSpawnTime = Time.time;
gameManager =
GameObject.Find("GameManager").GetComponent();
```
Здесь мы присваиваем `lastSpawnTime` значение текущего времени, то есть время запуска скрипта после загрузки сцены. Затем мы получаем знакомым уже способом `GameManagerBehavior`.
Добавим в `Update()` следующий код:
```
// 1
int currentWave = gameManager.Wave;
if (currentWave < waves.Length)
{
// 2
float timeInterval = Time.time - lastSpawnTime;
float spawnInterval = waves[currentWave].spawnInterval;
if (((enemiesSpawned == 0 && timeInterval > timeBetweenWaves) ||
timeInterval > spawnInterval) &&
enemiesSpawned < waves[currentWave].maxEnemies)
{
// 3
lastSpawnTime = Time.time;
GameObject newEnemy = (GameObject)
Instantiate(waves[currentWave].enemyPrefab);
newEnemy.GetComponent().waypoints = waypoints;
enemiesSpawned++;
}
// 4
if (enemiesSpawned == waves[currentWave].maxEnemies &&
GameObject.FindGameObjectWithTag("Enemy") == null)
{
gameManager.Wave++;
gameManager.Gold = Mathf.RoundToInt(gameManager.Gold \* 1.1f);
enemiesSpawned = 0;
lastSpawnTime = Time.time;
}
// 5
}
else
{
gameManager.gameOver = true;
GameObject gameOverText = GameObject.FindGameObjectWithTag ("GameWon");
gameOverText.GetComponent().SetBool("gameOver", true);
}
```
Разберём его пошагово:
1. Получаем индекс текущей волны и проверяем, последняя ли она.
2. Если да, то вычисляем время, прошедшее после предыдущего спауна врагов и проверяем, настало ли время создавать врага. Здесь мы учитываем два случая. Если это первый враг в волне, то мы проверяем, больше ли `timeInterval`, чем `timeBetweenWaves`. В противном случае мы проверяем, больше ли `timeInterval`, чем `spawnInterval` волны. В любом случае мы проверяем, что не создали всех врагов в этой волне.
3. При необходимости спауним врага, создавая экземпляр `enemyPrefab`. Также увеличиваем значение `enemiesSpawned`.
4. Проверяем количество врагов на экране. Если их нет, и это был последний враг в волне, то создаём следующую волну. Также в конце волны мы даём игроку 10 процентов всего оставшегося золота.
5. После победы над последней волной здесь воспроизводится анимация победы в игре.
### Задание интервалов спауна
Сохраните файл и вернитесь в Unity. Выберите в *Hierarchy* объект *Road*. В *Inspector* задайте для *Size* объекта *Waves* значение *4*.
Пока выберем для всех четырёх элементов в качестве *Enemy Prefab* объект *Enemy*. Настройте поля *Spawn Interval* и *Max Enemies* следующим образом:
* *Element 0*: Spawn Interval: *2.5*, Max Enemies: *5*
* *Element 1*: Spawn Interval: *2*, Max Enemies: *10*
* *Element 2*: Spawn Interval: *2*, Max Enemies: *15*
* *Element 3*: Spawn Interval: *1*, Max Enemies: *5*
Готовая схема должна выглядеть так:
Разумеется, вы можете поэкспериментировать с этими значениями, чтобы увеличить или уменьшить сложность.
Запустите игру. Ага! Жуки начали путь к вашей печеньке!
### Дополнительная задача: добавим разные типы врагов
Никакая игра жанра tower defense не может считаться полной только с одним типов врагов. К счастью, в папке *Prefabs* есть ещё и *Enemy2*.
В *Inspector* выберите *Prefabs\Enemy2* и добавьте к нему скрипт *MoveEnemy*. Задайте для *Speed* значение *3* и задайте *тег* *Enemy*. Теперь можно использовать этого быстрого врага, чтобы игрок не расслаблялся!
Обновление жизни игрока
-----------------------
Даже хотя орды врагов нападают на печеньку, игрок не получает никакого урона. Но скоро мы это исправим. Игрок должен страдать, если позволит врагу подкрасться.
Откройте в IDE *GameManagerBehavior.cs* и добавьте две следующие переменные:
```
public Text healthLabel;
public GameObject[] healthIndicator;
```
Мы используем `healthLabel` для доступа к значению жизни игрока, а `healthIndicator` для доступа к пяти маленьким зелёным монстрам, жующим печенье — они просто символизируют здоровье игрока; это забавнее, чем стандартный индикатор здоровья.
### Управление здоровьем
Теперь добавим свойство, хранящее здоровье игрока в `GameManagerBehavior`:
```
private int health;
public int Health
{
get
{
return health;
}
set
{
// 1
if (value < health)
{
Camera.main.GetComponent().Shake();
}
// 2
health = value;
healthLabel.text = "HEALTH: " + health;
// 3
if (health <= 0 && !gameOver)
{
gameOver = true;
GameObject gameOverText = GameObject.FindGameObjectWithTag("GameOver");
gameOverText.GetComponent().SetBool("gameOver", true);
}
// 4
for (int i = 0; i < healthIndicator.Length; i++)
{
if (i < Health)
{
healthIndicator[i].SetActive(true);
}
else
{
healthIndicator[i].SetActive(false);
}
}
}
}
```
Так мы управляем здоровьем игрока. И снова основная часть кода расположена в сеттере:
1. Если мы снижаем здоровье игрока, то используем компонент `CameraShake` для создания красивого эффекта тряски. Этот скрипт включён в скачиваемый проект и мы не будем его здесь рассматривать.
2. Обновляем частную переменную и метку здоровья в верхнем левом углу экрана.
3. Если здоровье снизилось до 0 и конец игры ещё не наступил, то присваиваем `gameOver` значение `true` и запускаем анимацию `GameOver`.
4. Убираем одного из монстров с печенья. Если мы просто отключаем их, то эту часть можно написать проще, но здесь мы поддерживаем повторное включение на случай добавления здоровья.
Инициализируем `Health` в `Start()`:
```
Health = 5;
```
Мы присваиваем `Health` значение `5`, когда начинает воспроизводиться сцена.
Сделав всё это, мы теперь можем обновлять здоровье игрока, когда жук добирается до печеньки. Сохраните файл и перейдите в IDE к скрипту *MoveEnemy.cs*.
### Изменение здоровья
Для изменения здоровья найдите комментарий в `Update()` со словами `// TODO: вычитать здоровье` и замените его таким кодом:
```
GameManagerBehavior gameManager =
GameObject.Find("GameManager").GetComponent();
gameManager.Health -= 1;
```
Так мы получаем `GameManagerBehavior` и вычитаем из его `Health` единицу.
Сохраните файл и вернитесь в Unity.
Выберите в *Hierarchy* объект *GameManager* и выберите для его *Health Label* значение *HealthLabel*.
Разверните в *Hierarchy* объект *Cookie* и перетащите пять его дочерних *HealthIndicator* в массив *GameManager's Health Indicator* — индикаторами здоровья будут мелкие зелёные монстрики, поедающие печенье.
Запустите сцену и дождитесь, пока жуки не дойдут до печеньки. Ничего не делайте, пока не проиграете.
Месть монстров
--------------
Монстры на месте? Да. Враги нападают? Да, и они выглядят угрожающе! Настала пора ответить этим животным!
Для этого нам нужно следующее:
* Полоса здоровья, чтобы игрок знал, какие враги сильные, а какие слабые
* Обнаружение врагов в радиусе действия монстра
* Принятие решения — в какого врага нужно стрелять
* Куча снарядов
### Полоса здоровья врагов
Для реализации полосы здоровья мы используем два изображения — одно для тёмного фона, а второе (зелёную полосу немного поменьше) будем масштабировать в соответствии со здоровьем врага.
Перетащите из *Project Browser* в сцену *Prefabs\Enemy*.
Затем в *Hierarchy* перетащите *Images\Objects\HealthBarBackground* на *Enemy*, чтобы добавить его как дочерний элемент.
В *Inspector* задайте для *Position* у *HealthBarBackground* значение *(0, 1, -4)*.
Затем в *Project Browser* выберите *Images\Objects\HealthBar* и убедитесь, что его *Pivot* имеет значение *Left*. Затем добавьте его как дочерний элемент *Enemy* в *Hierarchy* и задайте его *Position* значение *(-0.63, 1, -5)*. Для *X* масштаба *Scale* задайте значение *125*.
Добавьте к игровому объекту *HealthBar* новый скрипт *C#* под названием *HealthBar*. Позже мы изменим его, чтобы он менял длину полосы здоровья.
Выбрав в *Hierarchy* объект *Enemy*, убедитесь, что его позиция равна *(20, 0, 0)*.
Нажмите *Apply* в верхней части *Inspector*, чтобы сохранить все изменения как часть префаба. Наконец удалите в *Hierarchy* объект *Enemy*.
Теперь повторите все эти шаги, чтобы добавить полосу здоровья для *Prefabs\Enemy2*.
### Изменяем длину полосы здоровья
Откройте в IDE *HealthBar.cs* и добавьте следующие переменные:
```
public float maxHealth = 100;
public float currentHealth = 100;
private float originalScale;
```
В `maxHealth` хранится максимальное здоровье врага, а в `currentHealth` — оставшееся здоровье. Наконец, в `originalScale` находится начальный размер полосы здоровья.
Сохраняем `originalScale` объекта в `Start()`:
```
originalScale = gameObject.transform.localScale.x;
```
Мы сохраняем значение `x` свойства `localScale`.
Зададим масштаб полосы здоровья, добавив следующий код в `Update()`:
```
Vector3 tmpScale = gameObject.transform.localScale;
tmpScale.x = currentHealth / maxHealth * originalScale;
gameObject.transform.localScale = tmpScale;
```
Мы можем скопировать `localScale` во временную переменную, потому что не можем изменять отдельно его значение *x*. Затем вычислим новый масштаб по *x* на основании текущего здоровья жука и снова присвоим `localScale` значение временной переменной.
Сохраните файл и запустите игру в Unity. Над врагами вы увидите полосы здоровья.
Пока игра запущена, разверните в *Hierarchy* один из объектов *Enemy(Clone)* и выберите его дочерний элемент *HealthBar*. Измените его значение *Current Health* и посмотрите, как меняется полоса его здоровья.
### Обнаружение врагов в радиусе действия
Теперь нашим монстрам нужно узнать, в каких врагов целиться. Но прежде чем реализовать эту возможность, необходимо подготовить Monster и Enemy.
Выберите в Project Browser *Prefabs\Monster* и добавьте к нему в *Inspector* компонент *Circle Collider 2D*.
Задайте для параметра *Radius* коллайдера значение *2.5* — так мы укажем радиус атаки монстров.
Поставьте флажок *Is Trigger*, чтобы объекты проходили сквозь эту область, а не сталкивались с ней.
Наконец в верхней части *Inspector*, выберите для *Layer* объекта Monster значение *Ignore Raycast*. Нажмите в диалоговом окне на *Yes, change children*. Если не выбрать Ignore Raycast, то коллайдер будет реагировать на события нажатий мыши. Это будет проблемой, потому что монстры блокируют события, предназначенные для объектов Openspot под ними.
Чтобы обеспечить обнаружение врага в области триггера, нам необходимо добавить к нему коллайдер и rigid body, потому что Unity отправляет события триггеров только тогда, когда к одному из коллайдеров прикреплено rigid body.
В *Project Browser* выберите *Prefabs\Enemy*. Добавьте компонент *Rigidbody 2D* и выберите для *Body Type* значение *Kinematic*. Это означает, что на тело не будет воздействовать физика.
Добавьте *Circle Collider 2D* с *Radius*, равным *1*. Повторите эти шаги для *Prefabs\Enemy 2*.
Триггеры настроены, поэтому монстры будут понимать, что враги находятся в радиусе их действия.
Нам нужно подготовить ещё одну вещь: скрипт, сообщающий монстрам, когда враг уничтожен, чтобы они не вызывали исключение, продолжая огонь.
Создайте новый скрипт *C#* с названием *EnemyDestructionDelegate* и добавьте его к префабам *Enemy* и *Enemy2*.
Откройте в IDE *EnemyDestructionDelegate.cs* и добавьте следующее объявление делегирования:
```
public delegate void EnemyDelegate (GameObject enemy);
public EnemyDelegate enemyDelegate;
```
Здесь мы создаём `delegate` (делегат), то есть контейнер для функции, которую можно передавать как переменную.
> *Примечание*: делегаты используются тогда, когда один игровой объект должен активно уведомлять другие игровые объекты об изменениях. Подробнее об делегатах можно прочитать в [документарции Unity](https://unity3d.com/learn/tutorials/modules/intermediate/scripting/delegates "from the Unity documentation").
Добавьте следующий метод:
```
void OnDestroy()
{
if (enemyDelegate != null)
{
enemyDelegate(gameObject);
}
}
```
При уничтожении игрового объекта Unity автоматически вызывает этот метод и проверяет делегата на неравенство `null`. В нашем случае мы вызываем его с `gameObject` в качестве параметра. Это позволяет всем респондентам, зарегистрированным как делегаты, знать, что враг уничтожен.
Сохраните файл и вернитесь в Unity.
### Даём монстрам лицензию на убийство
И теперь монстры могут обнаруживать врагов в радиусе своего действия. Добавьте к префабу *Monster* новый скрипт *C#* и назовите его *ShootEnemies*.
Откройте в IDE *ShootEnemies.cs* и добавьте в него следующую конструкцию `using`, чтобы получить доступ к `Generics`.
```
using System.Collections.Generic;
```
Добавьте переменную для слежения за всеми врагами в радиусе действия:
```
public List enemiesInRange;
```
В `enemiesInRange` мы будем хранить всех врагов, находящихся в радиусе действия.
Инициализируем поле в `Start()`.
```
enemiesInRange = new List();
```
В самом начале в радиусе действия нет врагов, поэтому мы создаём пустой список.
Заполним список `enemiesInRange`! Добавьте в скрипт такой код:
```
// 1
void OnEnemyDestroy(GameObject enemy)
{
enemiesInRange.Remove (enemy);
}
void OnTriggerEnter2D (Collider2D other)
{
// 2
if (other.gameObject.tag.Equals("Enemy"))
{
enemiesInRange.Add(other.gameObject);
EnemyDestructionDelegate del =
other.gameObject.GetComponent();
del.enemyDelegate += OnEnemyDestroy;
}
}
// 3
void OnTriggerExit2D (Collider2D other)
{
if (other.gameObject.tag.Equals("Enemy"))
{
enemiesInRange.Remove(other.gameObject);
EnemyDestructionDelegate del =
other.gameObject.GetComponent();
del.enemyDelegate -= OnEnemyDestroy;
}
}
```
1. В `OnEnemyDestroy` мы удаляем врага из `enemiesInRange`. Когда враг наступает на триггер вокруг монстра, вызывается `OnTriggerEnter2D`.
2. Затем мы добавляем врага в список `enemiesInRange` и добавляем `EnemyDestructionDelegate` событие `OnEnemyDestroy`. Так мы гарантируем, что при уничтожении врага будет вызвано `OnEnemyDestroy`. Мы не хотим, чтобы монстры тратили боезапас на мёртвых врагов, правда?
3. В `OnTriggerExit2D` мы удаляем врага из списка и разрегистрируем делегата. Теперь мы знаем, какие враги находятся в радиусе действия.
Сохраните файл и запустите игру в Unity. Чтобы убедиться, что всё работает, расположите монстра, выберите его и проследите в *Inspector* за изменениями в списке `enemiesInRange`.
### Выбор цели
Теперь монстры знают, какой враг находится в радиусе действия. Но что они будут делать, когда в радиусе находятся несколько врагов?
Конечно же, они будут атаковать самого близкого к печенью!
Откройте IDE скрипт *MoveEnemy.cs* и добавьте новый метод, вычисляющий этого монстра:
```
public float DistanceToGoal()
{
float distance = 0;
distance += Vector2.Distance(
gameObject.transform.position,
waypoints [currentWaypoint + 1].transform.position);
for (int i = currentWaypoint + 1; i < waypoints.Length - 1; i++)
{
Vector3 startPosition = waypoints [i].transform.position;
Vector3 endPosition = waypoints [i + 1].transform.position;
distance += Vector2.Distance(startPosition, endPosition);
}
return distance;
}
```
Код вычисляет длину пути, ещё не пройденную врагом. Для этого он использует `Distance`, которая вычисляется как расстояние между двумя экземплярами `Vector3`.
Мы воспользуемся этим методом позже, чтобы выяснить, какую цель нужно атаковать. Однако пока наши монстры не вооружены и беспомощны, поэтому сначала мы займёмся этим.
Сохраните файл и вернитесь в Unity, чтобы начать настройку снарядов.
### Дадим монстрам снаряды. Много снарядов!
Перетащите из Project Browser в сцену *Images/Objects/Bullet1*. Задайте для позиции по *z* значение *-2* — позиции по x и y не важны, потому что мы задаём их каждый раз, когда создаём новый экземпляр снаряда при выполнении программы.
Добавьте новый скрипт *C#* с названием *BulletBehavior*, а затем в IDE добавьте в него следующие переменные:
```
public float speed = 10;
public int damage;
public GameObject target;
public Vector3 startPosition;
public Vector3 targetPosition;
private float distance;
private float startTime;
private GameManagerBehavior gameManager;
```
`speed` определяет скорость полёта снарядов; назначение `damage` понятно из названия.
`target`, `startPosition` и `targetPosition` определяют направление снаряда.
`distance` и `startTime` отслеживают текущую позицию снаряда. `gameManager` вознаграждает игрока, когда он убивает врага.
Назначаем значения этих переменных в `Start()`:
```
startTime = Time.time;
distance = Vector2.Distance (startPosition, targetPosition);
GameObject gm = GameObject.Find("GameManager");
gameManager = gm.GetComponent();
```
`startTime` мы задаём значение текущего времени и вычисляем расстояние между начальной и целевой позициями. Также, как обычно, получаем `GameManagerBehavior`.
Для управления движением снаряда добавим в `Update()` следующий код:
```
// 1
float timeInterval = Time.time - startTime;
gameObject.transform.position = Vector3.Lerp(startPosition, targetPosition, timeInterval * speed / distance);
// 2
if (gameObject.transform.position.Equals(targetPosition))
{
if (target != null)
{
// 3
Transform healthBarTransform = target.transform.Find("HealthBar");
HealthBar healthBar =
healthBarTransform.gameObject.GetComponent();
healthBar.currentHealth -= Mathf.Max(damage, 0);
// 4
if (healthBar.currentHealth <= 0)
{
Destroy(target);
AudioSource audioSource = target.GetComponent();
AudioSource.PlayClipAtPoint(audioSource.clip, transform.position);
gameManager.Gold += 50;
}
}
Destroy(gameObject);
}
```
1. Мы вычисляем новую позицию снаряда, используя `Vector3.Lerp` для интерполяции между начальной и конечной позициями.
2. Если снаряд достигает `targetPosition`, то мы проверяем, существует ли ещё `target`.
3. Мы получаем компонент `HealthBar` цели и уменьшаем её здоровье на величину `damage` снаряда.
4. Если здоровье врага снижается до нуля, то мы уничтожаем его, воспроизводим звуковой эффект и вознаграждаем игрока за меткость.
Сохраните файл и вернитесь в Unity.
### Делаем крупные снаряды
Разве не будет здорово, если монстр начнёт на высоких уровнях стрелять снарядами побольше? К счастью, это легко реализовать.
Перетащите игровой объект *Bullet1* из *Hierarchy* во вкладку *Project*, чтобы создать префаб снаряда. Удалите из сцены исходный объект — нам он больше не понадобится.
Дважды продублируйте префаб *Bullet1*. Назовите копии *Bullet2* и *Bullet3*.
Выберите *Bullet2*. В *Inspector* задайте полю *Sprite* компонента *Sprite Renderer* значение *Images/Objects/Bullet2*. Так мы сделаем Bullet2 немного больше, чем Bullet1.
Повторите процедуру, чтобы изменить спрайт префаба *Bullet3* на *Images/Objects/Bullet3*.
Далее в *Bullet Behavior* мы настроим величину урона, наносимого снарядами.
Выберите во вкладке *Project* префаб *Bullet1*. В *Inspector* вы увидите *Bullet Behavior (Script)*, в котором можно присвоить *Damage* значение *10* для *Bullet1*, *15* для *Bullet2* и *20* для *Bullet3* — или любые другие значения, какие вам понравятся.
> *Примечание*: я изменил значения так, чтобы на более высоких уровнях цена за урон становится выше. Это препятствует тому, чтобы апгрейд позволил игроку улучать монстров на самых лучших точках.
*Префабы снарядов — размер увеличивается с уровнем*
### Изменение уровня снарядов
Назначим разным уровням монстров разные снаряды, чтобы более сильные монстры уничтожали врагов быстрее.
Откройте в IDE *MonsterData.cs* и добавьте в `MonsterLevel` следующие переменные:
```
public GameObject bullet;
public float fireRate;
```
Так мы зададим префаб снаряда и частота стрельбы для каждого уровня монстров. Сохраните файл и вернитесь в Unity, чтобы завершить настройку монстров.
Выберите в Project Browser префаб *Monster*. В *Inspector* разверните *Levels* в компоненте *Monster Data (Script)*. Задайте для *Fire Rate* каждого из элементов значение *1*. Затем задайте параметру *Bullet* у Element 0, 1 и 2 значения *Bullet1*, *Bullet2* и *Bullet3*.
Уровни монстров должны быть настроены следующим образом:
Снаряды убивают врагов? Да! Откроем огонь!
### Открываем огонь
Откройте в IDE *ShootEnemies.cs* и добавьте следующие переменные:
```
private float lastShotTime;
private MonsterData monsterData;
```
Как понятно из названий, эти переменные отслеживают время последнего выстрела монстра, а также структуру `MonsterData`, которая содержит информацию о типе снарядов монстра, частоту стрельбы и так далее.
Зададим значения этих полей в `Start()`:
```
lastShotTime = Time.time;
monsterData = gameObject.GetComponentInChildren();
```
Здесь мы присваиваем `lastShotTime` значение текущего времени и получаем доступ к компоненту `MonsterData` этого объекта.
Добавим следующий метод, чтобы реализовать стрельбу:
```
void Shoot(Collider2D target)
{
GameObject bulletPrefab = monsterData.CurrentLevel.bullet;
// 1
Vector3 startPosition = gameObject.transform.position;
Vector3 targetPosition = target.transform.position;
startPosition.z = bulletPrefab.transform.position.z;
targetPosition.z = bulletPrefab.transform.position.z;
// 2
GameObject newBullet = (GameObject)Instantiate (bulletPrefab);
newBullet.transform.position = startPosition;
BulletBehavior bulletComp = newBullet.GetComponent();
bulletComp.target = target.gameObject;
bulletComp.startPosition = startPosition;
bulletComp.targetPosition = targetPosition;
// 3
Animator animator =
monsterData.CurrentLevel.visualization.GetComponent();
animator.SetTrigger("fireShot");
AudioSource audioSource = gameObject.GetComponent();
audioSource.PlayOneShot(audioSource.clip);
}
```
1. Получаем начальную и целевую позиции пули. Задаём позицию z равной z `bulletPrefab`. Раньше мы задали позицию префаба снаряда по z таким образом, чтобы снаряд появлялся под стреляющим монстром, но над врагами.
2. Создаём экземпляр нового снаряда с помощью `bulletPrefab` соответствующего `MonsterLevel`. Назначаем `startPosition` и `targetPosition` снаряда.
3. Делаем игру интереснее: когда монстр стреляет, запускаем анимацию стрельбы и воспроизводим звук лазера.
### Собираем всё вместе
Настало время соединить всё. Определим цель и сделаем так, чтобы монстр смотрел на неё.
В скрипте *ShootEnemies.cs* добавим в `Update()` такой код:
```
GameObject target = null;
// 1
float minimalEnemyDistance = float.MaxValue;
foreach (GameObject enemy in enemiesInRange)
{
float distanceToGoal = enemy.GetComponent().DistanceToGoal();
if (distanceToGoal < minimalEnemyDistance)
{
target = enemy;
minimalEnemyDistance = distanceToGoal;
}
}
// 2
if (target != null)
{
if (Time.time - lastShotTime > monsterData.CurrentLevel.fireRate)
{
Shoot(target.GetComponent());
lastShotTime = Time.time;
}
// 3
Vector3 direction = gameObject.transform.position - target.transform.position;
gameObject.transform.rotation = Quaternion.AngleAxis(
Mathf.Atan2 (direction.y, direction.x) \* 180 / Mathf.PI,
new Vector3 (0, 0, 1));
}
```
Рассмотрим этот код шаг за шагом.
1. Определяем цель монстра. Начинаем с максимально возможного расстояния в `minimalEnemyDistance`. Обходим в цикле всех врагов в радиусе действия и делаем врага новой целью, если его расстояние до печеньки меньше текущего наименьшего.
2. Вызываем `Shoot`, если прошедшее время больше частоты стрельбы монстра и задаём `lastShotTime` значение текущего времени.
3. Вычисляем угол поворота между монстром и его целью. Выполняем поворот монстра на этот угол. Теперь он всегда будет смотреть на цель.
Сохраните файл и запустите игру в Unity. Монстры начнёт отчаянно защищать печенье. Мы наконец-то закончили!
Куда двигаться дальше
---------------------
Готовый проект можно скачать [отсюда](https://koenig-media.raywenderlich.com/uploads/2017/09/TowerDefense-Part2-Complete.zip "here").
Мы проделали в этом туториале большую работу и теперь у нас есть отличная игра.
Вот несколько идей для дальнейшего развития проекта:
* Больше типов врагов и монстров
* Различные маршруты врагов
* Разные уровни игры
Каждый из этих аспектов потребует минимальных изменений и сможет сделать игру более увлекательной. Если вы создадите на основе этого туториала новую игру, то я с радостью сыграю в неё, поэтому поделитесь, пожалуйста, ссылкой на неё.
Интересные мысли о создании хитовой игры в жанре tower defense можно найти в этом [интервью](http://www.raywenderlich.com/30636/top-developer-interviews-ironhide-game-studio "Making a Hit Tower Defense Game: A Top App Dev Interview"). | https://habr.com/ru/post/413915/ | null | ru | null |
# Автоматизируем ведение большого количества пользователей в AD
Автоматизируем ведение большого количества пользователей в AD:
Добрый день! В этой статье я бы хотел описать применённое мной практическое решение по автоматизации одной рутинной задачи второй линии технической поддержки одного крупного предприятия.
Имеем два территориально распределённых домена AD по 10 000 человек, применённое решение по организации Веб-доступа к удаленным рабочим столам через приложения RemoteApp с несколькими интегрированными информационными системами и активно пополняющаяся база, человек так на 500 в месяц. На ~24 в рабочий день, на ~3 человека в час.
Первый очевидный вывод из входных данных – на таком количестве пользователей один админ не справится, у него должно быть право заболеть/уйти в отпуск не парализовав предприятие. А практика показывает, что и два не справляются.
Вторая проблема – идентификация личностей, допустим на файловых ресурсах предприятия, как это часто бывает, имеется информация, не предназначенная для посторонних глаз, и соответственно необходимо проверять каждого запросившего доступ на внесение в Active Directory и предоставления определённых групп доступа. К сожалению, без бюрократии в решении этого вопроса обойтись не удалось. Процедура сводится к подаче бумажной заявки в форме максимально стандартизированной, за подписью (желательно электронной) руководителя заявляющего и одобрением данного документа лицами знакомыми лично с подписантом.
После одобрения стандартизированной заявки остается дело за малым, внести людей в AD, присвоить необходимые группы доступа, и внести в excel табличку. Последний пункт может показаться немного архаичным, ведь AD вполне себе поддерживает аудит изменений, но моя практика показывает, что на таком обороте этот пункт не является лишним, а даже упрощает процесс поиска граблей в случае разбора полётов, который не редко возникает, следуя из первого вывода.
Но процесс можно немного автоматизировать, применив пару нехитрых скриптов. Логика сводится к обратному процессу:
1. Утверждаем стандарт внесения Учётных Записей в AD на предприятии
2. Запрашиваем у пользователя данные едином формате.
3. Вносим в таблицу основные данные, например:
4. Экспортируем из Excel в CSV файл, автоматически сгенерированную страницу, пригодную для автоматического занесения в AD при помощи скриптов
5. Экспортируем и вуаля! Остаётся передать логин и пароль пользователю.
Возможно описанные мной методы нельзя назвать best practice, однако они позволяют на практике решить существующую проблему без написания отдельно информационной системы и создания большого количества интеграций.
Далее я опишу пару технических моментов и опубликую скрипты которыми пользуюсь:
Так выглядит таблица пригодная для импорта в AD:
У меня эта таблица генерируется автоматически из предыдущей, пример [прилагаю](https://disk.yandex.ru/i/moOyY5LlvINbcQ).
Сохранять таблицу пригодную для импорта необходимо в формате CSV (разделитель – запятые)
Как вы думаете какими будут разделители если открыть сгенерированный файл блокнотом? Неправильно. Такими – «;»
Отдельно в моей реализации следует остановиться на столбце транслит. В утверждённом нами стандарте часть полей заполняется транслитом по утверждённому образцу и чтобы не делать это каждый раз я использовал vba скрипт, вот он:
```
Function TranslitText(RusText As String) As String
Dim RusAlphabet As Variant 'массив из букв русского алфавита
RusAlphabet = Array("-", "а", "б", "в", "г", "д", "е", "ё", "ж", "з", "и", "й", "к", "л", "м", "н", "о", "п", "р", "с", "т", "у", "ф", "х", "ц", "ч", "ш", "щ", "ъ", "ы", "ь", "э", "ю", "я", "А", "Б", "В", "Г", "Д", "Е", "Ё", "Ж", "З", "И", "Й", "К", "Л", "М", "Н", "О", "П", "Р", "С", "Т", "У", "Ф", "Х", "Ц", "Ч", "Ш", "Щ", "Ъ", "Ы", "Ь", "Э", "Ю", "Я")
Dim EngAlphabet As Variant 'массив из букв английского алфавита
EngAlphabet = Array("-", "a", "b", "v", "g", "d", "e", "yo", "zh", "z", "i", "y", "k", "l", "m", "n", "o", "p", "r", "s", "t", "u", "f", "kh", "ts", "ch", "sh", "sch", "", "y", "", "e", "yu", "ya", "A", "B", "V", "G", "D", "E", "Yo", "Zh", "Z", "I", "Y", "K", "L", "M", "N", "O", "P", "R", "S", "T", "U", "F", "Kh", "Ts", "Ch", "Sh", "Sch", "", "Y", "", "E", "Yu", "Ya")
Dim EngText As String, Letter As String, Flag As Boolean
For i = 1 To Len(RusText) 'цикл по всем символам русского текста
Letter = Mid(RusText, i, 1)
Flag = 0
For j = 0 To 67 'цикл по всем буквам русского алфавита
If RusAlphabet(j) = Letter Then 'если символ из текста совпал с буквой из русского алфавита...
Flag = 1
If RusAlphabet(j) = Letter Then 'проверка на регистр (верхний или нижний)
EngText = EngText & EngAlphabet(j) '... то добавляем соответствующую букву из английского алфавита
Exit For
Else
EngText = EngText & UCase(EngAlphabet(j))
Exit For
End If
End If
Next j
If Flag = 0 Then EngText = EngText & Letter 'если символа из текста в алфавите нет (например, знаки препинания и т.п.), то добавляем символ без изменения
Next i
TranslitText = EngText
End Function
```
Не делайте как я, пожалуйста, используйте один из существующих стандартов транслитерации по [ссылке](https://habr.com/ru/post/499574/).
Следующий же скрипт помещённый в файл с расширением .ps1 позволит вам в пару кликов закинуть все учётные записи из сгенерированного на предыдущем шаге файла в AD, как бы много их там не было. А заодно и навесить на все созданные УЗ группу ad-group.
```
Import-Module activedirectory
Import-Csv "C:\generated.csv" -Encoding default -Delimiter ';'| ForEach-Object {
New-ADUser -Server DOMEN.RU -Name $_.FirstName `
-DisplayName $_.DisplayName `
-GivenName $_.GivenName `
-Surname $_.LastName `
-Initials $_.Initials `
-OfficePhone $_.Phone `
-Description $_.Description `
-UserPrincipalName $_.UserPrincipalName `
-SamAccountName $_.samAccountName `
-Email $_.mail `
-Path "OU=TEST_OU,OU=Guest,OU=Users,OU=DOMEN,DC=DOMEN,DC=RU" `
-AccountPassword (ConvertTo-SecureString $_.Password -AsPlainText -force) -Enabled $true
Set-ADuser $_.samAccountName -ChangePasswordAtLogon $True
Add-AdGroupMember -Identity ad-group -Members $_.samAccountName
}
``` | https://habr.com/ru/post/553666/ | null | ru | null |
# Cli-IDE для Oracle СУБД. Ну. Почти IDE
Добрый день.
Первый вопрос: зачем, есть же Toad/SQL-developer/PLSQL-developer и т.п. графические ide-среды.
Ну. Да. Есть. Однако не всем именно они нужны, как средство работы с объектами oracle-субд.
Т.е. я тут, в этой статье - не именно для oracle-разработчиков буду рассказывать что то. Скорее для dba, т.е. людей у которых работа с объектами субд - значительно более специфичная, им не нужен такой ide-комбайн как Toad/SQL-developer/PLSQL-developer;
Второй момент: сейчас: удалёнка, везде и всюду. В этой связи доступ на работу - организовывается удалённый.
Либо: через что то типа VDI/RDP. Либо: выдаётся рабочий ноутбук и от на нём, с него - работай.
В первом случае - ну, часто подразумевается графический интерфейс удалённого рабочего стола и: виндовый и с ограничением по ресурсам.
Во втором случае: ну, организации часто пытаются и тут сэкономить - выдадут что нибудь с 8Гб оперативы и - как хочешь, так на этом и работай. Т.е.: файрфокс/хром, с N>>10 кол-вом вкладок, какой нибудь Toad/SQL-developer/PLSQL-developer, скайп/зум, ещё что то.
В обоих случаях: возникает вопрос - а как то бы тут сэкономить, на ресурсах, например - на IDE для oracle-субд.
Ну и, как мне кажется, находится, под этот запрос, интересный проект: [VoraX](https://github.com/talek/vorax4)
Проект, на настоящее время, абандонед, увы.
Вот хочу, по ряду причин, обратить внимание сообщества на этот проект. С одной стороны - чтобы больше народу посмотрело, с разных сторон и что то, какие то за/против увидели/оценили.
С другой стороны - уже появились, у меня, к этому проекту хотелки, но, не понятно как к ним подступится - нет ни времени, ни ресурса этим заниматься. Может быть тоже - кто то подскажет. А то и: свой форк запилит: штука то - весьма интересная.
В русскояз-м сегменте интернета практически нет упоминаний об этом проекте, есть упоминание воракса, в [хабр-комменте](https://habr.com/ru/post/247487/#comment_8214333), одного из контрбьютеров воракс-проекта.
В функционально-пользовательском смысле про возможности/свойства воракс-а отлично рассказывает автор проекта, [здесь](https://www.youtube.com/watch?v=9PSQNQhYKhY&t=90s).
В инженерно-техническом смысле это - vim-плагин. Часть кода плагина: собственно дополнительные vim-функции, обеспечивающие работу в пользовательском инт-се. Часть - это руби-скрипты, которым выполняется, например, запуск-взаимодействие с sqlplus, работа с репозиторем подключений.
Т.е. воракс - это честная скл-сессия в субд, со всеми отсюда вытекающими последствиями: возможность выполнять транзакции из нескольких команд, например. Во всяких dbext, vim-dadbod, Emacs в скл-моде: такого не получится - они, при выполнении каждой конкретной скл-команды: запускают скл-плюс, подключаются в бд, выполняют команду, получают результат, закрывают соединение в бд.
Ещё часть, релевантного к воракс-у, руби-кода распространяется в виде gem-пакета с именем "vorax", который надо доставлять в руби отдельно. В этом гем-е проверяются и, если надо, предварительно ставятся зависимости, в частности `racc` gem. Ему, этому gem-пакету, нужен ruby-dev ОС-пакет, его надо ставить в систему.
Соответственно: требуется, установленными на машине: `ruby`, `vim` с поддержкой ruby, oracle-клиент (можно инстант-клиент).
На LinuxMint - всё это ставится без проблем, я делал так:
```
apt install gawk bison libffi-dev libgdbm-dev libncurses-dev libsqlite3-dev libyaml-dev zlib1g-dev -y
apt install sqlite3 libgmp-dev libreadline-dev checkinstall libxml2-dev libxslt-dev -y
apt install build-essential ruby-dev pkg-config -y
ruby -v
gem install vorax
gem list | sort
```
Потом сборка vim-а, с поддрежкой ruby:
```
mkdir ~/Vim4VoraX; cd ~/Vim4VoraX
git clone https://github.com/vim/vim.git
cd ./vim/src/
#make distclean
./configure --enable-rubyinterp --with-features=huge
make
./vim --version | grep ruby; pwd
sudo apt remove vim
sudo checkinstall --pkgname vim4vorax4 --pkgversion 8.2.0 --install
#dpkg -r vim4vorax4
#in vim:
#:ruby puts RUBY_VERSION
```
Затем [патоген-ом](https://github.com/tpope/vim-pathogen) доставил собственно vorax-плагин в vim, использовал более современный форк, уважаемого [kish4ever](https://habr.com/ru/users/kish4ever/):
```
cd ~/.vim/bundle && git clone https://github.com/kakash1hatake/vorax4.git
```
При установке кода вим-плагина руками, так [как это описывает автор](https://github.com/talek/vorax4/wiki/Installation-Guide), плагин полностью работоспособным не становился. Не знаю может тут что то с кривизной моих рук. Патоген-менеджер vim-плагинов - мне помог.
Ну. Пара-тройка скринов, мы все - любим скрины:
Дока есть вот [тут](https://github.com/talek/vorax4/wiki) и в файле `/vorax4/doc/vorax.txt` - здесь и далее: путь относительный, от директории куда ставился vim-плагин.
Из некоторых вкусностей, которые успел заметить за те два дня что разглядываю этот плагин:
1. Профили подключения: шифруются, хранятся в виде xml-файла `profiles.xml`, в, по умолчанию, домашнем каталоге. Профиль-менеджер, технически, это скрипт: `/vorax4/vorax/ruby/lib/vorax/profiles_manager.rb`
2. Есть некий функционал, задающий режим отображения выхлопа селект-команд, в окне (точнее: буфере, если в vim-терминах) вывода. Бегло: поддерживается аппенд-мода вывода, поддерживается лимитирование строк в выборке (дописывается `WHERE ROWNUM <= :limit`), подерживается задание режима в котором не усекаются имена полей, если они длинее ширины столбца, есть Топ-режим отображения. Есть ещё несколько функций. Конечно можно выполнять set-команды и прочие команды склплюс-а и задавая какое то своё форматирование. Однако, в остальном - это всё тот же склплюс, со своими плюсами и минусами, касательно вывода. Об этом - несколько ещё поговорю, ниже. В правом нижнем углу окна вывода - подсказывается текущая мода отображения.
3. Вот про выполнение команд и всякое форматирование: есть режим `E`: т.н.: sanbdox-мода. В ней можно выполнить какой то скл-скрипт, который может выполнять свои склплюс-команды настройки скл-сессии. При этом, настройки скл-сессии самого воракс-а, из которого был, в такой моде выполнения, вызван некий скл-скрипт - будут запомнены, а после выполнения скрипта - восстановлены. Also: поддерживается обработка sigint сигналов 2,9 при выполнении команд - они посылаются склплюс-у. Also: поддерживается выполнение конкретной команды, на которой стоит курcор (или то что выделено, в visual-моде ), в верхнем vim-окне.
4. plsql-подпрограммы, их определение, можно получить из объектного вьювера, в отдельный буфер (в терминах vim-а), просто встав на элемент в тривью и жмакнув "Enter". Что тут интересно - конкретно вот этот буфер, его содержимое, при попытке изменить-скомпилировать ддл-код процедурного объекта, воракс будет отправлять в субд as is, цитирую:
> The default key mapping for compiling is c. "C" stands, obviously, for "C"ompile. For convenience, you may also use @. Two things happen when a PLSQL object is compiled:
>
>
> \* the buffer content is sent as it is to the server.
>
> \* as soon as the buffer content is executed, Vorax will check the ALL\_ERRORS view to see if any relevant errors exist. If such errors are found, they are loaded into a Vim quickfix window, along with the error line, error column and the message itself.
>
> Note: Pay attention that during the compilation of an PLSQL object, the substitution variables feature is disabled.
>
>
Проблемки (ну. с моей т.з.):
Спулинг выборок из воракс-а в файл. Формально - работает. Однако выясняется что воракс, обменивается с склплюс-ом (читает/пишет на/с стдоут/стдин) данными особенным образом - он обрамляет пользовательский текст в свои текстовые брекеты. Взаимодействие с склплюс - делается скриптом: `/vorax4/vorax/ruby/lib/vorax/sqlplus.rb`, там это выглядит, например, таким образом (пара скринов):
В итоге, в спул-файл, выписывается, кроме самой выборки - ещё куча служебных строк, от обмена данными между воракс-ом и склплюс-ом. Всё это - обходится конечно, но надо сделать дополнительные усилия, для обхода.
Второй момент.
Разглядывая склплюсовое форматирование выборок, в окне вывода, в воракс-е, вспомнил про `SQLcl`: какой он весь из себя модный-молодёжный, как там всё здорово с форматированием выборок. Ну и: тут же пришла в голову мысль о ~~костыле~~ рационализаторско-конструкторском усовершенствовании - а пуркуа бы и не па вписать в `/vorax4/vorax/ruby/lib/vorax/sqlplus.rb` вместо вызова бинаря `sqlplus`, вызов `sql`;
Да, виновен/мне стыдно: на тот момент ещё не знал что SQLcl - вызывается шельником `/sqlcl/bin/sql`, который запускает ява-процесс, к которым и взаимодействует пользователь.
Поэтому, конечно, тут ничего не получилось: воракс - честно запускал шельник `/sqlcl/bin/sql` и потом выдавал ошибку - ой что то оно не отвечает.
Плюс, не известно - как бы ещё SQLcl реагировал, на эти текстовые брекеты воракс-а, типа `#set blockterm`, которыми он окружает текст пользовательских команд, получаемых от пользователя.
Пробовалось вписать, в вызов явы, в функции run в шелнике `/sqlcl/bin/sql` ехес-команду баш-а, т.е., вот так:
```
function run {
if [ "m$SQLCL_DEBUG" != "m" ]; then
echo "JAVA=$JAVA"
echo "JAVA_OPTS=${APP_VM_OPTS[@]}"
echo "DEBUG=$DEBUG"
echo "CPLIST=$CPLIST"
echo "LD_LIBRARY_PATH=$LD_LIBRARY_PATH"
echo "exec $JAVA $CUSTOM_JDBC $CYGWIN "${APP_VM_OPTS[@]}" -client $SQLCL_DEBUG -cp "$CPLIST" oracle.dbtools.raptor.scriptrunner.cmdline.SqlCli "
fi
exec $JAVA $CUSTOM_JDBC $CYGWIN "${APP_VM_OPTS[@]}" -client $SQLCL_DEBUG -cp "$CPLIST" oracle.dbtools.raptor.scriptrunner.cmdline.SqlCli "$@"
}
```
Не выгорело, так же - сбоит.
Отдельно оговорюсь: в руби/яве - не понимаю ничего.
Собственно, зачем обращаю внимание собщества на этот проектик.
Интересны отзывы о этой штуке, может быть кто пользовался/пользуется, может рассказать плюсы/минусы которые с опытом работы становятся видны.
Ещё любопытно, как бы скрестить воракс-а с SQLcl, может быть есть, какие то, у кого то идеи об этом?
Так же, вопрос, какие ещё есть/знаете варианты работы с oracle-субд через cli-приложения, сопоставимые, или более продвинутые чем воракс, т.е.: коннекшен-менеджмент, обжект-браузер, и вот это вот всё.
Спасибо за внимание, ваше время.
UPD1: [пример](http://vorax-ide.blogspot.com/2010/09/how-to-install-vorax-on-cygwin.html) установки VoraX в CYGWIN
UPD2: Обнаружил что работает автодополнение кода, omnicompletion, в инсерт-моде, по ctrl-x,ctrl-o получается такое:
UPD3: в cli-тему и заодним, порекламирую такую cli-утилитку: "oratop - Utility for Near Real-time Monitoring of Databases, RAC and Single Instance (Doc ID 1500864.1)"; Этакий top, для oracle-субд, поясняющие [гугл-картинки](https://www.google.com/search?q=oratop%20utility&tbm=isch&hl=ru&safe=off&tbs=rimg:CVRIyrgGojQtYSoSGFAXbc2S) со скринами экранов утилиты. | https://habr.com/ru/post/539118/ | null | ru | null |
# Next js. Куда, откуда и причем здесь google?
Прошло уже почти 2 недели с момента презентации next 11. К сожалению, эта новость обошла хабр стороной и пора бы это исправить. Сперва немного о презентации. Это был сайт, на котором странным образом были видны цветные курсоры и время от времени рядом с ними печатался текст. Немного поразмышляв и прочитав первый комментарии стало понятно, что передо мной такие же участники этого события. Неплохое и многообещающее интро. Однако, это был, пожалуй, единственный намек на то, чего стоит ждать от презентации. Веб-серфинг не принес никаких результатов и не удалось найти ни слова о предстоящей конференции. Конечно же, используя next последние несколько лет можно было примерно представлять, какие технологии должны вот-вот появиться с полноценной поддержкой, понять, кто будет помогать в их реализации и какие цели будет преследовать компания.
Пару слов о технологии, если кто-то умудрился обойти ее стороной. *Next* – backend-фреймворк для… Инкрементальной сборки, Серверного рендеринга, статической генерации или гибридного варианта приложений, построенных на react. Созданием занималась компания **zeit**, имеющей к 2016г. утилиту **now**. Затем, в 2020 году, после инвестиций в 21 млн$, компания была переименована в **vercel**, а утилита *now* (переименованная также в *vercel*) переросла в веб-сервис с дополнительным функционалом для выкладки приложений, в первую очередь, построенных на *next*, но также *nuxt*, *Gatsby*, *angular* и многих других популярных инструментов.
Количество загрузок с npmБуквально сразу после релиза next стал одним из самых популярных js backend фреймворков, уступая лишь по некоторым моментам **express.js**
График удовлетворенности, интереса, использования и узнаваемости, согласно stateofjs.comТеперь, мимоходом вернемся к истокам. Пару слов о том, с чего все начиналось.
Работа над некстом, судя по [первому коммиту](https://github.com/vercel/next.js/commit/04578072ec60eb9e5c5e1b6787ed695a16e4529e), началась 6 октября 2016г и уже 25 октября в блоге на сайте *zeit.co* появилась первая статья с описанием нового фреймворка для серверного рендеринга приложений, написанных на react. С тех пор началось активное развитие и улучшение фреймворка.
В 2016 году это был фреймворк, умеющий серверный рендеринг для страниц в каталоге pages (без дополнительных библиотек для роутинга), отрабатывать логику на сервере и передавать ее результат компоненту страницы, добавлять теги в сайта, простую установку и настройку. Однако, в нем нельзя было настраивать кастомные конфигурации для вебпака, бейбела, стилизация только из next/css и многого другого (большинство из этих проблем были известны и уже [планировались](https://github.com/vercel/next.js/blob/1.2.3/README.md#future-directions)).
Можно долго рассказывать обо всех изменениях в next за эти годы – это и появление SSR, SSG, ISR, и обновление на ts, и amp, и ускорение сборки и многое, многое другое – было сделано действительно крайне много полезного функционала и улучшений, но статья все-таки именно про историю нововведений, поэтому, вернемся в наши дни.
К счастью, презентация прошла без синих экранов, поэтому мы смогли насладиться этим мероприятием. Начал ее, конечно же, уже упомянутый Гильермо Рауч (*Guillermo Rauch*), доделавший свой кофе. Сперва мы услышали о результатах компании, росте популярности в последние месяцы, большом комьюнити и сотрудничестве с *Google* и *Facebook*, важности девелоперского опыта и о том, как *next* постарался, чтобы все изменения происходили быстро и с сохранением всех состояний на странице. Тем самым плавно переходя к первому нововведению.
Команда *zeit* практически с самого начала появления *vercel* делала на этот сервис немалый упор, добавляя поддержку новых технологий и новый функционал – аналитика, оптимизации приложений, ssl и другое. Теперь к этому списку добавилась еще одна опция – именно она была задействована в том, многообещающем интро, из начала статьи – **real-time collaboration**. Делиться, комментировать, обводить и редактировать код, все это – прямо из окна браузера благодаря коллаборации в реальном времени. У команды версел уже был опыт добавления реал-тайма в некст – при переходе режима разработки с фетч-запросов на вебсокеты в некст 8. Для нового функционала *vercel* выбрала не классический подход с вебсокетами, а **replicache**. Разница в том, что *replicache* не передает по вебсокетам никакой информации, а лишь посылает приложению сигналы, что произошло какое-то изменение.
Выглядит потрясающе и то, как это настроено под адаптив.
Однако, без странных поломок не обошлось [[твит](https://twitter.com/ragingwind/status/1404903130232352768?s=20)].
В целом, это действительно крутой инструмент для совместной работы. Кажется, что тут уже и добавить нечего. Если только видеосвязь в углу, но это будет не инструмент для совместной разработки, а какой-то онлайн офис.
Теперь, когда кофе слегка подостыл, Гильермо Рауч – обведя изображение и написав, что оно слишком тяжелое – завершил рассказ об онлайн коллаборации и передал слово следующему герою конференции – Лидии Халли.
Изображения действительно занимают значимую часть сайта не только относительно размеров страницы, но и относительно ее веса. Для добавления оптимизированных изображений на сайт в html были добавлены тег и , и атрибут srcset для и `![]()`. Можно было создать отдельный компонент и в него передавать разные форматы и размеры изображения и получать , с оптимизированными под все экраны изображениями. То есть проделать 2 шага – сжать изображения и передать их в компонент. Однако, *vercel* решили пойти дальше и снять с нас первый шаг. С 10 версии *next* умеет автоматически сжимать все изображения, чуть позже была добавлена возможность сжимать их любой полюбившейся вам библиотекой. Также, компонент автоматически добавляет атрибуты *width* и *height*. Тем не менее, даже оптимизированные изображения могут подпортить метрики, если они находятся в первом экране. Поэтому, следующим нововведением, которым с нами поделилась Лидия, стал **placeholder** для изображений.
Буквально недавно я столкнулся с этой проблемой – первое изображение портило LCP. В качестве вариантов решения были – предзагрузка изображения, загрузка в высоком приоритете (то есть, по сути, сделать ленивую загрузку для всего остального, в т.ч. шрифтов) и загрузка с плейсхолдером. Были опробованы все варианты и явного улучшения не было заметно ни в одном из подходов. Будет интересно посмотреть на результаты тестов в решении некста. В любом случае, это решение полностью автоматическое и опробовать его не составит труда.
Здесь стоит немного остановиться и отметить то, насколько некст ценит разработческий опыт. Эта нить тянется с самых истоков фреймфорка – простота разработки и внедрения, понятная документация, примеры, простой переход на новые версии
Единственное, что можно сказать по изображениям так это то, что изображениям не хватает конвертирования в современные форматы из коробки (webp, JPEG 2000, JPEG XR, AVIF). Пока что, назвать этот функционал завершенным, к сожалению сложно, но его развитие не может не радовать.
В завершении своей части Лидия поблагодарила комьюнити и контрибьютеров из гугл – Алекса Касла (*Alex Castle*) и Джуна Пака (*Joon Park*). Google начали принимать активное участие в разработке некста в 2019 году – к релизу next 9. Целью коллаборации было повышение производительности и оптимизация собираемых приложений. Результаты не заставили себя долго ждать и уже к версии 9.1.7 были показаны результаты этого сотрудничества – уменьшение веса клиентского бандла на 3-8%. В версии 9.2 уже знакомый нам Алекс Касл проработал новый метод фрагментации кода, что уменьшило вес приложений у [Barnebys](https://www.barnebys.com/) на 23% ([подробнее](https://nextjs.org/blog/next-9-2#improved-code-splitting-strategy)). Подобные коллаборации не только дают помощь по улучшению старого кода, но и помогают с внедрением функционала под свои новые сервисы и метрики. Так, в мае 2020 года, google представила новый подход к метрикам – **web vitals**. Буквально на следующей неделе в next.js был добавлен метод “**reportWebVitals**” для страниц, позволяющий отслеживать эти метрики и отправлять их на сервер или в google аналитику. И на этом история не заканчивается, ведь 15 июня текущего года, google представила нам проект «[Аврора](https://web.dev/introducing-aurora/#introducing-aurora)», нацеленный на сотрудничество с open-source продуктами и на их развитие. В эту команду вышел, в том числе, упомянутый выше Алекс Касл.
Теперь Гильермо передает слово Шуби Пэникер (*Shubhie Panicker*), одной из участниц проекта Авроры. Гугл стояли у истоков современных подходов к проектированию приложений и сейчас они стремятся поделиться своим опытом и ресурсами, чтобы вместе сделать веб лучше. Шуби делится, что лучший подход к повышению производительности приложений – переложить максимум работы по оптимизациям на фреймворки, ведь для разработчиков этот вопрос не столь важен. Здесь можно поспорить, но безусловно смысл идеи верен, ведь абстрогировавшись от вопросов стандартных оптимизаций (вроде сжатия изображений, оптимизации шрифтов) разработчики смогут заняться более сложными вопросами и работать над новыми идеями повышения производительности или сосредоточиться на самом проекте.
Первым, над чем работал именно проект «Аврора» стал **conformance** – инструмент, представляющий новый подход к обработке ошибок приложения. По сути, он сочетает в себе *eslint*, проверки *typescript* и ошибки компилятора *next*, а также дополнительные правила, так или иначе связанные с *web vitals* – как добавлены скрипты, изображения и ссылки. Не терпится увидеть и новый способ отображения ошибок в *next* [[подробнее](https://web.dev/conformance/#conformance-in-next.js)].
В целом, ошибки в next это отдельная история, полная изменений и переделок в поисках чего-то идеального. И началось это с самого создания next. Так, первая переработка отображения ошибок была уже в третьей версии
Затем в четвертой версии, они были вновь изменены, но описание расположения ошибки было неполным, поэтому очередное изменение не заставило себя долго ждать и было в пятой версии
Шестая версия, на удивление, обошлась без изменений. Однако, команда версел поняла, что такой вариант на самом деле не сильно удобен для изменений и вновь переработали ошибки в 7 версии, сделав комбинацию из третьей и пятой версии.
Это был неплохой вариант и он продержался вплоть до next 9.4, к релизу которого стало понятно, что отображение ошибок в полный экран не столь удобно для комьюнити
Это было удобно, но все еще не идеально. Хочется верить, что новый вариант будет добавлен в ближайшее время и задержится с нами надолго, потому что выглядит он гораздо удобнее, чем то, что было сделано до этого. Однако, этот функционал все еще не завершен и даже не был представлен в официальном релизе.
Затем, слово было передано другому участнику Авроры – Хусейну Джирде. Первым делом Хусейн использовал команду для использования conformance – next lint и мы смогли увидеть проблемы, влияющие на производительность
Скриншот из конференцииИз сообщений об ошибках и из речи Хусейна мы вспоминаем о важности сторонних скриптов и стилей для реального бизнеса. Но, если стили *css*(после *next 9.2*) и *sass*(после *next 9.3*) с импортами и модулями *next* поддерживал из коробки, то для скриптов никакого инструментария не было. Поэтому, следующим шагом, речь пошла о теге . Важной частью этого тега является то, что мы не просто можем добавить внешние скрипты на страницу, а указать, когда именно он должен загружаться – `beforeInteractive` (до загрузки всех бандлов приложения), `afterIntercative` (после гидрации приложения) и `lazyOnload` (после браузерного события *onload*).
Далее Хусейн поведал нам о том, что 80% сайтов используют кастомные шрифты. Если честно, то я думал, что этот процент должен быть выше, но не суть. Зачастую эти шрифты подгружаются из *google fonts*. Google уже говорили о том, что устанавливать шрифты подобным образом – плохая идея. Но этим способом продолжают пользоваться, ведь у этого были явные плюсы – простота добавления и шрифты после загрузки могли быть доступны из кеша для любого сайта. Это было возможно вплоть до 2020 года, когда гугл ввел раздельный кеш, тем самым сделав его уникальным для каждого сайта и отменив один из плюсов. Теперь, Хусейн представил нам новый подход к оптимизации шрифтов – инлайн во время сборки шрифтов, загружаемых из *google fonts* и *adobe typekit*, что было еще одним полезным и действительно нужным нововведением.
Это был последний функционал, представленный нам в презентации, однако, были добавлены и другие интересные моменты и кратко о них:
*Next.js 11* будет использовать `createRoot`, когда *react* перейдет на альфу 18 версии. Приятно видеть, как *next* сотрудничает с другими инструментами. Так, например, была завезена поддержка *babel 7*, когда он еще был на стадии бета тестирования, также было с *webpack4* и *webpack5*. *Webpack 5*, кстати, после версии *next10.2* включен по умолчанию (после версии *next9.5* можно было включить опцию, когда *webpack* был версии *5.0.0-beta.30*).
Команда `npx @next/codemod cra-to-next` для обновления приложения, созданного командой CRA, в next приложение.
---
Это была действительно интересная презентация, я услышал именно то, чего так хотел услышать. У некста богатая история, большое комьюнити, стабильный рост и развитие. Особенно радует участие команды google, вложивших немало идей в это обновление и помогающих их внедрять.
При релизе 10 версии казалось, что внедрили уже все, о чем только можно было подумать. Однако *vercel* вышли за рамки моих мыслей и добавили коллаборацию в реальном времени. Новый формат отображения ошибок(несмотря на постоянные переработки) в этот раз стал неожиданностью. Уже не терпится опробовать, но пока еще *next* ничего об этом не говорили и на данный момент речь шла лишь об обновлении линтера под специфические правила, что тоже крайне полезно.
Хусейн закончил свою часть фразой «We love working with great frameworks to help developers make the web faster». Фраза «make the web faster» стала символом этой презентации и коллаборации с гугл. Уверен, Аврора принесет нам еще много света. А мы, под светом богини, продолжим делать веб быстрее. | https://habr.com/ru/post/565122/ | null | ru | null |
# Интеграция phpBB в сайт (Codeigniter). Сквозная авторизация
Несколько недель назад по некой нужде было необходимо добавить форум в только что написанный сайт. Сайт на этапе завершения, пользователей раз-два и обчелся. Сайт был написан на Codeigniter. В качестве форума был выбран phpBB, как один из распространенных free форум версии **3.1.1**. После несложных манипуляций форум без проблем был установлен. Стало интереснее, когда дело дошло до пользователей.
Первым делом я решил поискать готовые решение дабы не тратить ни свое время, ни время клиента. Была найдена уже не рабочая ссылка на библиотеку phpBB3\_library, были найдены плагины для WP, и др. движков, но мне хотелось сделать интеграцию безболезненно для себя и моего детища (сайта) и форума.
Недолго погуглив, нашел вот эту [статью](https://wiki.phpbb.com/Authentication_plugins), с которой и началось мое погружение в глубины пользовательской функциональности phpBB.
### Постановка задачи
1. Сделать безболезненную интеграцию. Должен быть один реализующий класс. Без изменений в движке форума, дабы при обновлении форума ничего не слетело.
2. Максимальное использование функций форума в нашем классе. Городить велосипед не хочется.
3. Реализовать совместную регистрацию, смену пароля, авторизацию, конец сеанса, блокировку и отмену блокировки пользователя на основе уже существующего функционала форума.
### Анализ
После чтения доков, стало понятно, что функции управления пользователями размещаются в <корень форума>/includes/functions\_user.php, а авторизация в <корень форума>/phpbb/auth/provider. В этой папке размещены функции для нескольких вариантов авторизации. Тип авторизации задается в панели администрирования форума, раздел «Общие -> Аутентификация». Я поставил значение по умолчанию — Db.
В принципе, необходимый функционал я нашел в этих двух файла, кроме обновления данных пользователя. Далее приступаем к реализации.
### Начальные данные
1. Сайт, реализованный с помощью codeigniter.
2. Форум phpBB.
3. Таблица с пользователями сайта — USERS.
4. Таблица с пользователями форума — phpbb\_USERS.
5. Регистрация/авторизация пользователей на сайте — переделанная под свои нужды библиотека [Codeigniter Auth](http://code-igniter.ru/wiki/%D0%A1%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D0%B0%D0%B2%D1%82%D0%BE%D1%80%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D0%B8_Ion_Auth).
### Решение
Задача поставлена, надо делать.
Перед началом — несколько нюансов.
1. Необходимо отключить регистрацию пользователей на сайте. Это делается в панели администратора (Общие -> регистрация пользователей -> Разрешить смену имени пользователя -> Нет). Разрешаем пользователю регистрацию только на сайте.
2. Запрещаем смену имени пользователя (Общие -> Регистрация пользователей -> Активация аккаунта -> Отключено).
3. Запрещаем авторизацию с форума. Авторизацию и выход делаем только с сайта. Сделал «в лоб» — в файле <корень форума>/ucp.php сделал редиректы на соответствующие страницы на сайте. (см. строки «case 'login':», «case 'login\_link':», «case 'logout':». Редирект «header('Location: /auth/login');» и «header('Location: /auth/logout');»).
4. На сайте (если есть функция redirect()) заменить функцию redirect(), например на ciredirect(), дабы избежать конфликта имен — в phpBB есть функция с аналогичным названием.
Для codeigniter создаю библиотеку my\_phplib.php (библиотека в codeigniter — это некий вспомогательный, подключаемый класс, располагающийся в папке application/libraries. В нем нет ничего необычного, так что пользователи других движков/фрейморков — не унывайте).
Итак, содержимое библиотеки:
**Библиотека my\_phplib.php**
```
php if (!defined('BASEPATH')) exit('No direct script access allowed');
class My_phpbblib
{
public $phpBB_user;
public $phpBB_auth;
public $phpBB_db;
public $table_prefix;
public function __construct(){
// определяем видимые переменные.
global $phpbb_root_path,
$phpEx,
$user,
$auth,
$cache,
$db,
$config,
$template,
$table_prefix,
$request,
$phpbb_container,
$symfony_request,
$phpbb_filesystem,
$phpbb_log,
$phpbb_path_helper,
$phpbb_dispatcher;
// Без константы никуда...
define('IN_PHPBB', TRUE);
// корневая папка форума.
$phpbb_root_path = './forum/';
// расширение подключаемых файлов. В нашем случае - php
$phpEx = substr(strrchr(__FILE__, '.'), 1);
// подключаем файлы
// конфигурационные файлы
include($phpbb_root_path . 'common.' . $phpEx);
include($phpbb_root_path . 'config.php.' . $phpEx);
// Функции для работы с пользователями
include($phpbb_root_path . 'includes/functions_user.' . $phpEx);
// разрешим супер глобальные массивы...
$request-enable_super_globals();
// запускаем сессию пользователя
$user->session_begin();
$auth->acl($user->data);
$this->phpBB_user = $user;
$this->phpBB_auth = $auth;
$this->phpBB_db = $db;
$this->table_prefix = $table_prefix;
}
// регистрация
public function registration($data = array()) {
// если данные есть, можно попробовать поработать с ними
if(count($data) < 3){
// нам надо как минимум 3 элемента - логин, пароль и email
return false;
}
$new_phphBB_user = array();
// логин пользователя.
if(isset($data['username'])) return false;
$new_phphBB_user['username'] = $data['username'];
// пароль пользователя
if(isset($data['user_password'])) return false;
$new_phphBB_user['user_password'] = phpbb_hash($data['user_password']);
// email пользователя
if(isset($data['user_email'])) return false;
$new_phphBB_user['user_email'] = $data['user_email'];
// группа пользователя.
// по умолчанию в phpBB3 следующие группы
// - 1 - GUESTS - гость (незарегистрированный пользователь)
// - 2 - REGISTERED - Зарегистрированный пользователь
// - 3 - REGISTERED_COPPA - Зарегистрированный пользователь COPPA
// - 4 - GLOBAL_MODERATORS - Супер-модераторы
// - 5 - ADMINISTRATORS - Администраторы
// - 6 - BOTS - Боты
// - 7 - NEWLY_REGISTERED - Новые пользователи.
// по умолчанию регистрируем NEWLY_REGISTERED
$new_phphBB_user['group_id'] = isset($data['group_id']) ? $data['group_id'] : 7;
// тип пользователя.
// есть 4 типа
// - 0 - Обычный пользователь
// - 1 - Неативный пользователь. Ждет активации.
// - 2 - Игнор пользователя (боты)
// - 3 - Суперадмин
// по умолчанию новый пользователь не активный.
$new_phphBB_user['user_type'] = isset($data['user_type']) ? $data['user_type'] : 1;
// сохраняем пользователя в таблицах форума.
$phphBB_user_id = user_add($user_row, false);
// возвращаем id пользователя в таблицах phpBB
return $phphBB_user_id;
}
// авторизация
public function login($data = array()){
$this->phpBB_user->setup('ucp');
// имя пользователя
$username = $data['username'];
// пароль пользователя
$password = $data['user_password'];
// Запомнить пользователя
$autologin = $data['autologin'];
// Показывать пользователя в онлайне
$viewonline = true;
// авторизация средствами phpBB
$result = $this->phpBB_auth->login($username, $password, $autologin, $viewonline);
// result возвращает массив
// array(
// 'status' => status-code(int),
// 'error_msg'=> status-message-id(text),
// 'user_row'=> user-row(array),
// );
// Статусы
// 1 - Не указан пароль
// 3 - успешный вход
// 10 - Неверный логин
// 11 - Неверный пароль
// 12 - Пользователь неактивен
// 13 - Превышен лимит попыток входа
return $result;
}
// выход
public function logout(){
$this->phpBB_user->session_kill();
$this->phpBB_user->session_begin();
}
// удалить пользователя
public function delete_user($mode = 'remove', $user_name = '') {
// $mode = remove/retain - удалить или оставить в базе
// по имени пользователя получить id, так как мы считаем, что id пользователя в форуме - на сайте нам не известен.
$sql = 'SELECT user_id, username
FROM phpbb_users
WHERE username_clean = "'.utf8_clean_string($user_name).'"';
$result = $this->phpBB_db->sql_query($sql);
if (!($row = $this->phpBB_db->sql_fetchrow($result)))
{
$db->sql_freeresult($result);
} do
{
$user_id_ary[] = $row['user_id'];
}
// освобождаем память.
$this->phpBB_db->sql_freeresult($result);
if($user_id_ary){
// если нашли пользователя - удаляем
return user_delete($mode, $user_id_ary, $retain_username = true);
}
return false;
}
// бан пользователю.
public function ban_user($user_name = '', $ban_minutes = 432000, $ban_reason = ''){
// тип бана - устанавливаем по имени пользователя
// бывает - по имени (user), по ип (ip), по email (email)
return user_ban('user', $user_name, $ban_minutes, $ban_len_other = '', $ban_exclude = false, $ban_reason, $ban_give_reason = '');
}
// разбанить пользователя.
public function unban_user($user_name = ''){
// тип бана - устанавливаем по имени пользователя
// бывает - по имени (user), по ип (ip), по email (email)
// по имени пользователя получить id банов
$sql = 'SELECT b.ban_id, u.user_id
FROM phpbb_users u, phpbb_banlist b
WHERE u.username_clean = "'.utf8_clean_string($user_name).'" AND u.user_id = b.ban_userid';
$result = $this->phpBB_db->sql_query($sql);
if (!($row = $this->phpBB_db->sql_fetchrow($result)))
{
$this->phpBB_db->sql_freeresult($result);
}
do
{
$user_ban_id_ary[] = $row['ban_id'];
}
$this->phpBB_db->sql_freeresult($result);
return user_unban('user', $user_ban_id_ary);
}
// обновить данные пользователя.
public function edit_user_pass($user_name ='', $user_pass) {
if (empty($user_name) || empty($user_pass)){
return false;
}
$sql = 'UPDATE ' . $this->table_prefix . 'users
SET user_password="' . md5($user_pass) . '"
WHERE username_clean = "'.utf8_clean_string($user_name).'"';
$this->phpBB_db->sql_query($sql);
return true;
}
}
```
Использование в codeigniter — стандартно — подключаем библиотеку в контроллере, отвечающем за авторизацию.
**Использование my\_phplib.php**
```
function __construct(){
parent::__construct();
$this->load->library('my_phpbblib');
}
// авторизация
public function login(){
/*
Ваш код
*/
$data = array();
$data['username'] = $this->input->post('login');
$data['user_password'] = $this->input->post('pass');
$data['autologin'] = $remember;
// Пробуем авторизироваться и получаем ответ.
$registration_result = $this->my_phpbblib->login($data);
/*
Ваш код
*/
}
// регистрация
public function registration(){
/*
Ваш код
*/
$user_row['username'] = $user_login;
$user_row['user_password'] = phpbb_hash($user_pass);
$user_row['user_email'] = $user_email;
$user_row['group_id'] = 2;
$user_row['user_type'] = 0;
// регистрация пользователя на форуме
$forum_id = $this->my_phpbblib->registration($user_row);
/*
Ваш код
*/
}
// выход
public function logout() {
/*
Ваш код
*/
$this->my_phpbblib->logout($data);
/*
Ваш код
*/
}
// Удалить пользователя.
public function delete($id = 0){
/*
Ваш код
*/
$this->my_phpbblib->delete_user('remove', $user_login);
/*
Ваш код
*/
}
// Сменить пароль пользователю
public function change_pass(){
/*
Ваш код
*/
// изменение пароля на форуме
$this->my_phpbblib->edit_user_pass($user_login, $user_pass);
/*
Ваш код
*/
}
// Заблокировать пользователя.
public function ban(){
/*
Ваш код
*/
// забаним пользователя и на форме.
$b = $this->my_phpbblib->ban_user($user_login, 432000, $ban_reason);
/*
Ваш код
*/
}
// разблокировать пользователя.
public function unban(){
/*
Ваш код
*/
$ub = $this->my_phpbblib->unban_user($user_login);
/*
Ваш код
*/
}
```
Данный способ был проделан с phpBB 3.1.1 и phpBB 3.1.3 (после обновления никакого вмешательства не потребовалось).
Спасибо за внимание.
Буду рад, если статья кому-нибудь поможет. | https://habr.com/ru/post/253773/ | null | ru | null |
# Дерево разделов неограниченной вложенности и URL
В данной статье мы рассмотрим один из возможных подходов к генерации полного пути на раздел, у которого может быть неограниченная вложенность в другие разделы, а также быстрое получение нужного раздела по заданному пути.
Представим, что мы программируем интернет-магазин, в котором должно быть дерево различных разделов, а также должны быть "приятные" ссылки на разделы, которые бы включали все подразделы. Пример: `http://example.com/catalog/category/sub-category`.
Разделы
-------
Самый очевидный вариант — это создать связь на родителя через атрибут `parent_id` и отношение `parent`.
```
class Category extends Model
{
public function parent()
{
return $this->belongsTo(self::class);
}
}
```
Также, у нашей модели имеется атрибут `slug` — заглушка, которая отражает раздел в URL. Она может быть сгенерирована из названия, либо указана пользователем вручную. Самое главное, заглушка должна проходить правило валидации `alphadash` (то есть состоять из букв, цифр и знаков `-`, `_`), а также быть уникальной внутри родительского раздела. Для последнего достаточно создать уникальный индекс в БД `(parent_id, slug)`.
Чтобы получить ссылку на раздел, нужно вытащить всех его родителей последовательно. Функция генерации URL выглядит примерно так:
```
public function getUrl()
{
$url = $this->slug;
$category = $this;
while ($category = $category->parent) {
$url = $category->slug.'/'.$url;
}
return 'catalog/'.$url;
}
```
Чем больше раздел имеет предков, тем больше выполнится запросов в базу. Но это только часть проблемы. Как сформировать маршрут до раздела? Попробуем так:
```
$router->get('catalog/{category}', ...);
```
Скормим браузеру ссылку `http://example.com/catalog/category`. Маршрут сработает. Теперь такую ссылку: `http://example.com/catalog/category/sub-category`. Маршрут уже не сработает, т.к. обратный слэш является разделителем параметров. Хм, значит добавим еще один параметр и сделаем его необязательным:
```
$router->get('catalog/{category}/{subcategory?}', ...);
```
Этот маршрут уже сработает, но если в URL добавить еще один подраздел, то ничего работать не будет. И проблема в том, что количество таких подразделов у нас не ограничено.
Далее, чтобы вытащить нужный раздел из БД, необходимо сначала найти раздел с идентификатором `category`, затем, если указан, подраздел `subcategory` и т.д. Все это доставляет неудобства и сильнее нагружает сервер, количество запросов пропорционально количеству подразделов.
### Оптимизация
Сильно сократить количество запросов нам поможет расширение для laravel [kalnoy/nestedset](https://github.com/lazychaser/laravel-nestedset). Оно призвано упростить работу с деревьями.
### Установка
Установка очень проста. Для начала нужно установить расширение через composer:
```
composer require kalnoy/nestedset
```
Модели понадобится два дополнительных атрибута, которые необходимо добавить в новой миграции:
```
Schema::table('categories', function (Blueprint $table) {
$table->unsignedInteger('_lft');
$table->unsignedInteger('_rgt');
});
```
Теперь только нужно удалить старые отношения `parent` и `children`, если они были заданы, а также добавить trait `Kalnoy\Nestedset\NodeTrait`. После обновления наша модель выглядит так:
```
class Category extends Model
{
use Kalnoy\Nestedset\NodeTrait;
}
```
Однако, значения `_lft` и `_rgt` не заполнены, чтобы все заработало, остался последний штрих:
```
Category::fixTree();
```
Данный код "починит" дерево на основе атрибута `parent_id`.
### Упрощенная генерация
Процесс генерации URL выглядит так:
```
public function getUrl()
{
// Получаем заглушки всех предков
$slugs = $this->ancestors()->lists('slug');
// Добавляем заглушку самого раздела
$slugs[] = $this->slug;
// И склеиваем это все
return 'catalog/'.implode('/', $slugs);
}
```
Намного проще, правда? Не важно сколько потомков у данного раздела, они все будут получены за один запрос. А вот с маршрутами не все так просто. По-прежнему не получится получить цепочку разделов за один запрос.
### Маршруты
Задача №1. Как задать маршрут до раздела с указанием всех его предков в ссылке?
Задача №2. Как получить весь путь до нужного раздела за один запрос?
#### Описание маршрута
Ответ на первую задачу: *использовать весь путь как параметр маршрута*.
```
$router->get('catalog/{path}', 'CategoriesController@show')
->where('path', '[a-zA-Z0-9/_-]+');
```
Мы просто указываем, что параметр `{path}` может содержать не только привычную строку, но и обратный слэш. Таким образом, этот параметр захватывает сразу весь путь, который следует за контрольным словом `catalog`.
Теперь в контроллере на входе получаем только один параметр, но можем его разбить на все подразделы:
```
public function show($path)
{
$path = explode('/', $path);
}
```
Однако, это не упростило задачу с получением указанного в ссылке раздела.
#### Связка пути с разделом
Итак, как оптимизировать этот процесс? *Хранить полный путь для каждого раздела в БД*.
Допустим, имеется такое простое дерево:
```
- Category
-- Sub category
--- Sub sub category
```
Данным разделам будут соответствовать следующие пути:
```
- category
-- category/sub-category
--- category/sub-category/sub-sub-category
```
Тогда нужную категорию можно получить очень просто:
```
public function show($path)
{
$category = Category::where('path', '=', $path)->firstOrFail();
}
```
Теперь сохраняем в БД то, что до этого генерировали для ссылки, а генерация ссылки теперь значительно упрощается:
```
// Генерация пути
public function generatePath()
{
$slugs = $this->ancestors()->lists('slug');
$slugs[] = $this->slug;
$this->path = implode('/', $slugs);
return $this;
}
// Получение ссылки
public function getUrl()
{
return 'catalog/'.$this->path;
}
```
Если присмотреться к списку путей в примере, то можно заметить, что путь для каждой модели это `путь-родителя/заглушка-модели`. Поэтому генерацию пути можно еще немного оптимизировать:
```
public function generatePath()
{
$slug = $this->slug;
$this->path = $this->isRoot() ? $slug : $this->parent->path.'/'.$slug;
return $this;
}
```
Остается следующая проблема. Когда обновляется заглушка одного раздела, либо раздел меняет родителя, должны обновиться ссылки всех его потомков. Алгоритм простой: получить всех потомков и сгенерировать для них новый путь. Ниже приведен метод обновления потомков:
```
public function updateDescendantsPaths()
{
// Получаем всех потомков в древовидном порядке
$descendants = $this->descendants()->defaultOrder()->get();
// Данный метод заполняет отношения parent и children
$descendants->push($this)->linkNodes()->pop();
foreach ($descendants as $model) {
$model->generatePath()->save();
}
}
```
Рассмотрим более подробно.
В первой строчке получаем всех потомков (за один запрос). `defaultOrder` здесь применяет древовидную сортировку. Смысл ее в том, что в списке каждый раздел будет стоять *после своего предка*. Алгоритм построения пути использует родителя, поэтому необходимо, чтобы родитель обновил свой путь до того, как будет обновлен путь любого из его потомков.
Вторая строчка выглядит немного странно. Смысл ее в том, что она заполняет отношение `parent`, которое используется в алгоритме генерации пути. Если не воспользоваться данной оптимизацией, то каждый вызов `generatePath` будет выполнять запрос для получения значения отношения `parent`. При этом `linkNodes` работает с коллекцией разделов и не делает никаких запросов в БД. Поэтому, чтобы это работало для непосредственных детей текущего раздела, нужно его добавить в коллекцию. Добавляем текущий раздел, связываем все разделы между собой и убираем его.
Ну и в конце проход по всем потомкам и обновление их путей.
Осталось только определиться, когда вызывать данный метод. Для этого отлично подходят события:
1. Перед сохранением модели, проверяем, изменились ли атрибуты `slug` или `parent_id`. Если изменились, то вызываем метод `generatePath`;
2. После того, как модель была успешно сохранена, проверяем, не изменился ли атрибут `path`, и, если изменился, вызываем метод `updateDescendantsPaths`.
```
protected static function boot()
{
static::saving(function (self $model) {
if ($model->isDirty('slug', 'parent_id')) {
$model->generatePath();
}
});
static::saved(function (self $model) {
// Данная переменная нужна для того, чтобы потомки не начали вызывать
// метод, т.к. для них путь также изменится
static $updating = false;
if ( ! $updating && $model->isDirty('path')) {
$updating = true;
$model->updateDescendantsPaths();
$updating = false;
}
});
}
```
### Результаты
Преимущества такого подхода:
* Мгновенная генерация ссылки на раздел
* Быстрое получение раздела по пути
Недостатки:
* Пути хранятся в БД, что несколько увеличивает размер таблицы
* Смена заглушки одного раздела влечет за собой обновление путей всех потомков
По сути, преимущества очень сильно перевешивают недостатки в виду того, что генерировать ссылки и получать разделы нужно гораздо чаще, чем обновлять заглушки; а перерасход пространства путями мизерный.
Товары
------
Рассмотрим подходы к генерации ссылок на товары, которые включали бы в себя путь к разделу. Например: `http://example.com/catalog/category/sub-catagory/product`. Основная проблема здесь в том, чтобы сформировать правильный маршрут.
*Товар, как и раздел, имеет заглушку, которая может быть указана вручную, либо сгенерирована на основе названия. Важно, что эта заглушка должна быть уникальна внутри раздела, чтобы не возникало конфликтов. Лучше всего в БД создать уникальный индекс `(category_id, slug)`.*
Попробуем самый простой вариант и рассмотрим следующие маршруты:
```
// Маршрут до раздела
$router->get('catalog/{path}', function ($path) {
return 'category = '.$path;
})->where('path', '[a-zA-Z0-9\-/_]+');
// Маршрут до товара
$router->get('catalog/{category}/{product}', function ($category, $product) {
return 'category = '.$category.'
product = '.$product;
})->where('category', '[a-zA-Z0-9\-/_]+');
``` | https://habr.com/ru/post/279233/ | null | ru | null |
# Планшет — не роскошь
*«У современных мобильных телефонов такая же вычислительная мощь, что и у компьютеров NASA в 60-е годы. И в то время этого хватало, чтобы запустить человека в космос, а сегодня — только чтобы запускать птиц в свиней.»
Фольклор*
*«Вы назовете это извращением. Но кто сказал, что извращение — это плохо?»
Один доцент нашей кафедры*
Идея описанного ниже эксперимента возникла после серии услышанных и подслушанных высказываний о том, что современные планшеты не могут выступать в роли инструментов серьезной научно-исследовательской деятельности. Действительно, для многих пользователей работа с планшетником сводится к веб-серфингу, переписке по электронной почте и разного протокола мессенджерах, чтению книг, просмотру видео и иным преимущественно развлекательным целям. Также, как следует ожидать и как показывает недавний [пост](http://habrahabr.ru/post/168013/), планшетник является прекрасным мобильным подспорьем при работе с «офисными» приложениями. Однако аппаратные характеристики существующей техники позволяют задуматься — а насколько же эффективным станет планшет на изначальном для компьютеров поприще.
### Техника
Подопытным стал TeXeT TM-7025, с 1 ГГц процессором, 512 Мб оперативной памяти и Android 4.0 на борту. Мой первый компьютер, приобретенный в 2004 году, был чуточку мощнее (Athlon XP 1.66 ГГц, 256 Мб памяти до и 1 Гб — после апгрейда), однако заменен был только в марте 2012, намолотив Фортраном за свою жизнь расчётов на курсовую, а затем в паре с ноутбуком HP 550 — на два диплома, обеспечив успешное окончание школы, бакалавриата и магистратуры по направлению теоретической физики со специализацией на вычислительной гидродинамике.
Стоит сказать, что подопытный планшет имеет 7-дюймовый экран, что резко ограничивает удобство редактирования исходного кода, однако внешний компьютер для этих целей применялся по минимуму. Сторонними средствами написана уже данная статья, хотя, чего греха таить, введение и этот раздел набраны на смартфоне.
### Софт
В силу рода занятий, возиться с портированием доступного софта не собирался даже в предельном случае разбора задачи. Потому, если бы такого не нашлось, то и эксперимента бы не было. Однако, обзор Google Play показал, что в нём [наличествует порт](https://play.google.com/store/apps/details?id=com.octave) [Octave](http://www.gnu.org/software/octave/) на Android. Помимо него, конечно же, имеется и весьма обширный спектр более простых программ, но с их вычислительными возможностями ясности нет, зато Octave — программа известная и небольшой опыт возни с ней уже имеется. Потому выбирать было не из чего, но возможность заодно разобраться и с этой системой более детально стала дополнительным стимулом в работе. Для рисования графиков имеющийся пакет требует установки графического пакета droidplot — портированной тем же автором версии gnuplot.
Естественно, код программы проще писать отдельным текстом и просто загружать его в консоли Octave. В качестве редактора был взял первый подвернувшийся под руку, то бишь бесплатная версия DroidEdit.
### Задача
Пробные запуски были сделаны на системах дифференциальных уравнений. Просто загоняем систему и рисуем график на выходе, всё встроенными функциями Octave. Неинтересно, быстро. Но работает, что воодушевляет.
Тестовой стала небезызвестная система Лоренца, берущая своё начало, как известно, из уравнений конвекции в приближении Буссинеска.
**Исходный код для интегрирования системы Лоренца**
```
function xdot=f(x,t)
r=28.;
s=10.;
b=8./3.;
# система уравнений Лоренца
xdot(1)=s*(x(2)-x(1));
xdot(2)=r*x(1)-x(2)-x(1)*x(3);
xdot(3)=x(1)*x(2)-b*x(3);
endfunction
# временные границы, начальные условия
t=linspace(0.,10.,250);
x0=[7.;10.;5.];
lsode_options("integration method","non-stiff");
y=lsode("f",x0,t);
# график аттрактора в плоскости x-z
plot(y(:,1),y(:,3));
```
В зависимости от управляющего параметра (нормированного числа Рэлея), эта система проходит ряд устойчивых состояний от полного равновесия в нуле до хаотического режима. Сгенерированные на планшете картинки наглядно их демонстрируют. При r = 0.5:
r = 4:
r = 16:
r = 25:
r = 28:
Это всё замечательно, но какая вычислительная гидродинамика без конечно-разностных методов? Следующим этапом доказательства того, что планшет может не только потреблять контент, стало моделирование совершенно стандартной задачи конвекции жидкости в замкнутой полости. В рамках одного из курсов её обязан реализовать каждый студент наших кафедр. Формулировка следующая: рассчитать поле скорости и температуры несжимаемой вязкой жидкости в подогреваемой сбоку квадратной полости. По уму, конечно, разумно бы сперва посмотреть чего попроще, например, задачи теплопроводности, но решено было не мелочиться.
Уравнения сразу даны в безразмерном виде, сокращающем всё многообразие физических параметров задачи до двух — числа Грасгофа Gr и числа Прандтля Pr. На всех границах скорость, и значит — функция тока — равна нулю (условие прилипания для вязкой жидкости), температура слева — 0, справа — 1, на верхней и нижней границе линейно растёт.
Для упрощения, задача рассматривается как двумерная — полость представляется бесконечно протяженным каналом квадратного сечения. Трёхмерные задачи — это гораздо более широкое богатство содержания, но в то же время уже совершенно иной уровень по требованиям к ресурсам, потому их численное моделирование широко развиваться стало только в последние пару-тройку десятилетий. Двумерный же подход позволяет выявить в первую очередь основные, всеобщие свойства гидродинамических систем, с гораздо меньшими усилиями. Прежде всего, связано это с особенностями двумерного течения жидкости — вместо векторных уравнений Навье-Стокса можно перейти к описанию скорости через две скалярные величины (т.н. двухполевой метод) — функцию тока (она же z-компонента векторного потенциала скорости) и завихренность (z-компонента ротора скорости). Примечательны они тем, что, во-первых, при переходе к функции тока автоматически и точно удовлетворяется условие несжимаемости (что и является основной проблемой моделирования в естественных переменных скорость-давление), а, во-вторых, с помощью функции тока крайне удобно изображать поле скорости — её изолинии соответствуют линиям тока, главное, разобраться с направлением течения.
Уравнения двухполевого метода:
### Программа
Программа незамысловата, и являет собой простейшую явную конечно-разностную схему. Потому останавливаться детально на ней незачем. Просто приведу исходник. Даже не особо оптимизированный, хотя с учётом производительности планшета вопросы оптимальности кода становятся крайне существенными.
**Исходный код конечно-разностного метода**
```
a = 8.0;
ap = 8.0;
maxp = 100;
Nx = 10;
Ny = 10;
tmax = 10.;
Gr = 20000.;
Pr = 1.;
eps = 1.0e-2;
# выходные файлы
o1id = fopen("/sdcard/Octave/Convection/psi(t)_Gr=20000.txt","w");
o2id = fopen("/sdcard/Octave/Convection/field_Gr=20000.txt","w");
# массивы/матрицы
# завихренность
phi0 = zeros(Nx+1,Ny+1,"single");
phi1 = zeros(Nx+1,Ny+1,"single");
# функция тока
psi0 = zeros(Nx+1,Ny+1,"single");
psi1 = zeros(Nx+1,Ny+1,"single");
# температура
T0 = zeros(Nx+1,Ny+1,"single");
T1 = zeros(Nx+1,Ny+1,"single");
# вспомогательно-оптимизационные параметры
hx = 1.0 / Nx;
hy = 1.0 / Ny;
hxi = 1.0 / hx;
hyi = 1.0 / hy;
ht = hy**2/ a;
htp = hy**2 / ap;
htx2 = ht*hxi**2;
hty2 = ht*hyi**2;
htxy = 0.25*ht*hxi*hyi;
htpx2 = htp*hxi**2;
htpy2 = htp*hyi**2;
htpxy = 0.25*htp*hxi*hyi;
Pri = 1.0 / Pr;
# метки осей
x = linspace(0.,1.,Nx+1);
y = linspace(0.,1.,Ny+1);
axis("xy");
# начальное распределение
for i = 1:Nx+1
for j = 1:Ny+1
psi0(i,j) = 1.0e-1*(1.0d0 - (i-1)*hx)*(i-1)*hx*(1.0d0 - (j-1)*hy)*(j-1)*hy;
T0(i,j) = (i-1)*hx;
phi0(i,j) = 0.0;
endfor
endfor
ct = 0.;
q = 0;
# цикл по времени
while(ct <= tmax)
# уравнения для phi, T
for i = 2:Nx
for j = 2:Ny
dpsidx = psi0(i+1,j) - psi0(i-1,j);
dpsidy = psi0(i,j+1) - psi0(i,j-1);
phi1(i,j) = phi0(i,j) + ...
(phi0(i+1,j) - 2.*phi0(i,j) + phi0(i-1,j))*htx2 + ...
(phi0(i,j+1) - 2.*phi0(i,j) + phi0(i,j-1))*hty2 + ...
htxy*( dpsidx*(phi0(i,j+1) - phi0(i,j-1)) - dpsidy*(phi0(i+1,j) - phi0(i-1,j)) ) + ...
0.5*ht*hxi*Gr*(T0(i+1,j) - T0(i-1,j));
T1(i,j) = T0(i,j) + Pri*( (T0(i+1,j) - 2.*T0(i,j) + T0(i-1,j))*htx2 + ...
(T0(i,j+1) - 2.*T0(i,j) + T0(i,j-1))*hty2 ) + ...
htxy*( dpsidx*(T0(i,j+1) - T0(i,j-1)) - dpsidy*(T0(i+1,j) - T0(i-1,j)) );
endfor
endfor
# граничные условия
for i = 1:Nx+1
T1(i,1) = (i-1)*hx;
T1(i,Ny+1) = (i-1)*hx;
phi1(i,1) = -2.*Nx*Nx*psi1(i,2);
phi1(i,Ny+1) = -2.*Nx*Nx*psi1(i,Ny);
endfor
for j = 1:Ny+1
T1(1,j) = 0.;
T1(Nx+1,j) = 1.;
phi1(1,j) = -2.*Ny*Ny*psi1(2,j);
phi1(Nx+1,j) = -2.*Ny*Ny*psi1(Nx,j);
endfor
# уравнение Пуассона для функции тока
p = 0;
ppp0 = 0;
ppp1 = 0;
do
for i = 1:Nx+1
for j = 1:Ny+1
psi1(i,j) = 0.;
endfor
endfor
for i = 2:Nx
for j = 2:Ny
psi1(i,j) = psi0(i,j) + htp*phi1(i,j) + ...
(psi0(i+1,j) - 2.*psi0(i,j) + psi0(i-1,j))*htpx2 + ...
(psi0(i,j+1) - 2.*psi0(i,j) + psi0(i,j-1))*htpy2;
ppp0=ppp0 + abs(psi0(i,j));
ppp1=ppp1 + abs(psi1(i,j));
endfor
endfor
for i = 1:Nx+1
psi1(i,1) = 0.;
psi1(i,Ny+1) = 0.;
endfor
for j = 1:Ny+1
psi1(1,j) = 0.;
psi1(Ny+1,j) = 0.;
endfor
for i = 1:Nx+1
for j = 1:Ny+1
psi0(i,j) = psi1(i,j);
endfor
endfor
p = p++;
until(p > maxp || abs(ppp1 - ppp0)/(ppp0+ppp1) < eps)
for i = 1:Nx+1
for j = 1:Ny+1
phi0(i,j) = phi1(i,j);
psi0(i,j) = psi1(i,j);
T0(i,j) = T1(i,j);
endfor
endfor
# максимальное значение функции тока
if(q == 1000)
fprintf(o1id,"%f %f\n",ct,max(max(psi0)));
q = 0;
endif
ct = ct + ht
q++;
endwhile
# поля переменных
for i = 1:Nx+1
for j = 1:Ny+1
fprintf(o2id,"%f %f %f %f %f\n",(i-1)*hx,(j-1)*hy,psi0(i,j),T0(i,j),phi0(i,j));
endfor
endfor
fclose(o1id);
fclose(o2id);
# рисование и сохранение графиков
# в силу невыясненных причин потребовалось транспонировать выводимые матрицы
# как видно, генерируются картинки в eps-формате
# похоже, порт Octave пока попросту других делать не умеет
# можно строить в gnuplot / droidplot
figure(1);
contourf(x,y,T0');
title("T, Gr = 2000");
xlabel("x");
ylabel("y");
saveas(1,"/sdcard/Octave/Convection/T_20000.eps");
figure(1);
contourf(x,y,psi0');
title("Psi, Gr = 2000");
xlabel("x");
ylabel("y");
saveas(1,"/sdcard/Octave/Convection/psi_20000.eps");
```
#### Результаты
Ну, и самое интересное. Скорость и температура жидкости при различной интенсивности подогрева, то бишь — разных Gr. Решения получены на сетке размером 10х10 узлов. Конечно, это тоже немного, однако, когда компьютеры были большими, нормой бывали расчёты и на сетках 4х4, 5х5.
Со значениями основных параметров Gr ~ 10 000, Pr = 1, eps = 0.01 и кодом, приведённым выше, планшет обрабатывает одну единицу безразмерного времени в течение примерно трёх-пяти минут, что вовсе не так уж и медленно, с учётом недостатка памяти, необходимости Android'у выполнять иные системные функции и отвоёвывать на то ресурсы системы, а также и на потенциальную медлительность самой системы Octave как интерпретатора.
При больших Gr расчёт двухвихревого режима течения занимает гораздо больше времени из-за существенного ухудшения сходимости итерационного процесса. Вызвано это ухудшение тем, что двухвихревое течение является не стационарным, а установившимся колебательным процессом — вихри то усиливаются, то ослабевают, попутно изменяя свои размеры в довольно широком диапазоне. Например, Gr = 120 000 на планшете считается примерно часа полтора-два, но и на обычной машине процесс идёт не очень радостно по сравнению со слабым подогревом. Да и улететь в NaN на таком режиме уже легче лёгкого, требуется значительно уменьшать шаг времени. Ускорение алгоритма в данной ситуации — вопрос особый, и требует пересмотра метода решения разностных уравнений.
Итак, полученные картинки. Просто и наглядно — видно, что в полости существует устойчивое вихревое течение и выраженный перенос тепла в первую очередь за счёт движения жидкости — всплывания у нагретой границы и погружения у холодной. При повышении интенсивности подогрева течение сосредотачивается в пограничном слое и переходит в двухвихревой режим. Цветовая шкала не рисовалась, но она стандартная — рост от фиолетового к коричневому через зелёный (как на географических картах).
Функция тока и температура при Gr = 2000:
при Gr = 20000:
и при Gr = 120000:
### Заключение
Планшет — действительно полноценная вычислительная машина. Слабенькая, но упорная. И производить на нём несложные вычисления, скажем, чтобы проверить свежую идею или прикинуть основные направления дальнейшего поиска, абсолютно реалистично.
**Не стоит забывать, что любой компьютер всегда остаётся компьютером в изначальном смысле этого слова.** | https://habr.com/ru/post/168411/ | null | ru | null |
# Числовые подписи
Меня всегда завораживала магия программирования — маленькие фокусы, в которых бессмысленный на первый взгляд код делает что-то интересное. Самые известные из них — «подписи», которые выводят на печать короткий текст (обычно имя автора). В прошлый раз я [показала](http://habrahabr.ru/blogs/crazydev/104084/) несколько таких фокусов, основанных на эзотерических языках программирования, и некоторым читателям они даже пригодились при подготовке новогоднего поздравления :-) Настоящая же магия — это создание таких вещиц на совершенно нормальном языке, который вы используете каждый день, например, на C++ или Java. В этой статье я покажу несколько способов вывести короткий текст с использованием в качестве исходных данных только числовых констант.
###### Disclaimer: большинство приведенных фокусов основаны на низкоуровневых действиях с памятью, поэтому результаты могут варьироваться в зависимости от архитектуры компьютера и используемого компилятора (я пользуюсь gcc).
C++ спокойно относится к маргинальным манипуляциям с памятью и указателями, поэтому обфускации типа задания строки числом — почти обычное дело :-) Самый простой пример:
```
#include
int main()
{ int A = 2037539149;
printf((char \*)&A);
}
```
Как это работает? Первый и единственный обязательный аргумент функции printf — char \* format, задающий формат вывода. Обычно в него передается постоянная строка, а переменные части берутся из следующих аргументов; использование переменной char \* в качестве аргумента тоже работает, хотя и с предупреждением компилятора «format not a string literal and no format arguments».
(char \*)&A трактует адрес переменной A как указатель на массив символов (вне зависимости от того, что хранится в этой переменной на самом деле). Дело за малым: разместить в A байты, которые составят нужное слово, например, Mary -> 0x4D 0x61 0x72 0x79 -> 0x7972614D (на печать символы выводятся в обратном порядке, от младших разрядов к старшим) -> 2037539149.
Ограничение этого метода — он выводит слова длиной до 4 букв, больше в int не поместится. 8 букв можно получить, если заменить int на unsigned long long:
```
#include
int main()
{ unsigned long long A = 8751164009814452552ULL;
printf((char \*)&A);
}
```
Усложним задачу и перейдем с целых чисел на числа с плавающей точкой. В их внутреннем представлении разбирается меньше народу, поэтому это повысит степень обфускации :-)
Самый простой пример:
```
#include
int main()
{ double A = 2.222663600523023e-313;
printf((char\*)&A);
}
```
Как это работает? Да точно так же, только константу для вывода конкретной строки получить немного сложнее. Чтобы вывести «Mary» с переводом строки после имени, нужно иметь в памяти набор байтов 0x4D 0x61 0x72 0x79 0x0A. Для поиска double-константы, которая записывается именно этими байтами, можно использовать следующий хак:
1. Записать в строку нужные байты как шестнадцатеричное число (аналогично первому методу): A7972614D.
2. Из этой строки прочитать число как unsigned long long, но записать его в переменную типа double.
3. Полученную переменную вывести на печать с максимально возможной точностью, например, средствами STL.
```
#include
#include
#include
#include
using namespace std;
int main()
{ double a;
sscanf("A7972614D", "%llx", (unsigned long long \*)&a);
cout << setprecision (numeric\_limits::digits10 + 1) << a << endl;
}
```
При желании можно усложнить код еще, например, задавать числовую константу не непосредственно, а как результат некоторых вычислений. Отлично смотрелось бы получение текста из магических констант pi, e, золотого сечения и т.д. Эта статья была вдохновлена чудной рекурсивной подписью следующего вида (константа изменена):
```
#include
double x = 0.003609087829883, y;
int main() { return(\*(char\*)&x?x\*=y=x,main():printf((char\*)&y)); }
```
Переформатированием и добавлением отладочных выводов можно убедиться, что этот код рекурсивно возводит в квадрат число x и выводит на печать последнюю ненулевую степень (опять же, как строку). Поскольку текст из 4 символов представляется константой порядка 10-300, квадрат этой константы действительно становится нулем. Исходная константа в коде рассчитывается как корень степени двух из константы текста.
Многие языки не позволяют программисту таких вольностей с памятью и типами данных, но можно обойтись более классическим способом — представлением числа в системе счисления, отличной от десятичной. Если бы меня звали Ada, можно было бы ограничиться шестнадцатеричными числами, но Mary требует основания минимум 35, а лучше 36.
```
public class Magic {
public static void main(String[] args) {
System.out.println(Integer.toString(1040398,36));
}
}
```
С уважением,
`370288658856287000618250P` | https://habr.com/ru/post/112831/ | null | ru | null |
# Совместное моделирование быстродействующих систем средствами TIA Portal и Simulink
В этой работе показана детальная авторская реализация объединения сред TIA Portal и Simulink для совместного моделирования с обменом данными, работающая при любом, даже самом малом, шаге квантования (моделирования). Этот вариант позволяет также тестировать PLC контроллеры TIA Portal на частотах квантования контроллеров. Синхронизация сред осуществляется без применения таймеров реального времени. Приведен пример построения быстродействующего контура, обеспечивающего управление аналоговым неустойчивым объектом Simulink виртуальным ПЛК среды TIA Portal. Экспериментально определено, что предлагаемое объединение сред не влияет на результаты моделирования.
### Состояние проблемы
Интегрированная среда разработки систем автоматизации TIA Portal содержит инструментальные средства для конфигурирования, настройки, тестирования и обслуживания систем. Мощная среда MATLAB/Simulink обеспечивает эффективное моделирование и оптимизацию сложных динамических систем. Совместное моделирование TIA Portal и Simulink повышает качество проектирования систем автоматизации и управления и сокращает сроки проектирования.
Известны примеры связи сред TIA Portal – Simulink через OPC сервер, в которых среды обмениваются пакетами данных с максимальной частотой 10 раз с секунду [1,2,3]. Это ограничение определяет максимальную частоту квантования. Для моделирования и работы быстродействующих систем, которые характеризуются широкой полосой пропускания, требуется высокая частота квантования.
Скорость непосредственной передачи/приема данных через TCP канал в десятки раз выше скорости передачи через OPC сервер. Однако, для TCP связи с контроллерами TIA Portal, которые выступают в роли TCP клиента, необходимо, чтобы модель Simulink работала в режиме сервера, а таких библиотечных средств у Simulink нет.
Поиск готовых авторских вариантов объединения средств TIA Portal и Simulink для моделирования быстродействующих процессов дал отрицательный результат. Например, автор [4] сообщает о применении в Simulink собственной S-функции, которая обеспечивает передачу и прием данных, но он не раскрывает код S-функции, детали механизма взаимодействия и синхронизации сред а также влияние взаимодействия на точность моделирования.
Ниже представлен собственный детальный вариант построения системы для совместного моделирования в средах TIA Portal и Simulink с обменом данными, работающей при любом самом малом шаге квантования (моделирования).
### Особенности организации совместного моделирования сред TIA Portal и Simulink
Организация совместного моделирования систем средствами TIA Portal и Simulink с любым шагом моделирования включает следующее.
1. Среды TIA Portal и Simulink связываются TCP каналом передачи данных.
2. Модель Simulink обменивается данными с TIA Portal через TCP сервер, разработанный средствами MATLAB.
3. Сервер обменивается данными на скоростях ниже пропускной способности TCP канала.
4. TIA Portal обеспечивает однократный запуск программного модуля - участника совместного моделирования, каждый раз в момент приема данных от Simulink сервера.
### Пропускная способность TCP
Для совместного моделирования, например, систем управления, необходимо, чтобы на каждом шаге моделирования контроллер среды TIA Portal (или его модель) принимал данные о состоянии Simulink модели и возвращал модели управляющее воздействие. Время совместного моделирования напрямую зависит от пропускной способности канала передачи данных.
Тестирование пропускной способности TCP канала: “клиент ПЛК TIA Portal – виртуальный Ethernet адаптер Siemens – сервер MATLAB” (Рисунок 1) дало следующие результаты.
* Частота однонаправленной побайтовой передачи данных командами MATLAB fwrite равна 3000 Байт/c.
* Частота обмена байтами (на каждом такте использовались команды fwrite и fread) составляет примерно 300 приемопередач в cекунду.
* При обмене данными в формате Double (LReal), когда каждое число состоит из 8 байт и используются команды fwrite и fread, частота практически не отличается от частоты побайтового обмена в 300 приемопередач в cекунду.
Приведенные результаты тестирования показывают, что применение TCP канала позволяет обеспечить совместную работу TIA Portal и MATLAB на максимальной частоте квантования около 300 Гц.
**Рисунок 1**. Сетевое взаимодействие MATLAB – виртуальный PLC контроллер TIA Portal. Только один клиент может быть подключен к серверу. У каждого объекта сетевой пары (сервер и клиент) должна быть уникальная совпадающая комбинация IP адреса и порта (как показано на рисунке).
### Пример построения системы управления для совместного моделирования средствами TIA Portal и Simulink
Для проверки последовательности реализации и качества совместного моделирования были построены два контура управления одинаковыми неустойчивыми аналоговыми объектами второго порядка с одинаковыми дискретными ПИД регуляторами. Первый “образцовый” контур реализован только средствами Simulink. Регулятор второго контура построен на базе ПЛК TIA Portal, а объект управления моделируется средствами Simulink. Прием сигнала рассогласования и передача воздействия, вычисляемого ПЛК, осуществляется через TCP канал.
Подготовка к совместному моделированию выполнена в следующей последовательности.
1. Использование средств MATLAB/Simulink.
1.1 Построен контур управления неустойчивым объектом с дискретным ПИД регулятором (Рисунок 2).
**Рисунок 2**. Модель Simulink контура управления аналоговым неустойчивым объектом второго порядка (выделен желтым).
1.2 Методом оптимизации “Tune” (Рисунок 3) для шага моделирования 10 мс найдены оптимальные параметры дискретного ПИД регулятора.
ПРИМЕЧАНИЕ. Оптимизация ПИД регулятора в MATLAB не нашла устойчивый вариант управления объектом (Рисунок 2) при шаге моделирования 0.1 с - минимальном шаге систем с OPC серверами.
**Рисунок 3**. Характеристики контура управления (Рисунок 2) при шаге моделирования 10 мс. Верхний ряд: параметры оптимального ПИД-регулятора. Нижний ряд: частотные характеристики объекта и разомкнутого контура (Open-loop) с запасом по амплитуде 16,7 dB и фазе 69 град; реакция контура на ступенчатое воздействие (Reference tracking) с перерегулированием 16.2%.
1.3 Средствами Simulink PLC coder [5] код регулятора модели (блок PLC\_reg, Рисунок 2) переведен в SCL код ПЛК контроллера TIA Portal:
```
FUNCTION_BLOCK PLC_reg
VAR_INPUT
ssMethodType: INT;
in: LREAL;
END_VAR
VAR_OUTPUT
out: LREAL;
END_VAR
VAR_IN_OUT
END_VAR
VAR
Filter_DSTATE: LREAL;
Integrator_DSTATE: LREAL;
c_rtb_FilterCoeffici: LREAL;
END_VAR
CASE ssMethodType OF
0:
Filter_DSTATE := 0.0;
Integrator_DSTATE := 0.0;
1:
c_rtb_FilterCoeffici := ((2.91953906295837 * in) - Filter_DSTATE) * 188.820552673467;
out := ((18.4564752234922 * in) + Integrator_DSTATE) + c_rtb_FilterCoeffici;
Filter_DSTATE := (0.01 * c_rtb_FilterCoeffici) + Filter_DSTATE;
Integrator_DSTATE := ((28.4060096566942 * in) * 0.01) + Integrator_DSTATE;
END_CASE;
END_FUNCTION_BLOCK
```
1.4 Разработан TCP сервер для обмена данными в формате double.
Код MATLAB функции для запуска сервера, передачи/приема данных и остановки сервера:
```
function PLC_out = TCPserverDouble(PLC_in)
persistent init_Server;
persistent tcpServer;
persistent PLC_val;
if (isempty(init_Server))
PLC_val = 0;
init_Server = 0;
if ~isempty(tcpServer)
fclose(tcpServer);
delete(tcpServer);
end
end
if init_Server == 0
init_Server = 1;
tcpServer = tcpip('192.168.0.1', 2000, 'NetworkRole', 'server');
fopen(tcpServer);
end
if init_Server == 1
pause(0.01);
fwrite(tcpServer, fliplr(typecast(double(PLC_in),'uint8')));
if get(tcpServer,'BytesAvailable') > 7
PLC_val = typecast(uint8(flipud(fread(tcpServer, 8))),'double');
end
end
PLC_out = PLC_val;
end
```
1.5 К модели (Рисунок 2) добавлен контур управления однотипным объектом (Рисунок 4) взаимодействующий с ПЛК TIA Portal через TCP сервер. Обмен данными через сервер дает задержку на один такт. Для выравнивания процессов в первый контур также внесена задержка (z-1) на 1 такт. Введенный экстраполятор нулевого порядка (Zero-Order Hold) поддерживает взаимодействие аналоговой и дискретной частей модели такое же, как и в первом контуре.
**Рисунок 4**. Два однотипных контура управления. Верхний контур (опорный) реализован только средствами Simulink. Нижний контур дает результат при совместной работе ПЛК TIA Portal и Simulink. Описанный выше TCP сервер тактируется блоком “Interpreted MATLAB Function”.
1.6 Настроены параметры модели на запуск и остановку сервера. Для этого имя функции для работы с сервером TCPserverDouble введено в поле вызова “Property Inspector à Properties à Callbacks à SetupFcn” а команда окончания работы сервера clear TCPserverDouble введена в поле вызова “Property Inspector à Properties à Callbacks à StopFcn”.
2. Использование средств TIA Portal.
2.1. В свойствах проекта TIA Portal установлен флажок “Support simulation during block compilation”.
2.2. На базе библиотечных блоков TCON, TDISCON, TSEND и TRCV (Рисунок 5) построен TCP канал передачи-приема LReal данных для ПЛК (PLC1[CPU 1515-2 PN]) клиента с IP адресом 192.168.0.1:2000.
**Рисунок 5**. Библиотечные блоки TCP канала: TCON, TDISCON, TSEND и TRCV.
2.3. Построен блок (Рисунок 6) для однократного выполнения SCL программы регулятора (см. код п.1.3). Программа запускается импульсами TRCV\_NDR блока TRCV (Рисунок 5), которые формируется каждый раз после успешного приема данных. Выполнение программы заканчивается передачей выходного сигнала регулятора в TCP канал. Инверсный сигнал TCON\_Req обеспечивает установку регулятора в исходное состояние (обнуление интегральной составляющей и фильтра дифференциальной составляющей), когда вход Method равен нулю.
**Рисунок 6**. Блок SCL программы регулятора. Запуск однократного выполнения программы обеспечивается импульсами TRCV\_NRD блока TRCV (Рисунок 5) . Сброс регулятора обеспечивается инверсным сигналом TCON\_Req когда вход Method равен нулю.
2.4. Построен блок (Рисунок 7) для перевода формата Bool переменной TCON\_Req в Integer. Формируемая переменная Method (Рисунок 6) переключает режимы работы регулятора: модули CASE 0 и CASE 1 программы SCL (см. п. 1.3). Модуль CASE 0 обнуляет фильтр дифференциальной составляющей и интегральную составляющую регулятора. Модуль CASE 1 обеспечивает работу регулятора.
**Рисунок 7**. Блок преобразования формата переменной.
### Последовательность запуска совместного моделирования
Запуск TIA Portal и Simulink выполняется в следующей последовательности.
1. Запускается симулятор ПЛК S7-PLCSIM Advanced. IP адрес ПЛК симулятора должен быть настроен на IP адрес ПЛК клиента TIA Portal: блок TCON структуры PLC\_1[CPU 1515-2 PN] (Рисунок 5).
2. Компилируется программа структуры PLC\_1[CPU 1515-2 PN].
3. Программа загружается в Симулятор нажатием на клавишу .
4. Включается мониторинг структуры Main[OB1] .
5. Запускается объект PLC\_1[CPU 1515-2 PN]:
6. Запускается Simulink модель . После запуска сервер модели ожидает подключение ПЛК клиента при неизменном положения индикатора:
ПРИМЕЧАНИЕ. Запуск Simulink модели можно выполнить на любом предыдущем этапе.
7. После запуска Simulink модели подключается ПЛК клиента к TCP сети установкой переменной TCON\_Req в состояние “1” (TRUE):
8. Совместное моделирование TIA Portal и Simulink начинает работу. Результаты моделирования, показанные на Рисунок 8, Рисунок 9 и Рисунок 10, отображаются графопостроителями Scope (Рисунок 4). Переключение входного воздействия в процессе работы совместной модели достигается переключением блока Manual Switch (Рисунок 4).
ПРИМЕЧАНИЕ. В ряде случаев, для обеспечения работоспособности TCP соединения, необходимо приостановить защиту компьютера: отключить файервол и/или антивирусную программу.
### Результаты тестирования
Демонстрационная система управления была построена с применением средств TIA Portal и Simulink. Задачу ПИД регулятора решал ПЛК среды TIA Portal, неустойчивый объект управления второго порядка реализован средствами Simulink. В процессе совместной работы контроллер принимает от Simulink сигнал рассогласования и возвращает Simulink воздействие, прикладываемое к объекту.
Сравнение результатов совместного моделирования системы управления средствами TIA Portal и Simulink с результатами моделирования такой же системы только средствами Simulink (Рисунок 8, Рисунок 9, ) показывает 100% совпадение. Это означает, что выборочное совместное моделирование быстродействующих систем управления с шагом моделирования 10 мс и 1 мс выполнено без ошибок.
**Рисунок 8**. 100% совпадение реакции (integrator1, Рисунок 4) самостоятельного контура модели системы управления Simulink и реакции (integrator3, Рисунок 4) совместного моделирования TIA Portal и Simulink системы управления с аналогичной структурой и параметрами (Рисунок 4).
**Рисунок 9.** 100% совпадение выходов регулятора (слева) и реакций систем управления (в центре) вычисляемых Simulink отдельно и совместно Simulink и TIA Portal c шагом моделирования 10 мс (Рисунок 4). Параметры регуляторов контуров приведены в таблице справа.
**Рисунок 10.** 100% совпадение выходов регулятора (слева) и реакций систем управления (в центре) вычисляемых Simulink отдельно и совместно Simulink и TIA Portal c шагом моделирования 1 мс (Рисунок 4). Параметры регуляторов контуров приведены в таблице справа.
**Диагностика TCP соединения**
При установке TCP соединения первым должен подключаться сервер переводом в режим “open”, а затем клиент.
Если при работе соединения клиента переходит в состояние “closed”, то соединение через некоторое время меняет статус “ESTABLISHED” на “CLOSE\_WAIT”. При последующей попытке вернуть клиента в режим “open” MATLAB выдает сообщение об ошибке: Unsuccessful open: Connection refused: connect. Такое же сообщение MATLAB выдает при попытке подключения клиента когда сервер отсутствует. В таких случаях, для восстановления TCP соединения необходимо отключить и сервер и клиент (перевести в состояния “closed”), а затем повторить процедуру установки соединения.
Для тестирования сетевых устройств ПК были задействованы следующие команды MATLAB.
* Распечатка в окне Command Window списка активных реальных и виртуальных сетевых Ethernet адаптеров и их IP адресов:
`>> !ipconfig`
* Определение локального адреса компьютера:
`>> [name,address] = resolvehost("localhost")`
* Получение списка активных портов TCP:
`>> !netstat -a -n -p TCP`
### Заключение
1. Разработанная организация совместного моделирования TIA Portal – Simulink с TCP каналом работает при любом шаге моделирования.
2. Показанное объединение сред позволяет тестировать PLC контроллеры TIA Portal на частотах квантования контроллеров.
3. Моделирование систем обеспечивается с неограниченной полосой пропускания, в отличии от вариантов, когда среды моделирования связаны через OPC сервер.
4. Доработка (изменения) структуры и параметров программных модулей, создаваемых приложением Simulink PLC coder для TIA Portal не требуется.
5. Результат совместного моделирования сред TIA Portal и Simulink на 100% совпадает с результатами моделирования выполненных для сравнения только средствами Simulink.
6. Синхронизация сред моделирования не требует применения таймеров реального времени.
7. Синхронизация сред обеспечивается введением паузы в блок связи с TIA Portal модели Simulink.
8. Шаг модели устанавливается без учета величины паузы, однако пауза должна превышать время обмена данными между средами.
9. Увеличение паузы не влияет на результаты моделирования, хотя и приводит к увеличению времени моделирования.
10. Разработанный метод совместного моделирования TIA Portal – Simulink с применением TCP связи может быть распространен и на взаимодействие других сред с использованием других каналов передачи данных.
### Библиографический список
1. [Siemens Controls](https://www.youtube.com/playlist?list=PL762SfoJC-e9l5BALU0tJeJyM1ZraK1zE). [PID16 - Siemens PID06e - OPC UA Client in Matlab - Simulink Exchanges Data with PLC via OPC UA](https://www.youtube.com/watch?v=bmivi9Vx2x8).
2. U. Yavuz, “Real-Time Communication between S7-1200 PLC and Matlab/Simulink and a Fuzzy Logic Temperature Humidity Control Application”, Scientific Journal of Mehmet Akif Ersoy University, Volume 2, Issue 1, pp 7-14, 30 January 2019
3. [Dr. Bob Davidov](https://portalnp.snauka.ru/author/bobdavidov). [Подключение PLC контроллеров к MATLAB через TIA Portal OPC сервер](https://disk.yandex.ru/i/CSyumK9Q5APvvg). <https://portalnp.snauka.ru/2022/08/10938>
4. [Integration of Simatic S7-1200 with the Matlab Simulink environment Examples](https://www.youtube.com/watch?v=fJpb1UHAZcs).
5. [MathWorks. PLC coder: General](https://www.mathworks.com/help/plccoder/ug/plc-coder-general.html). | https://habr.com/ru/post/689654/ | null | ru | null |
# Для чего компании нужен UI KIT? (Frontend + Design)
*В этой статье мы расскажем, что такое UI KIT, для чего он нужен, и как он сэкономит время и деньги.*
В статье мы подойдем к китам, которые сделаны не только дизайнерами, но также переведены в компоненты фронтенд-разработчиками.
### Что такое UI KIT?
Это единый набор элементов пользовательского интерфейса. Выглядят они примерно так:
### Для чего он нужен?
#### 1. Единый стиль всех проектов
Все ваши информационные системы будут идентичными. Клиенты будут узнавать вашу компанию по одинаковым элементам. Также им будет удобнее работать с каждым вашим новым продуктом, так как им будут знакомы все элементы и их поведение.
> Начало проекта всегда подразумевает создание первых базовых элементов ui-kita на основе утвержденного концепта.
>
> Основная причина — это унификация элементов интерфейса, что сокращает и упрощает работу в дальнейшем в сложных проектах, чтобы избежать ошибок в дальнейшем. И помогает скоординировать работу с разработчиками, чтобы получить дизайн единообразным на разных страницах одного проекта.
>
> К счастью для нас прошло времена Photoshop и на рынке появилась для бога избранных Sketch (маководы ликуют), а уж позже Figma. Что в разы упростило работу для дизайнера. Всеми любимые компоненты позволили делать изменения в разы быстрее, буквально в один клик, что позволяет не бегать по всем экранам и не проверять, где там цвет поменялся, а где нет.
>
> **Андрей Залетов**
>
> Senior UI/UX designer KOTELOV
>
>
#### 2. Экономия на разработке
Если нет кита, компании, нанимая подрядчика заполняют бриф, далее подрядчик разрабатывает с нуля дизайн, далее создает компоненты на фреймворках JavaScript (Angular, React, Vue). То есть заказчик каждый раз платит за дизайн и программирование одних и тех же элементов на фронтенде разным подрядчикам, причем элементы получаются у всех разные по дизайну и коду, что не позволяет масштабироваться. В случае с китом вы платите 1 раз.
**3. Мгновенный доступ к UI KIT у всей команды**
Аналитики, дизайнеры, разработчики имеют доступ к киту по ссылке. Могут самостоятельно ознакомиться со всеми элементами, правилами их использования и создавать прототипы, фронтенд и дизайн.
**4. Скорость разработки**
При готовом UI KIT вы имеете все элементы, такие как кнопки, поля ввода, таблицы, графики уже задизайнены и переведены в компоненты (на JS). Вы можете собирать системы, не тратя время на дизайн и разработку. Также упрощается прототипирование, если раньше вы составляли прототипы из простых форм, то сейчас можете собирать их из настоящего дизайна.
**Почему важно делать UI KIT, если кнопку или поле можно отрисовать и запрограммировать достаточно быстро?**
Большинству пользователей кнопка представляется, как всего лишь прямоугольник с текстом посередине:
Вот так выглядит код кнопки на React:
```
// Core
import * as React from "react";
// Styles
import styles from "./BadButton.module.scss";
interface BadButtonProps {
children: React.ReactNode;
background?: string;
color?: string;
}
const BadButton: React.FC = (props) => (
{props.children}
);
// Exports
export default BadButton;
```
А вот так выглядит удобная кнопка, которая делает взаимодействие с системой удобной:
Так выглядит код кнопки здорового человека:
```
// Core
import * as React from "react";
import classNames from "classnames";
// Utils
import { capitalize } from "./utils/string";
// Styles
import styles from "./GoodButton.module.scss";
const ButtonVariantTypes = ["filled", "outlined", "link"] as const;
const ButtonColorTypes = ["primary", "secondary"] as const;
const ButtonSizeTypes = ["small", "medium", "large"] as const;
const ButtonHTMLTypes = ["submit", "button", "reset"] as const;
export type ButtonVariantType = typeof ButtonVariantTypes[number];
export type ButtonColorType = typeof ButtonColorTypes[number];
export type ButtonSizeType = typeof ButtonSizeTypes[number];
export type ButtonHTMLType = typeof ButtonHTMLTypes[number];
export interface BaseButtonProps {
/**
* Передать дочерний элемент для кнопки
*/
children: React.ReactNode;
/**
* Определить класс для кнопки
*/
className?: string;
/**
* Выбрать вариацию отображения кнопки
*/
variant?: ButtonVariantType;
/**
* Выбрать цвет кнопки
*/
color?: ButtonColorType;
/**
* Выбрать размер кнопки
*/
size?: ButtonSizeType;
/**
* Определить размер кнопки во всю ширину от родительского контейнера
*/
fullWidth?: boolean;
/**
* Отключить кнопку
*/
disabled?: boolean;
/**
* Обработчик события на клик по мыши для кнопки
*/
onClick?: () => void;
}
export type AnchorButtonProps = {
/**
* Передать url и определить кнопку как ссылку
*/
href: string;
} & BaseButtonProps &
Omit, "type" | "onClick">;
export type NativeButtonProps = {
/\*\*
\* Выбрать тип кнопки
\*/
type?: ButtonHTMLType;
} & BaseButtonProps &
Omit, "type" | "onClick">;
export type ButtonProps = Partial;
const GoodButton: React.FC = ({
children,
className,
variant = "filled",
color = "primary",
size = "small",
type = "button",
fullWidth,
disabled,
onClick,
href,
...rest
}) => {
const Component = href ? "a" : "button";
let buttonProps;
if (Component === "a") {
buttonProps = { "aria-disabled": disabled };
} else {
buttonProps = { type, disabled };
}
return (
{children}
);
};
// Exports
export default GoodButton;
```
То есть разработка любого на первый взгляд простого элемента это продолжительная и дорогостоящая работа (если делать его удобным и масштабируемым), поэтому проще один раз отрисовать и запрограммировать каждый элемент и потом использовать его во всех проектах.
### Можно ли использовать готовый UI KIT?
В интернете множество китов за небольшие деньги, что-то около 15$. Вы безусловно можете их использовать. Но они скорее подойдут для небольших проектов, которые не собираются далеко масштабироваться или же в вашей компании предполагается сделать одну систему, а не строить множество продуктов.
#### Основные причины для постройки, а не покупки UI KIT
1. Большие компании приводят все системы к единому виду, чтобы сотрудники и пользователи ориентировались легко в любой системе компании;
2. Компаниям необходимо соблюдать фирменный стиль;
3. При покупке UI KIT вам необходимо отталкиваться от технологий заложенных в купленном ките;
4. Купленный кит не может закрыть весь функционал систем, то есть вам необходимо будет дорисовывать его и дорабатывать;
5. Строя ui kit с нуля вы видите полноценно цель разработки. То есть сможете разрабатывать элементы исходя из задачи, делая каждый элемент удобнее.
### Требования к разработчику UI KIT:
UI KIT разрабатывается только дизайнером и разработчиком уровня Senior, которые имеют опыт в подобных проектах. Дизайнер и фронтенд-разработчик должен обладать опытом и знаниями для построения сложных систем, так как ui kit будет использоваться около 5 лет всеми командами разработки вашей компании и привлекаемыми подрядчиками для большинства ваших систем. | https://habr.com/ru/post/583876/ | null | ru | null |
# Алгоритм Order-Independent Transparency c использованием связных списков на Direct3D 11 и OpenGL 4
Реализацию порядко-независимой прозрачности ([order-independent transparency](http://en.wikipedia.org/wiki/Order-independent_transparency), OIT), наверное, можно считать классической задачей программирования компьютерной графики. По сути, алгоритмы OIT решают одну простую прикладную задачу – как нарисовать набор полупрозрачных объектов так, чтобы не беспокоиться о порядке их рисования. Правила смешивания цветов при рендеринге требуют он нас, чтобы полупрозрачные объекты рисовались в порядке от дальнего к ближнему, однако этого сложно добиться в случае протяженных объектов или объектов сложной формы. Реализация одного из самых современных алгоритмов, OIT с использованием связных списков, [была представлена AMD](http://developer.amd.com/wordpress/media/2012/10/OIT%20and%20Indirect%20Illumination%20using%20DX11%20Linked%20Lists_forweb.ppsx) для Direct3D 11 еще в 2010 году. Скажу откровенно, производительность алгоритма на широко доступных графических картах тех лет не произвела на меня должного впечатления. Прошло 4 года, я откопал презентацию AMD и решил реализовать алгоритм не только на Direct3D 11, но и на OpenGL 4.3. Тех, кому интересно, что получилось из этой затеи, прошу под кат.
Перед тем, как начать разговор о самой реализации алгоритма, отмечу, что демка доступна широкой аудитории [здесь](https://github.com/rokuz/GraphicsDemo). Проект называется Demo\_OIT. Для сборки вам понадобятся Visual Studio 2012/2013 и [CMake](http://www.cmake.org/). Полезная терминология приведена в конце поста.
#### Краткий обзор алгоритмов OIT
Рендеринг полупрозрачных объектов имеет ряд особенностей:
1. При рендеринге непрозрачных объектов грани, которые не видны наблюдателю, обычно отбрасываются. Это позволяет сэкономить на растеризации и обработке фрагментов. В случае полупрозрачных объектов обратные грани не могут быть отброшены;
2. Тест глубины не должен проводиться среди полупрозрачных объектов, так как одни полупрозрачные объекты могут быть видны через другие. Однако, должна учитываться глубина непрозрачной части cцены, так как непрозрачный объект может частично или полностью перекрывать полупрозрачный;
3. Рисовать полупрозрачные объекты необходимо в порядке от дальнего к ближнему. Это диктуют правила смешивания цветов по альфа-каналу (alpha blending). Как уже было отмечено, алгоритмы OIT позволяют избавиться от этого ограничения.
Обобщенный алгоритм OIT можно представить следующим образом:
1. Нарисовать непрозрачные объекты сцены, сохранить буфер глубины;
2. Для каждого фрагмента полупрозрачного объекта, используя буфер глубины, полученный на шаге 1, определить, необходимо ли рисовать этот фрагмент;
3. Для каждого отображаемого полупрозрачного фрагмента сохранить его цвет, глубину и позицию на экране;
4. Для полупрозрачных фрагментов провести сортировку по значению глубины от дальнего к ближнему;
5. Рисовать полупрозрачные фрагменты в полученном порядке, смешивая их цвета по значению альфа-канала.
Основную сложность здесь представляют пункты 3 и 4, а именно, как получить фрагменты с разной глубиной, куда сохранить и как потом сортировать.
* Алгоритм [Depth Peeling](http://steps3d.narod.ru/tutorials/depth-peel-tutorial.html) (и его вариации [Reverse Depth Peeling](http://orenk2k.blogspot.ru/2010/10/oit-order-independent-transparency-3.html), [Dual Depth Peeling](http://developer.download.nvidia.com/SDK/10/opengl/src/dual_depth_peeling/doc/DualDepthPeeling.pdf) и т.д.) позволяет получить сцену по слоям. В первом слое хранятся фрагменты ближайшие к наблюдателю, во втором слое – вторые по близости и т.д. В классической реализации каждому слою отводится своя текстура, а полупрозрачная часть сцены рисуется столько раз, сколько необходимо слоев. Сортировка фрагментов в явном виде не нужна достаточно смешивать слои от дальнего к ближнему. К недостаткам алгоритма можно отнести многократное рисование сцены, необходимость хранения текстуры для каждого слоя (не для всех вариаций алгоритма это справедливо), выборка из множества текстур при смешивании цветов. К достоинству алгоритма можно отнести то, что его можно реализовать даже на Direct3D 9.
* Алгоритм Stencil Routed A-Buffer предполагает хранение слоев сцены в MSAA-текстуре. Этот алгоритм быстрее, избавляет от необходимости многократного рисования полупрозрачных объектов, однако лишает нас встроенного антиалиасинга. Кроме того, количество уровней MSAA ограничено (до 8x-16x на большинстве современного оборудования), а значит, ограничено и количество слоев. Я некогда реализовывал этот алгоритм, подробности, если интересно, [здесь](http://www.uraldev.ru/articles/40).
* Алгоритм OIT using Linked Lists, которому посвящен данный пост, лишен недостатков вышеописанных алгоритмов. Здесь полупрозрачная часть сцены рисуется однократно, возможна поддержка MSAA. Реализацию алгоритма на Direct3D 11 с использованием compute-шейдеров без поддержки MSAA можно найти [здесь](http://www.uraldev.ru/articles/36), там же приведено чуть более подробное описание алгоритма.
#### Реализация алгоритма Order-Independent Transparency using Linked Lists
Начну с того, что определю требования к реализации:
1. Алгоритм работает на Direct3D 11 и OpenGL 4.3;
2. Алгоритм не использует compute-шейдеры. Вполне достаточно фрагментного шейдера;
3. Алгоритм поддерживает MSAA.
Основная суть алгоритма заключается в следующем: для каждого отображаемого полупрозрачного фрагмента мы формируем связный список фрагментов, которые располагаются в этой же позиции на экране. Сформировать такой набор связных списков позволяет возможность современного графического оборудования вести произвольную запись в выделенный блок памяти прямо из шейдеров. Имея такие связные списки для каждого полупрозрачного фрагмента, можно производить сортировку фрагментов по глубине и затем смешивать цвета в правильном порядке.
Для реализации алгоритма нам потребуются:
1. Текстура целочисленного формата (unsigned int), совпадающая по размеру с экраном, для хранения головных элементов связных списков;
2. Буфер в памяти для хранения элементов связных списков. Минимальное содержание элемента связного списка включает цвет фрагмента, глубину и ссылку на следующий элемент (адрес в буфере);
3. Счетчик полупрозрачных фрагментов для того, чтобы определить ближайший свободный элемент в буфере.
Для лучшего понимая принципа работы, рассмотрим следующий рисунок.
На рисунке мы видим текстуру для хранения головных элементов списка, в которой хранятся адреса соответствующих фрагментов в буфере, и сам буфер. Места, в которых нет полупрозрачных фрагментов, содержат -1. Если на одну позицию на экране пришлось несколько полупрозрачных фрагментов, образуется список (фрагмент с индексом 0 содержит ссылку на фрагмент с индексом 2). Счётчик фрагментов в этой ситуации равен 5, т.е. следующий фрагмент будет записан в буфер по адресу 5, а счётчик инкрементируется.
На первый взгляд кажется, что всё просто, перейдем к деталям реализации.
##### Реализация на Direct3D 11
Для реализации этого алгоритма на Direct3D 11 нам потребуются так называемые Unordered-Access ресурсы: текстура (*RWTexture2D*) и структурированный буфер (*RWStructuredBuffer*). Особенность этих ресурсов заключается в том, что чтение и запись для них доступны в шейдерах. Для них существует специальный набор команд в Direct3D API, например, чтобы связать UA-ресурсы с переменными в шейдерах служит метод *OMSetRenderTargetsAndUnorderedAccessViews*. Этот метод упомянут не случайно. Организация Direct3D 11 такова, что UA-ресурсы конкурируют с render target’ами при образовании связки с пиксельными шейдерами, т.е. если оборудование обеспечивает MRT в 8 текстур, и 2 слота занимают render target’ы, то на UA-ресурсы остается не более 6 слотов. Работа с UA-ресурсами должна производиться при помощи атомарных операций, что обусловлено высоко параллельной архитектурой GPU.
Счетчик фрагментов будет реализован при помощи флага *D3D11\_BUFFER\_UAV\_FLAG\_COUNTER* для структурированного буфера. Direct3D 11 позволяет прикреплять атомарный счетчик к структурированному буферу, в нашем случае логично использовать буфер для хранения элементов связных списков.
Для реализации алгоритма на Direct3D 11 создадим:
1. Текстуру для хранения адресов головных элементов списков. Формат — *DXGI\_FORMAT\_R32\_UINT*, флаги для связи с шейдерами — *D3D11\_BIND\_UNORDERED\_ACCESS | D3D11\_BIND\_SHADER\_RESOURCE*, размер эквивалентен размеру заднего буфера;
2. Структурированный буфер для хранения элементов связных списков. Каждый элемент списка на HLSL представлен следующей структурой:
```
struct ListNode
{
uint packedColor;
uint depthAndCoverage;
uint next;
};
```
Таким образом, каждый элемент списка занимает 12 байт. Таких элементов нужно несколько на каждый фрагмент заднего буфера. Представим себе ситуацию, когда прямо перед камерой расположено 8 параллельных полупрозрачных плоскостей, которые занимают весь экран. В этом случае для каждого фрагмента заднего буфера сформируется список из 8 элементов. Для хранения этого объема данных потребуется буфер размером 12 \* *W* \* *H* \* 8 байт, где *W,H* – длина и ширина заднего буфера. Редкой компьютерной игре необходимо столько видимых полупрозрачных фрагментов в кадре, поэтому возьмем эти 8 плоскостей за предельный случай. Для разрешения заднего буфера 1920x1080 размер структурированного буфера составит приблизительно 190Мб. К этому же буферу присоединим счётчик фрагментов при помощи описанного выше флага.
Рисовать кадр будем по следующей схеме:
1. Очищаем текстуру адресов головных элементов списков значением 0xffffffff. Для этого есть специальный метод *ClearUnorderedAccessViewUint*. Сбрасываем счётчик фрагментов;
2. Выставляем задний буфер как нулевой render target, индекс 1 получит текстура головных элементов, индекс 2 – структурированный буфер элементов списков;
3. Рисуем непрозрачную часть сцены (в демке рисуется скайбокс и несколько непрозрачных чайников);
4. Формируем списки фрагментов полупрозрачной части сцены. Чтобы все получилось необходимо отключить отсечение обратных граней (*D3D11\_CULL\_NONE*), отключить запись новых значений в буфер глубины (но сам тест глубины не отключать), отключить запись цвета в текстуру (на этом шаге нам нечего рисовать, мы только формируем списки). Пиксельный шейдер, формирующий списки фрагментов, приведен ниже.
```
#include
#include
struct ListNode
{
uint packedColor;
uint depthAndCoverage;
uint next;
};
globallycoherent RWTexture2D headBuffer;
globallycoherent RWStructuredBuffer fragmentsList;
uint packColor(float4 color)
{
return (uint(color.r \* 255) << 24) | (uint(color.g \* 255) << 16) | (uint(color.b \* 255) << 8) | uint(color.a \* 255);
}
[earlydepthstencil]
float4 main(VS\_OUTPUT input, uint coverage : SV\_COVERAGE, bool frontFace : SV\_IsFrontFace) : SV\_TARGET
{
float4 color = computeColorTransparent(input, frontFace);
uint newHeadBufferValue = fragmentsList.IncrementCounter();
if (newHeadBufferValue == 0xffffffff) { return float4(0, 0, 0, 0); }
uint2 upos = uint2(input.position.xy);
uint previosHeadBufferValue;
InterlockedExchange(headBuffer[upos], newHeadBufferValue, previosHeadBufferValue);
uint currentDepth = f32tof16(input.worldPos.w);
ListNode node;
node.packedColor = packColor(float4(color.rgb, color.a));
node.depthAndCoverage = currentDepth | (coverage << 16);
node.next = previosHeadBufferValue;
fragmentsList[newHeadBufferValue] = node;
return float4(0, 0, 0, 0);
}
```
Рассмотрим самые интересные места в этом коде. Модификатор *[earlydepthstencil]* играет очень важную роль. Дело в том, что фрагментные тесты (тест глубины, трафарета и т.д.) в обычной ситуации проводятся на завершающем этапе графического конвейера, после исполнения пиксельных шейдеров. В нашем случае это недопустимо, так как все рисуемые на этом этапе фрагменты попадают в связные списки. Чтобы отсечь лишние фрагменты до попадания в списки, необходимо провести ранний тест глубины (до пиксельного шейдера).
Нетрудно видеть, что цвет фрагмента хранится в структуре как uint. Упаковка float4 значения в uint позволяет сэкономить 12 байт. 32-битная глубина пакуется в 16-битную, а свободные 16 бит используются для хранения значения coverage (необходимо для реализации MSAA).
Метод *IncrementCounter* вычисляет новый адрес для головного элемента списка, а функция *InterlockedExchange* атомарно меняет текущее значение головного элемента списка на новое. Нетрудно видеть, что список растет с головы, а вышеописанный код — практически классическая реализация вставки в начало для односвязного списка.
5. На завершающем шаге необходимо отсортировать полученные списки фрагментов по глубине и вывести на экран, смешивая по альфа-каналу. Для вывода на экран полупрозрачной части сцены используется рендеринг так называемого полноэкранного квада (по сути, двух треугольников, покрывающих весь экран). При рендеринге квада надо отключить тест глубины и включить альфа-блендинг. Так как непрозрачная часть сцены уже нарисована, то формула блендинга будет следующая:
*Цвет фрагмента* = *Текущий цвет фрагмента* \* 1 + *Цвет фрагмента из шейдера* \* *Альфа фрагмента из шейдера*;
Те, кто знакомы с классической формулой [альфа-блендинга](http://en.wikipedia.org/wiki/Alpha_compositing), возможно, удивятся, увидев такое. По факту мы используем классическую формулу, просто часть этой формулы реализована в шейдере, а приведенная выше формула – завершающий этап смешивания с цветом фрагментов, уже нарисованных на экране.
В качестве алгоритма сортировки используем [сортировку вставками](http://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0_%D0%B2%D1%81%D1%82%D0%B0%D0%B2%D0%BA%D0%B0%D0%BC%D0%B8). Для небольших наборов данных этот примитивный алгоритм достаточно эффективен, кроме того данный алгоритм устойчив, т.е. не меняет порядок уже отсортированных элементов. При рендеринге полупрозрачных фрагментов мы теоретически можем получить частично-упорядоченные по глубине списки, для этого надо дополнительно отсортировать полупрозрачные объекты по расстоянию до наблюдателя и рисовать объекты в этом порядке. В некоторых случаях это позволит уменьшить количество перестановок сортируемых элементов в памяти.
Код для сортировки фрагментов в пиксельном шейдере приведен ниже.
```
void insertionSortMSAA(uint startIndex, uint sampleIndex, inout NodeData sortedFragments[MAX_FRAGMENTS], out int counter)
{
counter = 0;
uint index = startIndex;
for (int i = 0; i < MAX_FRAGMENTS; i++)
{
if (index != 0xffffffff)
{
uint coverage = (fragmentsList[index].depthAndCoverage >> 16);
if (coverage & (1 << sampleIndex))
{
sortedFragments[counter].packedColor = fragmentsList[index].packedColor;
sortedFragments[counter].depth = f16tof32(fragmentsList[index].depthAndCoverage);
counter++;
}
index = fragmentsList[index].next;
}
}
for (int k = 1; k < MAX_FRAGMENTS; k++)
{
int j = k;
NodeData t = sortedFragments[k];
while (sortedFragments[j - 1].depth < t.depth)
{
sortedFragments[j] = sortedFragments[j - 1];
j--;
if (j <= 0) { break; }
}
if (j != k) { sortedFragments[j] = t; }
}
}
```
Здесь же уместно будет упомянуть о [реализации MSAA в Direct3D 11](http://msdn.microsoft.com/en-us/library/windows/desktop/cc627092(v=vs.85).aspx). Когда MSAA включен, для каждого фрагмента формируется набор точек (выборок) внутри фрагмента с немного отличающимися позициями. Число таких точек соответствует количеству уровней MSAA (обычно 2, 4, 8, 16). Для каждой точки проверяется ее принадлежность треугольнику (coverage test), и если хоть одна точка находится внутри треугольника, то пиксельный шейдер выполняется для текущего фрагмента, а результат интерполируется между всеми прошедшими тест выборками. Для того чтобы понять какие из выборок находятся внутри треугольника (т.е. прошли тест и оказывают влияние на результирующий цвет фрагмента), формируется маска, которая называется coverage. Именно это значение мы и сохраняли для каждого полупрозрачного фрагмента на предыдущем шаге.
Теперь при рендеринге мы можем выбрать из списка фрагменты, которые соответствуют конкретной выборке при помощи простого условия *coverage & (1 << sampleIndex) != 0*. Также следует обратить внимание на константу *MAX\_FRAGMENTS*. Эффективно сортировать связные списки не просто даже на CPU, на GPU мы еще более ограничены. Поэтому перед сортировкой связный список копируется в массив фиксированной длины, что ограничивает количество полупрозрачных фрагментов в цепочке.
Интересно, что после фильтрации фрагментов по маске *coverage* в списке остаются фрагменты, имеющие абсолютно одинаковую глубину и незначительно отличающийся цвет. Это приводит к образованию артефактов на ребрах полигональной модели, особенно при низком качестве MSAA. Для того чтобы устранить артефакт, необходимо произвести усреднение цвета фрагментов с одинаковой глубиной. Так как выходной список фрагментов отсортирован по глубине, то фрагменты с одинаковым значением глубины идут подряд. Остается их только посчитать и собрать. Полный код шейдера скрыт под спойлером.
**Код пиксельного шейдера для данного этапа**
```
#include
float4 main(VS\_OUTPUT input, uint sampleIndex : SV\_SAMPLEINDEX) : SV\_TARGET
{
uint2 upos = uint2(input.position.xy);
uint index = headBuffer[upos];
clip(index == 0xffffffff ? -1 : 1);
float3 color = float3(0, 0, 0);
float alpha = 1;
NodeData sortedFragments[MAX\_FRAGMENTS];
[unroll]
for (int j = 0; j < MAX\_FRAGMENTS; j++)
{
sortedFragments[j] = (NodeData)0;
}
int counter;
insertionSortMSAA(index, sampleIndex, sortedFragments, counter);
// resolve multisampling
int resolveBuffer[MAX\_FRAGMENTS];
float4 colors[MAX\_FRAGMENTS];
int resolveIndex = -1;
float prevdepth = -1.0f;
[unroll(MAX\_FRAGMENTS)]
for (int i = 0; i < counter; i++)
{
if (sortedFragments[i].depth != prevdepth)
{
resolveIndex = -1;
resolveBuffer[i] = 1;
colors[i] = unpackColor(sortedFragments[i].packedColor);
}
else
{
if (resolveIndex < 0) { resolveIndex = i - 1; }
colors[resolveIndex] += unpackColor(sortedFragments[i].packedColor);
resolveBuffer[resolveIndex]++;
resolveBuffer[i] = 0;
}
prevdepth = sortedFragments[i].depth;
}
// gather
[unroll(MAX\_FRAGMENTS)]
for (int i = 0; i < counter; i++)
{
[branch]
if (resolveBuffer[i] != 0)
{
float4 c = colors[i] / float(resolveBuffer[i]);
alpha \*= (1.0 - c.a);
color = lerp(color, c.rgb, c.a);
}
}
return float4(color, alpha);
}
```
Результаты работы алгоритма, реализованного средствами Direct3D 11, можно видеть ниже.
##### Реализация на OpenGL 4.3
Реализация на OpenGL 4.3 во многом похожа на предыдущую реализацию. Аналогом структурированных буферов здесь являются storage block’и (добавленные в стандарт как раз в версии 4.3). Для работы с текстурами, в которые можно вести чтение и запись из шейдеров, в GLSL есть специальные типы (нам потребуется *uimage2D*). Итого, для реализации алгоритма нам потребуется:
1. Целочисленная текстура (*GL\_R32UI*) для хранения адресов головных элементов связных списков;
2. Буфер с типом *GL\_SHADER\_STORAGE\_BUFFER* для хранения элементов связных списков. Размер буфера вычисляется так же, как и в реализации на Direct3D 11;
3. Буфер с типом *GL\_ATOMIC\_COUNTER\_BUFFER* для хранения счетчика фрагментов. В отличие от Direct3D в OpenGL хранилище для атомарного счётчика создается явно;
4. Текстуры для рендеринга сцены и буфера глубины. В реализации алгоритма на OpenGL нам потребуется текстура глубины (об этом ниже). Достать стандартный буфер глубины из WGL хоть и можно, но ненадежно, поскольку формат буфера глубины-трафарета, который был выбран при инициализации окна WGL, может быть различный на разном оборудовании. Проще и безопаснее рисовать в собственноручно созданный framebuffer.
Процедура рендеринга кадра имеет одну ключевую особенность. OpenGL предлагает нам вручную управлять синхронизацией операций чтения-записи. Для этого существует специальная функция *glMemoryBarrier*, которую мы будем вызывать следующим образом:
```
glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT | GL_ATOMIC_COUNTER_BARRIER_BIT | GL_SHADER_STORAGE_BARRIER_BIT);
```
Это обеспечит целостность данных между разными этапами рисования кадра.
Рисовать кадр будем по следующей схеме:
1. Очищаем текстуру с адресами головных элементов связных списков значением 0xffffffff. В OpenGL 4.3 для этого нужно вызвать шейдер, который будет для каждого фрагмента выполнять следующую операцию:
```
imageStore(headBuffer, upos, uvec4(0xffffffff));
```
2. Сбрасываем счётчик фрагментов (*glClearBufferSubData*);
3. Выставляем framebuffer для рендеринга;
4. Рисуем непрозрачную часть сцены;
5. Формируем списки фрагментов полупрозрачной части сцены. На этом этапе есть анонсированная ранее особенность. OpenGL умеет производить ранний тест глубины только для фрагментных шейдеров без «побочных эффектов». К сожалению, к «побочным эффектам» относится запись в storage block. Важная роль раннего теста глубины для этого алгоритма обсуждалась ранее, поэтому нам ничего не остается, кроме как реализовать тест глубины самим. Часть фрагментного шейдера на GLSL приведена ниже.
```
void main()
{
outputColor = vec4(0);
uint newHeadBufferValue = atomicCounterIncrement(fragmentsListCounter);
if (newHeadBufferValue == 0xffffffff) discard;
ivec2 upos = ivec2(gl_FragCoord.xy);
float depth = texelFetch(depthMap, upos, 0).r;
if (gl_FragCoord.z > depth) discard;
vec4 color = computeColorTransparent(gl_FrontFacing);
uint previosHeadBufferValue = imageAtomicExchange(headBuffer, upos, newHeadBufferValue);
uint currentDepth = packHalf2x16(vec2(psinput.worldPos.w, 0));
fragments[newHeadBufferValue].packedColor = packColor(vec4(color.rgb, color.a));
fragments[newHeadBufferValue].depthAndCoverage = currentDepth | (gl_SampleMaskIn[0] << 16);
fragments[newHeadBufferValue].next = previosHeadBufferValue;
}
```
Запись в буферы глубины и цвета, а также отсечение обратных граней должны быть отключены на этом этапе аналогично реализации на Direct3D.
6. Сортируем полученные списки фрагментов по глубине и выводим в framebuffer, смешивая по альфа-каналу. Процедура сортировки, смешивания цветов и настройки альфа-блендинга аналогичны Direct3D. Единственное исключение составляет тот факт, что после фильтрации фрагментов по маске coverage в списке не остается фрагментов, имеющих абсолютно одинаковую глубину, поэтому фрагментный шейдер несколько упрощается.
```
void main()
{
ivec2 upos = ivec2(gl_FragCoord.xy);
uint index = imageLoad(headBuffer, upos).x;
if (index == 0xffffffff) discard;
vec3 color = vec3(0);
float alpha = 1.0f;
NodeData sortedFragments[MAX_FRAGMENTS];
for (int i = 0; i < MAX_FRAGMENTS; i++)
{
sortedFragments[i] = NodeData(0, 0.0f);
}
int counter;
insertionSort(index, gl_SampleID, sortedFragments, counter);
for (int i = 0; i < MAX_FRAGMENTS; i++)
{
if (i < counter)
{
vec4 c = unpackColor(sortedFragments[i].packedColor);
alpha *= (1.0 - c.a);
color = mix(color, c.rgb, c.a);
}
}
outputColor = vec4(color, alpha);
}
```
7. Осуществляем копирование из framebuffer’а на экран при помощи функции glBlitFramebuffer.
Визуально результат, полученный при рендеринге на OpenGL 4.3, ничем не отличается от Direct3D 11.
#### Проблемы
У алгоритма есть 3 ключевые проблемы:
1. Величина *MAX\_FRAGMENTS*, ограничивающая максимальное количество полупрозрачных фрагментов в списке. Мы сами можем выбирать эту величину, исходя из требуемого уровня качества и запаса времени, которое можно отдать под расчет OIT. К слову, включение MSAA увеличивает количество полупрозрачных фрагментов, особенно в районе ребер полигональных моделей. Ниже показано, что будет, если величины списка не хватит.
2. Размер буфера для хранения элементов списков. Я использовал буфер размером 190Мб и не смог воспроизвести переполнение на сцене из 36 чайников, однако на полигональных моделях сложной формы это возможно и очень вероятно. Размер буфера можно увеличивать, благо графические API не ограничивают явно размеры структурированных буферов и storage block’ов. Я уменьшил размер буфера в 8 раз, чтобы показать, что произойдет при переполнении.
3. Сложность пиксельного (фрагментного) шейдера на завершающем этапе алгоритма. С увеличением *MAX\_FRAGMENTS* и включением MSAA шейдер становится все более тяжелым, что негативно сказывается на fillrate и может приводить к серьезным «тормозам».
#### Производительность
Замеры производительности велись на компьютере следующей конфигурации: AMD Phenom II X4 970 3.79GHz, 16Gb RAM, AMD Radeon HD 7700 Series, под управлением ОС Windows 8.1.
Среднее время кадра. Direct3D 11 / 1920x1080 / 400k-800k полупрозрачных фрагментов.
| MSAA / MAX\_FRAGMENTS | 8 | 16 | 32 |
| --- | --- | --- | --- |
| 0 | 1.4835ms | 1.67446ms | 2.1275ms |
| 2x | 3.49895ms | 6.66149ms | 8.52533ms |
| 4x | 5.78841ms | 12.3358ms | 15.7224ms |
| 8x | 8.93051ms | 18.4825ms | 24.8538ms |
Среднее время кадра. OpenGL 4.3 / 1920x1080 / 400k-800k полупрозрачных фрагментов.
| MSAA / MAX\_FRAGMENTS | 8 | 16 | 32 |
| --- | --- | --- | --- |
| 0 | 3.25259ms | 4.10712ms | 16.8482ms |
| 2x | 5.06972ms | 7.16611ms | 33.6713ms |
| 4x | 7.22944ms | 12.3625ms | 62.5776ms |
| 8x | 11.2621ms | 19.0938ms | 115.026ms |
Среднее время кадра. Direct3D 11 / 1920x1080 / ~5000k полупрозрачных фрагментов.
| MSAA / MAX\_FRAGMENTS | 8 | 16 | 32 |
| --- | --- | --- | --- |
| 0 | 4.94471ms | 5.73306ms | 7.95545ms |
| 2x | 9.91625ms | 26.6783ms | 40.4808ms |
| 4x | 16.653ms | 50.7367ms | 77.038ms |
| 8x | 28.3847ms | 91.0873ms | 143.419ms |
Среднее время кадра. OpenGL 4.3 / 1920x1080 / ~5000k полупрозрачных фрагментов.
| MSAA / MAX\_FRAGMENTS | 8 | 16 | 32 |
| --- | --- | --- | --- |
| 0 | 16.2532ms | 22.0057ms | 139.678ms |
| 2x | 22.1646ms | 35.0568ms | 275.324ms |
| 4x | 30.4289ms | 56.7788ms | 536.241ms |
| 8x | 46.6934ms | 197.024ms | 1009.09ms |
Нетрудно видеть, что реализация алгоритма на Direct3D 11 работает быстрее, чем на OpenGL 4.3. Причем на 5 миллионах полупрозрачных фрагментов реализация на OpenGL «умирает» при включенном MSAA и больших величинах *MAX\_FRAGMENTS*. Результаты профилирования показали, что основную часть времени алгоритм тратит на завершающем этап, т.е. на сортировке и смешивании цветов фрагментов. Также следует учитывать, что моя видеокарта далеко не самая новая, и приведённые цифры показывают лишь динамику изменения времени кадра.
#### Выводы
Использование связных списков, наверное, можно считать самым современным подходом к реализации OIT. Алгоритм работает очень быстро при разумных настройках качества и сложности полупрозрачной части сцены. 5 миллионов видимых полупрозрачных фрагментов в кадре это, на мой взгляд, достаточно даже для самой современной игры (примерно 2.5 раза покрыть экран с разрешением 1920x1080 полупрозрачными фрагментами). От MSAA, который может замедлить алгоритм, при необходимости можно отказаться вовсе или заменить на другой алгоритм антиалиасинга. Алгоритм, безусловно, имеет недостатки, но все они понятны, и с ними можно бороться.
#### Немного о терминологии
Так сложилось, что терминология компьютерной графики практически полностью иностранная. Ниже под спойлером я привел ряд терминов, которые могут быть полезны при прочтения поста.
**Термины**
**Рендеринг** – процесс рисования трёхмерной сцены на двумерном носителе (экране, текстуре).
**Шейдер** – программа для графического процессора (GPU), позволяющая контролировать один этапов графического конвейера. Вершинный шейдер оперирует вершинами, геометрический – примитивами (треугольниками, линиями и т.д.), пиксельный(фрагментный) – формируемыми на выходе пикселами.
**Растеризация** – процесс формирования растрового изображения по векторному представлению объекта.
**Тест глубины** – тест, полученных при рендеринге фрагментов, который позволяет отсекать фрагменты в зависимости от глубины уже нарисованной части сцены. Обычно в буфер глубины записывается глубина ближайшего к наблюдателю фрагмента.
**MSAA (multi-sampling antialiasing)** – один из алгоритмов антиалиасинга, реализованный как в OpenGL, так и в Direct3D.
**MSAA-текстура** – текстура для рендеринга с антиалиасингом. Имеет специальный формат, тип и набор операций в шейдерах.
**Render target** – то, куда осуществляется рендеринг. Термин обычно используется при рисовании сцены в текстуру.
**MRT (multiple render targets)** – технология, позволяющая осуществлять рендеринг сразу в несколько render target’ов.
**Compute-шейдер** – программа для GPU, призванная решать задачу общего назначения (возможно не относящуюся к компьютерной графике).
**Задний буфер (back buffer)** – в многобуферной модели рендеринга тот буфер, в который обычно осуществляется рендеринг, и который меняется местами с передним буфером (front buffer) после завершения рисования кадра.
**Framebuffer** – специальный объект в OpenGL, который позволяет объединять несколько render target’ов и буфер глубины.
**Fillrate** – грубо скорость заполнения экрана пикселами. | https://habr.com/ru/post/224003/ | null | ru | null |
# Оптимизируем память Rails сервиса (реальный кейс)
> Для Ruby и Ruby on Rails разработчиков уровня Junior+, Middle
Мы часто пишем код, не вникая, сколько ресурсов уйдет на его выполнение. И это может быть ок. Но, во-первых, каждый нормальный разработчик старается становиться лучше и раскачивает свои скилы. Во-вторых, это легко может обернуться реальным багом с абсолютно не очевидными корнями, и вопрос-таки придется решать.
### Загадочный баг
В моем случае эта проблема проявилась, когда девопсы перевели нашу CRM систему в Kubernetes. В ней перестал формироваться Excel отчет по заявкам, если задать ему временную выборку хотя бы за месяц. Sidekiq в какой-то момент просто прекращал выполнение джобы, не возвращая ошибок (хотя код сервиса предусматривает и запись exception-ов, и изменение статуса экспорта). Модель экспорта у нас просто зависала в статусе ‘in\_progress’, но Sidekiq прекращал выполнять работу, никого в известность не ставя.
Забегая вперед, скажу, что причина оказалась в новых настройках контейнеров, которым девопсы жестко ограничили допустимое использование памяти, и если процесс выходил за рамки, то он просто тихо убивался. Таким образом, слишком грузные экспорты зависали в CRM, якобы в прогрессе, а пользователи ничего не могли поделать.
### Не действуем "наощупь"
Оптимизировать "наугад" — вообще плохая идея. Чтобы понимать, есть ли в наших действиях какой-то толк, сформируем метрику. Для измерения памяти воспользуемся гемом [benchmark-memory](https://github.com/michaelherold/benchmark-memory), и напишем нехитрый метод:
```
def benchmark_memory(█)
Benchmark.memory do |x|
x.report('') do
yield
GC.start(full_mark: true, immediate_sweep: true) # принудительный запуск Garbage Collector'а, чтобы минимизировать разброс в результатах
end
end
end
```
Обратите внимание на вызов Garbage Collector в конце. Не подчищенный «мусор» очень любит раздувать память. А эффективность работы GC сильно зависит от версии Ruby чем новее, тем лучше и быстрее он работает. Но нам, чтобы измерять проводимые оптимизации, нужен стабильный результат. Вот, например, как наш метод оценил бы экспорт 100 заявок без вызова GC:
```
Экспорт 100 заявок в один раз
50.966M memsize ( 1.445M retained)
850.405k objects ( 24.514k retained)
50.000 strings ( 50.000 retained)
Экспорт 100 заявок в другой раз
80.554M memsize ( 920.363k retained)
1.303M objects ( 17.565k retained)
50.000 strings ( 50.000 retained)
```
В общем, включаем в методе запуск Garbage Collector’а, и теперь мы сможем легко измерить потребление памяти для любого процесса:
```
benchmark_memory { puts 1 }
Calculating -------------------------------------
1
464.000 memsize ( 0.000 retained)
2.000 objects ( 0.000 retained)
0.000 strings ( 0.000 retained)
```
Здесь мы видим, что для простого вывода единицы в консоль нам требуется 464 байта.
Результаты для исходной реализации нашего экспорта выглядели так:
```
Экспорт 100 заявок:
1.482M memsize ( 1.480M retained)
24.814k objects ( 24.793k retained)
50.000 strings ( 50.000 retained)
Экспорт 1000 заявок:
12.811M memsize ( 12.809M retained)
226.587k objects ( 226.556k retained)
50.000 strings ( 50.000 retained)
```
Для 100 заявок требуется полтора мегабайта, для 1000 заявок — почти в десять раз больше. Налицо линейная асимптотика — чем больше исходные данные, тем больше потребляемая память. Звучит логично, но это и есть, так называемое, раздувание памяти (ссылка на подробный материал об этом ниже). Получается, для корректной работы программы мы должны заранее учесть возможные ограничения на обращение к сервису экспорта, нас это не устраивает.
> Кстати, из полученных данных мы можем примерно оценить, сколько памяти требовал от контейнера наш сервис на проде, когда убивался воркер сайдкика. Возьмем минимальный по потреблению памяти без Garbage Collector’а результат для 100 заявок — 50 Мб (отбросим даже дробную часть), то есть 500 Мб для 1000. В зависшей выборке было 38\_000 заявок — значит потенциально сервис может "раздуть" потребление памяти до 18,5 Гб! (38 \* 500 = 19\_000 Мб =~ 18,5 Гб).
### Как оптимизировать потребление памяти?
#### Оптимизация 1: Формат отчета
Первое, что пришло в голову — это изменить формат отчета, и перейти с xlsx на csv. Спросил у «бизнеса», оказалось, им без разницы. В итоге, такой мизерной «оптимизации» оказалось достаточно, чтобы на 40% сократить потребление памяти:
```
Экспорт 100 заявок в xlsx:
1.482M memsize ( 1.480M retained)
24.814k objects ( 24.793k retained)
50.000 strings ( 50.000 retained)
Экспорт 100 заявок в csv:
852.195k memsize ( 849.968k retained)
12.034k objects ( 12.007k retained)
50.000 strings ( 50.000 retained)
```
#### Оптимизация 2: потоковая запись файла
Весь процесс формирования отчета можно изобразить такой схемой:
В принципе, уже при взгляде на нее не сложно догадаться, где раздувается память. В ReportWorker’е мы целиком формируем пулл объектов и передаем его наш сервис. Но можно попробовать записывать данные в потоковом режиме. Если передавать в сервис только массив айдишников, мы можем использовать в нем такой метод для формирования коллекции:
```
def export_collection(objects_ids)
Application.where(id: objects_ids.uniq).order(created_at: :desc)
end
```
Но как сделать так, чтобы результаты запроса к базе не загружались в память целиком, а обрабатывались по очереди? Тут нам поможет метод ActiveRecord `find_each`:
```
def to_csv_export(objects_ids)
CSV.open(file_path, 'w') do |csv|
csv << export_headers # массив с заголовками отчета
export_collection(objects_ids).find_each do |application| # Не загружаем объекты в память, а итерируемся по ним поочередно
begin
csv << export_row(application.decorate) # метод для формирования строки отчета
rescue StandardError => e
errors << "#{application.id}: #{e}"
end
end
end
end
```
В итоге, следующий замер потребления памяти показал такие результаты:
```
Для 100 заявок:
166.688k memsize ( 165.445k retained)
1.729k objects ( 1.715k retained)
50.000 strings ( 50.000 retained)
Для 1000 заявок:
167.510k memsize ( 166.227k retained)
1.734k objects ( 1.719k retained)
50.000 strings ( 50.000 retained)
```
То есть, как мы и ожидали, память не раздувается, независимо от того, какое количество заявок мы хотим выгрузить в файл.
### Заключение:
Итак, парочка достаточно простых оптимизаций, — и отчет, который раньше требовал 18,5 Гб, теперь укладывается менее чем в 200 Кб. Можно было и эту цифру сократить, например, выгружая из базы данных не весь объект целиком, а лишь те поля, которые нам нужны. Но в нашем случае пришлось бы сильно пожертвовать читабельностью кода, а заданный бюджет и так вполне устраивает, поэтому оптимизировать память дальше я не стал. А вот скорость оставляла желать лучшего. Но о том, как мы справились с этой проблемой, я расскажу вам в следующем посте.
> Спойлер: скорость нам удалось увеличить в 170 раз, и сократить время формирования отчета с нескольких часов до одной минуты | https://habr.com/ru/post/494862/ | null | ru | null |
# Самые распространенные ошибки в вашем React коде, которые вы (возможно) делаете
Вдохновленный прочитанными статьями на медиуме, я решил написать свою статью и рассказать вам как можно избегать самых распространенных ошибок в вашем React приложении и для чего это нужно делать.
Весь код написан в ES6 стиле, поэтому, что бы повторить его вам нужно использовать [Babel](https://github.com/babel/babel) в вашем проекте (а еще есть такие кто его не использует?).
Я постарался объяснить как можно подробнее каждую ошибку, поэтому, моя статья больше ориентирована на молодых разработчиков, которые еще находятся в поиске новых знаний. Хотя, как мне кажется, и опытный разработчик может найти для себя пару интересных вещей в этой статье.
Если вам интересно, то добро пожаловать под кат.
В скобках перед каждым параграфом я оставил ссылку на eslint правило. Вы сможете позднее [найти их в git](https://github.com/yannickcr/eslint-plugin-react/blob/HEAD/docs/rules/no-direct-mutation-state.md) и добавить в свой проект.
### (react/forbid-component-props)
Первая распространенная ошибка это передача 'style' и 'className' как props в ваш компонент. Избегайте этого, так как вы [добавите много сложности в ваши компоненты.](https://brigade.engineering/don-t-pass-css-classes-between-components-e9f7ab192785)
Вместо это можно использовать библиотеку ['classnames'](https://github.com/JedWatson/classnames) и добавить интересные вариации в ваш компонент (если вы используете css классы):
```
const { hasError, hasBorder } = this.props;
const componentClasses = classnames({
'your-component-main-class': true,
'your-component-main-class_with-error': hasError,
'your-component-main-class_with-border': hasBorder,
});
```
### (react/forbid-prop-types)
Следующая ошибка — не информативные propTypes. Не используйте PropTypes.any, PropTypes.array и PropTypes.object. Описывайте ваши props как можно подробнее. Это позволит вам оставить хорошую документацию на будущее, и вы (или другой разработчик) еще не раз скажите себе большое спасибо.
```
class MyComponent extends React.Component {
static propTypes = {
user: PropTypes.shape({
id: PropTypes.number,
name: PropTypes.string,
}),
policies: PropTypes.arrayOf(PropTypes.shape({
id: PropTypes.number,
type: PropTypes.string,
value: PropTypes.string,
}),
}
}
```
### (react/forbid-foreign-prop-types)
Давайте продолжим с propTypes. Не используйте propTypes другого компонента:
```
import SomeComponent from './SomeComponent';
SomeComponent.propTypes;
```
Создайте файл в котором вы будете содержать в порядки ваши глобальные propTypes:
```
import { userShape, policiesArray } from '../common/global_prop_types';
```
Это поможет [babel-plugin-transform-react-remove-prop-types](https://github.com/oliviertassinari/babel-plugin-transform-react-remove-prop-types) убрать propTypes из продакшен кода и сделать ваше приложение чуточку легче.
### (react/no-access-state-in-setstate)
Следующая ошибка очень интересная:
```
class MyComponent extends React.Component {
state = {
counter: 1,
};
incrementCounter = () => this.setState({ counter: this.state.counter + 1 });
massIncrement = () => {
// this code will lead to not what you expect
this.incrementCounter();
this.incrementCounter();
}
}
```
Потому что setState это асинхронная функция состояния state в обоих случаях будет одинаковым.
this.state.counter будет равен 1 и мы получим:
```
incrementCounter = () => this.setState({ counter: 1 + 1 });
incrementCounter = () => this.setState({ counter: 1 + 1 });
```
Для того, что бы это избежать можно использовать setState callback который получает как аргумент прошлое состояние state:
```
incrementCounter = () => this.setState((prevState) => ({ counter: prevState.counter + 1 }));
```
### (react/no-array-index-key)
Эта ошибка так же очень часто встречается, поэтому, прочтите внимательно и избегайте ее в будущем:
```
users.map((user, index) => (
));
```
React использует prop key как ссылку к DOM элементу, и это помогает ему быстро найти и отрендерить нужный компонент (все, конечно, сложнее, но я упростил специально).
Что случиться если вы добавите нового юзера в середину массива? React будет вынужден перерендерить все UserComponents после добавленного нового, так как индекс будет изменен для большого кол-ва компонентов. Используйте уникальные ключи вместо этого. Очень простой выход это id, которые вы получаете из вашей базы данных:
```
users.map((user) => (
));
```
### (react/no-did-mount-set-state), (react/no-did-update-set-state)
Эта ошибка так же очень часто встречается в моей практике. Если вы попытаетесь обновить state в componentDidUpdate методе, вы получите бесконечный цикл ре-рендера. React начинает проверку на ре-рендер когда у компонента меняется state или props. Если вы поменяете state после того как компонент замаунтился в DOM или уже обновился, вы запустите проверку заново и заново и заново…
При обновлении стейта в componentDidMount вы можете вызвать ре-рендер компонента еще один раз, так как функция вызывается один раз после маунтинга компонента в DOM.
Если у вас возникает необходимость обновлять данные именно после маунтинга компонента, я предлагаю использовать переменные класса:
```
class MyComponent extends React.Component {
componentDidMount() {
this.veryImportantDataThatCanBeStoredOnlyAfterMount = 'I'll be back!';
}
veryImportantDataThatCanBeStoredOnlyAfterMount = void 0;
render() {
return
}
}
```
### (react/no-direct-mutation-state)
Мутация state это очень большая ошибка. Неконтролируемая мутация state приведет к необнаруживаемым багам и, как следствие, к большим проблемам. Мое персональное мнение это использование [immutable-js](https://facebook.github.io/immutable-js/), как библиотеку, которая добавляет иммутабельные структуры. И их вы можете использовать с Redux/MobX/Любой библиотекой state менеджмента. Так же вы можете использовать [deepClone из lodash](https://lodash.com/docs/#cloneDeep) для клонирования state и последующей мутации клона или использовать новую фичу JS — деструкцию (destructuring):
```
updateStateWrong = () => this.state.imRambo = true;
updateStateRight = () => {
const clonedState = cloneDeep(this.state);
clonedState.imAGoodMan = true;
this.setState(clonedState);
}
updateWithImmutabelJS = () => {
const newState = this.state.data.set('iUseImmutableStructure', true);
this.setState(data: newState);
}
updateWithDestructuring = () => this.setState({ ...this.state, iUseDestructuring: true });
```
### (react/prefer-stateless-function)
Данное правило описывает больше улучшение вашего кода и приложения, чем ошибку, но я, все же, рекомендую следовать этому правилу. Если ваш компонент не использует state, сделайте его stateless компонентом (мне больше нравиться термин 'pure component'):
```
class MyComponentWithoutState extends React.Component {
render() {
return I like to write a lot of unneeded code
}
}
const MyPureComponent = (props) => Less code === less support
```
### (react/prop-types)
Пожалуйста, всегда добавляйте проверку на типы props (propTypes) если ваш компонент получает props. Думайте об этом как о документировании вашего кода. Вы еще не раз скажете себе 'спасибо' за это (а может быть и мне :)). PropTypes поможет вам понять и разобраться, что ваш компонент может отрендерить, а так же, что ему нужно для рендеринга.
```
MyPureComponent.propTypes = {
id: PropTypes.number.isRequired, // And I know that without id component will not render at all, and this is good.
}
```
### (react/jsx-no-bind)
Очень распространенная и большая ошибка которую я видел в коде много раз. Не Используйте Bind И Arrow Function В Jsx. Никогда. Больше.
Самое жаркое место в аду ждет того кто пишет .bind(this) в JSX в обработчике событий.
Каждый раз когда компонент рендериться ваша функция будет создаваться заново, и это может сильно затормозить ваше приложение (это связано с тем, что garbage collector будет вынужден запускаться значительно чаще). Вместо .bind(this) вы можете использовать Arrow functions определенным образом:
```
class RightWayToCallFunctionsInRender extends React.Component {
handleDivClick = (event) => event;
render() {
return
}
}
const handleDivClick = (event) => event;
const AndInPureComponent = () => {
return
}
```
### (react/jsx-no-target-blank)
Ошибка связанная с безопасностью. Для меня выглядит очень странно, что люди до сих пор делают эту ошибку. Очень много людей написало очень много статей на эту тему в 2017.
Если вы создаете ссылку с target='\_blank' атрибутом не забудьте добавить к ней rel='noreferrer noopener'. Очень просто:
Спасибо вам!
------------
Это все, что я бы хотел рассказать вам в рамках этой статьи. Я буду очень вам признателен, если вы, мои читатели, оставите мне ваш отзыв или комментарий, и поделитесь в нем вашим мнением относительно проблем, которые я описал в этой статье. Так же, вы можете рассказать мне про мои и ваши ошибки в коде и про все, что посчитаете нужным рассказать. Спасибо вам еще раз! | https://habr.com/ru/post/416511/ | null | ru | null |
# Скорость времени
Сколько нужно времени, чтобы снять показания времени? Каков хронометраж времени? Эти странные вопросы выплыли в публичную плоскость еще в 2014 году, когда Netflix переносил свои сервисы с CentOS Linux на Ubuntu, а автору этой статьи довелось помогать в отладке некоторых причудливых проблем с производительностью. Одна из этих проблем и будет описана ниже. Конечно, маловероятно, что вы когда-нибудь столкнетесь с именно такой проблемой, но интересен сам тип данной проблемы и метод отладки, позволивший с ней справиться – на самом деле, очень простой. Прагматичное сочетание инструментов для наблюдения за ситуацией и постановки экспериментов. Автор этого текста, Брендан Грегг, делился множеством постов о суперсиле наблюдательных инструментов, но часто бывает и так, что непритязательный хакинг не менее эффективен.
Cassandra, кластер для работы с базами данных, переключили на Ubuntu – и стало заметно, что задержка при записи возросла более чем на 30%. Экспресс-проверка базовой статистики по производительности показала, что потребление ресурсов ЦП возросло более чем на 30%. Что же такое выделывает Ubuntu, если ей на это требуется на 30% больше процессорного времени?!
### 1. Инструменты CLI
Системы Cassandra представляли собой виртуализованные на Xen инстансы EC2. Автор этой статьи попробовал зайти на один из них и для начала прогнать некоторые базовые инструменты для работы с интерфейсом командной строки (составил для этой цели специальный [чеклист](https://www.brendangregg.com/Articles/Netflix_Linux_Perf_Analysis_60s.pdf)). Может быть, это какая-то другая программа пожирает ЦП, например, распоясавшийся сервис Ubuntu, которого не было в CentOS? top(1) показала, что ЦП потребляет только база данных Cassandra.
Что насчет короткоживущих процессов, например, циклически перезапускаемого сервиса? Такие вещи могут оставаться невидимы для top(8). Автор попробовал инструмент execsnoop(8) (в те времена это еще была версия [Ftrace](https://github.com/brendangregg/perf-tools)), но он ничего не показал.
Казалось, что лишнее процессорное время тратится именно в Cassandra, но как?
### 2. Профиль ЦП
Будет легко составить впечатление о процессорном времени, если сравнить [ступенчатые графики ЦП](https://www.brendangregg.com/FlameGraphs/cpuflamegraphs.html). Поскольку рассматриваемые инстансы, как CentOS, так и Ubuntu, работали параллельно, удалось одновременно снять с них ступенчатые графики и сопоставить их.
Ступенчатый график CentOS:
Ступенчатый график Ubuntu:
Черт возьми, да они же не работают. Здесь нет никакого стека Java – иначе зеленые методы Java должны были выситься как башня – а найдется всего один, максимум два зеленых кадра. Вот как ступенчатые графики Java выглядели в то время. Несколько позже автору довелось прототипировать заплатку для указателя кадров c2; в результате получилась -XX:+PreserveFramePointer, фиксирующая стеки Java в этих профилях.
Даже с незафиксированными стеками Java была заметна большая разница: на Ubuntu куча процессорного времени тратится на вызов libjvm: os::javaTimeMillis(). 30,14% в середине ступенчатого графика. Поиск показывает, что и в другом месте на него тратилось лишнее время, в сумме 32,1%. Этот сервер тратит около трети циклов процессора, просто проверяя время!
Если задуматься, сама эта проблема кажется дикой: время превратилось в ресурс и в материал, требующий анализа производительности.
Оказалось, что поврежденные стеки Java даже пригодились. Благодаря ним вызовы os::javaTimeMillis() объединились в группы, а в противном случае они могли бы быть рассеяны поверх различных путей кода в Java, лежали бы повсюду как тоненькие стеки. Чтобы проверить, не так ли обстоит дело, автор специально прошерстил код, чтобы найти их суммарный процент, а также обратил порядок слияния, так, чтобы получился график-сосулька, где один из листьев сцеплен с корнем. Но в данном случае почти ничего делать не пришлось, потому что порядок объединения оказался в основном случайным. (Это была одна из причин, чтобы переключиться на ступенчатые графики от d3, поскольку библиотека d3 интерактивна и позволяет скрывать часть кадров: например, все кадры Java, все кадры из пользовательского режима, т.д.). Такой подход позволил высветить различные группы, например, упомянутую выше.
### 3. Изучение ступенчатого графика
os::javaTimeMillis выбирает текущее время. Обзор ступенчатого графика показывает, что системный вызов gettimeofday(2) выполняется при входе в функции ядра tracesys() и syscall\_trace\_enter/exit(). Вырисовывается две теории, позволяющие это объяснить: А) В Ubuntu включена некая трассировка системных вызовов (аудит? apparmor?). B) В Ubuntu выбор времени идет немного медленнее, это может быть связано с изменениями в библиотеке или ядре/источнике тактов.
Теория (A), вероятнее всего, основана на ширине кадров в ступенчатом графике. Но не вполне убедительна. Этот профиль в Xen – гостевой, поэтому информация собиралась при помощи perf(1) и мягких прерываний программы cpu-clock из ядра, а не на уровне аппаратного немаскируемого прерывания (NMI). Без NMI (с отключенными прерываниями) некоторые пути кода в ядре не поддаются профилированию. Кроме того, по причине гостевого статуса в Xen, время гипервизора вообще не профилируется. В силу двух этих факторов ступенчатый график может не учитывать время, потраченное в ядре и гипервизоре, поэтому истинные потери времени в os::javaTimeMillis могут быть немного иными.
Обратите внимание: в Ubuntu также есть кадр, в котором показывается вход в vDSO (виртуальный динамический разделяемый объект). Это ускоритель системных вызовов, относящийся к пользовательскому режиму, а gettimeofday(2) – классический вариант его использования, даже процитированный на странице справки man, посвященной vdso(7). Было время, когда источник pvclock в Xen не поддерживал vDSO, поэтому код системного вызова просматривался над кадром vdso. Такая же ситуация складывается и в CentOS, хотя, там кадр vdso не включается в ступенчатый график (предположительно, только из-за разницы в perf(1)).
### 4. Коллеги/Интернет
Инструменты для [анализа производительности в Linux хороши](https://www.brendangregg.com/linuxperf.html). Но иногда проблемы нужно решать быстро, поэтому целесообразнее просто обратиться к коллегам или поискать в Интернете. Нужно об этом сказать, просто в качестве напоминания для всех, кто привык самостоятельно выполнять анализ такого рода.
### 5. Эксперименты
Для дальнейшего анализа ситуации при помощи наблюдательных инструментов, можно было:
A. Зафиксировать стеки Java, чтобы посмотреть, есть ли разница в использовании времени на Ubuntu. Может быть, Java по какой-то причине выполняет вызовы чаще.
B. Отслеживать путь gettimeofday() и других подобных ему системных вызовов, чтобы посмотреть, есть ли какая-либо разница там. Например, ошибки.
Но, как резюмировано в посте [What is Observability](https://www.brendangregg.com/blog/2021-05-23/what-is-observability.html), сам феномен «наблюдаемости» — это напоминание не увлекаться единственным типом анализа. Вот еще некоторые экспериментальные подходы, которые стоит изучить:
C. Отключить tracesys/syscall\_trace.
D. Провести микробенчмаркинг os::javaTimeMillis() в обеих системах.
E. Попытаться изменить источник тактов для ядра.
Поскольку © выглядит как пересборка ядра, лучше начать с (D) и (E).
### 6. Измеряем скорость времени
Есть ли уже микробенчмаркинг для os::javaTimeMillis()? В таком случае можно было бы убедиться, что на Ubuntu эти вызовы действительно притормаживают.
Автору такой микробенчмарк найти не удалось, поэтому он сам написал довольно простой код. Не пытаясь делать вызовы «до» и «после», чтобы измерить длительность времени (хотя, такой подход должен сработать, если учесть при анализе те излишки времени, которые тратятся на сами замеряющие вызовы), автор решил просто сделать цикл, в котором миллионы раз вызывается показатель времени и проверить, сколько времени на это уходит (сорри, тавтология тут неизбежна):
```
$ cat TimeBench.java
public class TimeBench {
public static void main(String[] args) {
for (int i = 0; i < 100 * 1000 * 1000; i++) {
long t0 = System.currentTimeMillis();
if (t0 == 87362) {
System.out.println("Bingo");
}
}
}
}
```
Этот код 100 миллионов раз вызывает currentTimeMillis(). Затем этот код выполняется при помощи оболочечной команды time(1), позволяющей определить общее время выполнения всех этих 100 миллионов вызовов. В цикле также есть тест и println(). Остается надеяться, что компилятор не выкинет при оптимизации этот цикл, ведь в остальном он пуст. Поэтому тест немного замедляется.
Попробуем:
```
centos$ time java TimeBench
real 0m12.989s
user 0m3.368s
sys 0m18.561s
ubuntu# time java TimeBench
real 1m8.300s
user 0m38.337s
sys 0m29.875s
```
Сколько длится каждый вызов времени? Предполагая, что именно на вызовы времени уходит львиная доля цикла, имеем около 0,13 μs на Centos и 0,68 μs на Ubuntu. Ubuntu работает впятеро медленнее. Поскольку нас интересует относительное сравнение, можно просто сравнить общие значения времени исполнения («реальное» время) и получить такой же результат.
Вот тот же самый код на C, в нем gettimeofday(2) вызывается напрямую:
```
$ cat gettimeofdaybench.c
#include
int
main(int argc, char \*argv[])
{
int i, ret;
struct timeval tv;
struct timezone tz;
for (i = 0; i < 100 \* 1000 \* 1000; i++) {
ret = gettimeofday(&tv, &tz);
}
return (0);
}
```
Компилируем это с -O0, чтобы цикл не отбрасывался. При прогоне этого кода на двух системах результаты получаются схожими.
Такие короткие бенчмарки хороши тем, что результирующий двоичный код можно дизассемблировать и убедиться, что скомпилированные инструкции именно такие, какими мы ожидаем их увидеть, и компилятор с ними не запутался.
### 7. Эксперименты с clocksource
Второй эксперимент заключается в изменении источника кадров (clocksource). На выбор есть такие:
```
$ cat /sys/devices/system/clocksource/clocksource0/available_clocksource
xen tsc hpet acpi_pm
$ cat /sys/devices/system/clocksource/clocksource0/current_clocksource
xen
```
Окей, по умолчанию выбирается xen, который мы уже видели в ступенчатом графике (башня заканчивается pvclock\_clocksource\_read()). Давайте попробуем tsc, этот вариант должен быть быстрее всех:
```
# echo tsc > /sys/devices/system/clocksource/clocksource0/current_clocksource
$ cat /sys/devices/system/clocksource/clocksource0/current_clocksource
tsc
$ time java TimeBench
real 0m3.370s
user 0m3.353s
sys 0m0.026s
```
Изменения наступают немедленно, и теперь микробенчмарк на Java бегает в 20 с лишним раз быстрее, чем раньше! (Причем, почти вчетверо быстрее, чем на CentOS.) Теперь он достигает 33 ns, по-видимому, этот результат даже раздут из-за инструкций цикла. При желании большей точности можно было бы частично [свернуть цикл](https://www.brendangregg.com/blog/2014-04-26/the-noploop-cpu-benchmark.html), так, чтобы инструкции цикла стали пренебрежимы.
### 8. Обходной маневр
Счетчик временных меток (TSC) в качестве источника тактов быстр, так как извлекает время при помощи одной лишь инструкции RDTSC, тогда как при использовании vDSO здесь не обойтись без системного вызова. Традиционно TSC не выставляется из-за опасений, связанных с разбежкой времени. Эти проблемы можно было бы исправить при помощи программных источников тактов и обеспечить точное, монотонно текущее время.
Как раз в период отладки этой проблемы автору довелось выступать на технической конференции, и там он поделился этой проблемой с инженером по процессорам. Тот сказал, что tsc стабилен долгие годы, и совет избегать этого источника уже устарел. Правда, никакой ссылки на это из открытых источников он привести не смог.
Благодаря этой случайной встрече, а также тому, насколько отказоустойчиво облако Netflix, с которым работал автор, мы вслед за ним рекомендуем попробовать tsc в продакшене в качестве обходного маневра при решении описываемой проблемы.
Изменения в продакшен-графиках очевидны; заметно, насколько упала задержка при записи:
При более обширном тестировании выясняется, что задержка при записи падает на 43%, поэтому достигается производительность чуть выше, чем на CentOS.
Ступенчатый график ЦП на Ubuntu приобретает следующий вид:
os::javaTimeMillis() теперь составляет всего 1,6%. Обратите внимание: теперь она входит в "[[vdso]]" – и все: никаких вызовов ядра поверх нее.
### 9. Что было после
Автор сообщил подробности в AWS и Canonical, а потом переключился на решение других проблем с производительностью в рамках миграции. Майк Хуан, коллега автора, также столкнулся с описанной проблемой при работе над другой службой Netflix и включил tsc. В итоге этот вариант был выбран в BaseAMI во всех облачных сервисах.
По состоянию на 2022 год эта проблема с источником тактов на виртуальных машинах широко известна. В 2021 году в Amazon даже выпустили официальную [рекомендацию](https://aws.amazon.com/premiumsupport/knowledge-center/manage-ec2-linux-clock-source/):
> «Для инстансов EC2, запущенных на гипервизоре AWS Xen, лучше всего использовать tsc в качестве источника тактов. На инстансах EC2 других типов, например, C5 или M5, используйте в качестве гипервизора AWS Nitro. Рекомендуемый источник тактов для гипервизора AWS Nitro — kvm-clock.»
Соответственно, дела изменились в [Nitro](https://www.brendangregg.com/blog/2017-11-29/aws-ec2-virtualization-2017.html), где источники тактов гораздо быстрее (и это здорово!). В 2019 году автору с коллегами довелось тестировать kvm-clock и убедиться, что он всего на 20% уступает в скорости tsc. Уже гораздо лучше, чем источник тактов xen, но автор по-прежнему сохраняет верность tsc за неимением причин с него уходить (например, чтобы снова не возникли разбежки по времени с часами tsc).
Комплект для бенчмаркинга JMH также позволяет тестировать System.currentTimeMillis(), поэтому уже нет необходимости выкатывать собственный вариант (если, конечно, не собираетесь его дизассемблировать, но на такой случай лучше взять что-нибудь короткое и простое).
Что касается tracesys: автор изучил издержки, затрачиваемые на другие системные вызовы и счел их пренебрежимыми, а когда вернулся к работе над этими вызовами, пути кода в ядре уже изменились. В чем было дело – возникла ли ошибка конфигурации в новом релизе Ubuntu, либо эти изменения возникли при аудите и позже были исправлены? Автору хотелось докопаться до сути этих проблем, а они взяли и исчезли. Как бы то ни было, он все равно рекомендует использовать в качестве источника тактов tsc, а не вариант xen, так как в таком случае производительность вчетверо выше.
### 10. Заключение
При работе с некоторыми источниками тактов сама процедура измерения времени может стать узким местом. Много лет назад, на гостевых профилях в виртуальных машинах Xen ситуация была гораздо хуже. В Linux tsc многие годы остается самым быстрым источником тактов, но только вендор процессоров может уверенно судить о том, возникают ли в tsc какие-либо проблемы с разбежкой часов. По крайней мере, официальная рекомендация AWS по-прежнему актуальна.
Кроме того, даже при наличии сверхмощных трассировочных инструментов, иногда лучше просто сесть и разобраться с системой вручную. Как в этом случае – расставить пару импровизированных бенчмарков, каждый длиной всего несколько строк кода. Всякий раз при исследовании производительности некого небольшого дискретного системного компонента, старайтесь найти и выкатить собственный ситуативный бенчмарк и добывать нужную информацию собственными изысканиями. Наблюдение и эксперимент всегда идут рука об руку.
[](https://cloud.timeweb.com/vds-promo-8-rub?utm_source=habr&utm_medium=blog_1560_476&utm_campaign=habr&utm_content=1560_476) | https://habr.com/ru/post/682930/ | null | ru | null |
# Рисуем коммитами на Гитхабе
[Пятничное]
Всегда хотел сделать свой график активности пользовательского профиля на Гитхабе. Например, выкладывать коммиты каждый день так, чтобы через год этот график превратился в какую-нибудь картинку, пусть и с ограничением по размерам в 52×7 квадратиков-пикселей (52 недели в году × 7 дней в неделе).
Проблема была в том, что даже при полной автоматизации процесса всё равно ждать целый год. А тут я почитал документацию Гитхаба и понял, что задача решается проще и более того — за один раз. А значит, надо делать не откладывая. Обычно названия проектам придумывать сложно, но тут оно пришло само. *Кай* рисовал льдинками, а [*Герда* рисует коммитами](https://github.com/sijeko/gerda)!
[](https://habrahabr.ru/post/319298/#habracut)
Как это работает
----------------
Используется существующее на данный момент (преднамеренное?) поведение Гитхаба при построении графика активности, учитывающее предоставленные клиентом *локальные даты коммитов*. Подробнее эту тему можно изучить в [справке сервиса](https://help.github.com/articles/why-are-my-contributions-not-showing-up-on-my-profile/).
А поскольку Гитхаб доверяет локальным датам, указанным в коммите, можно отправить ему сколько угодно коммитов с какими угодно датами:
```
echo "С Новым годом тебя, часовой пояс +3!" >> gerda.md
git add gerda.md
git commit -m "Правки к Новому году" --date="0001-01-01T00:00:00+0300"
```
Таким образом, наша задача состоит в автоматизации самого процесса создания коммитов с нужными датами. Говоря проще, надо написать скрипт, который генерирует скрипт, который создаёт нужные коммиты. По пути ещё надо не забыть, что график профиля использует недели с воскресным, а не понедельничным первым днём.
Лучше всего скриптам скармливать картинки в более-менее человекочитаемом формате, например, массивом строк или вообще реальные файлы изображений. Я для простоты парсинга сделал строки. Гитхаб отображает пять разных оттенков цвета в графике, чем темнее оттенок, тем больше активность пользователя в заданный день. Возьмём для примера три:
* пробел **␣** — отсутствие оттенка — никакой активности в заданный день,
* звёздочка **\*** — светлый оттенок — средняя активность в заданный день,
* решётка **#** — тёмный оттенок — большая активность в заданный день.
Например, напишем слово „ПРИВЕТ“ (используем звёздочку в качестве антиалиасинга для „плавных“ переходов):
```
$commits = [
/* columns
' 10→| 20→| 30→| 40→| 50→| ' ← exactly 52 characters */
' ####### #####* # # ##### ###### ####### ', // Sun
' # # # # # ## # # # # ', // Mon
' # # # # # # # # * # # ', // Tue
' # # #####* # # # ##### ##### # ', // Wed
' # # # # # # # # # # ', // Thu
' # # # ## # # # # # ', // Fri
' # # # # # #####* ###### # ', // Sat
];
```
Лучше оставлять по паре недель (пробелов) слева и справа — чтобы меньше мешала текущая активность.
Теперь самое сложное — разобрать этот массив, соотнеся каждый символ в нём с каким-то определённым днём. У меня получилось так:
```
/**
* Генерация набора коммитов.
*
* @param string[] $map Карта коммитов в виде массива из 7 строк по 52 символа каждая
* @param \DateTime $firstSunday Дата последнего воскресенья год назад
* @return array
*/
function generateCommits($map, $firstSunday)
{
$commits = [];
$count = 7 * 52;
$date = clone $firstSunday;
// Идём по всем символам карты коммитов, вычисляя неделю и день недели
for ($day = 0, $weekDay = 0; $day < $count; $day++) {
$week = intval($day / 7);
$char = substr($map[$weekDay], $week, 1);
if ($char !== ' ') {
$commits[$date->format('Y-m-d')] = $char === '#' ? 20 : 10;
}
// Переходим к следующему дню
$date->add(new DateInterval('P1D'));
$weekDay = ($weekDay + 1) % 7;
}
return $commits;
}
```
В результате получаем ассоциативный массив (словарь), где ключ — день недели, а значение — количество коммитов, необходимых в этот день:
```
$commits = [
// ...
'2016-01-31' => 10,
'2016-02-01' => 20,
'2016-02-02' => 20,
'2016-02-03' => 10,
// ...
]
```
Дальше всё совсем просто: проходим по этому словарю и пишем в результирующий шелл-скрипт нужное количество коммитов для каждого дня (для часового пояса я использовал московское время). В качестве подопытного файла используем маркдаун-документ, в текст которого с каждым коммитом добавляем день или какую-нибудь другую информацию (у меня это маркированный список с номером коммита в этот день):
```
git init
echo "# Gerda" > gerda.md
echo "\n## 2016-01-31" >> gerda.md
echo "* Gerda №1" >> gerda.md
git add gerda.md
git commit -m "Gerda №1" --date="2016-01-31T12:00:00+0300"
# ... так 10 раз ...
echo "\n## 2016-02-01" >> gerda.md
echo "* Gerda №1" >> gerda.md
git add gerda.md
git commit -m "Gerda №1" --date="2016-02-01T12:00:00+0300"
# ... так 20 раз ...
echo "\n## 2016-02-02" >> gerda.md
echo "* Gerda №1" >> gerda.md
git add gerda.md
git commit -m "Gerda №1" --date="2016-02-02T12:00:00+0300"
# ... так 20 раз ...
echo "\n## 2016-02-03" >> gerda.md
echo "* Gerda №1" >> gerda.md
git add gerda.md
git commit -m "Gerda №1" --date="2016-02-03T12:00:00+0300"
# ... так 10 раз ...
```
Программирование логики готово. Вынесем все нужные настройки в один файл `settings.php`, чтобы отделить данные от логики:
```
// Streak graph picture
$commits = [ ... ];
// Repository origin
$origin = 'https://github.com/maximal/gerda.git';
// Output shell file
$commandFile = 'repo' . DIRECTORY_SEPARATOR . 'make-commits.sh';
```
Разумеется, чтобы Гитхаб понял, от какого пользователя были произведены коммиты, в настройках Гита должны стоять ваш логин и почтовый ящик:
```
# ~/.gitconfig
[user]
name = my_github_username
email = my_github_email@ya.ru
### ...
```
Придумываем нужный нам график активности. Пишем желаемую картинку в настройках. Запускаем то, что получилось:
Ой, пятница от радости выпрыгнула за ограничение в 52 символа. Поправим:
Скрипт с коммитами создан, запустим его:
```
cd repo
./make-commits.sh
```
По окончании работы скрипта (как правило, там пара тысяч коммитов: придётся подождать минутку), Гитхаб спросит ваш пароль. Вводить пароли в чужие (а иногда и в свои) скрипты некруто, поэтому, если хотите, можете завершить скрипт на этом шаге и запушить потом самостоятельно (в сгенерированном скрипте честно-честно только команда `git push`):
```
git remote add origin https://github.com//.git
git push -u origin master -f
```
Ждём пару минут (разумно полагать, что эти данные у Гитхаба кешируются), обновляем страницу профиля.
Готово.
Ссылки
------
Весь исходный код и его описание лежат на (сюрприз!) Гитхабе: <https://github.com/sijeko/gerda>
Будут пулреквесты — заходите на огонёк.
Живая картинка активности на примере моего профиля: <https://github.com/maximal>
Минусы
------
Чего программа не умеет, и что можно доработать:
* Скрипт не учитывает уже существующую Гитхаб-активность, поэтому при плотной текущей занятости картинка,
скорее всего, не получится, или, в лучшем случае, будет смазана.
* Вся „активность“ получается сконцентрированной в одном репозитории и в одном файле,
поэтому если ваша цель — максимальная скрытность, этот скрипт — не вариант.
* Если надо перерисовать картинку, репозиторий придётся сначала удалить на Гитхабе
и потом создать новый с таким же именем — не очень удобно.
* Программа распознаёт три градации цвета, Гитхаб отображает пять — можно улучшить.
* Фиксированный часовой пояс (+3:00, московское время) — можно сделать конфигурируемым.
* Для коммитов используется пользователь по умолчанию из конфигурации Гита — можно сделать изменяемым в наших настройках. | https://habr.com/ru/post/319298/ | null | ru | null |
# Перемещаем ViewState в конец страницы
### Проблема
Продолжаем борьбу с ViewState при использовании WebForms (использование данной технологии обусловлено ~~политикой партии~~ применением [паттерна WCSF](http://msdn.microsoft.com/ru-ru/library/bb264518(en-us).aspx) в проектах фирмы).
В [предыдущей статье](http://habrahabr.ru/blogs/net/60170/) я рассмотрел возможность переноса ViewState из браузера пользователя в сессию. Здорово, что удалось избавиться от ViewState на странице, но с этим способом иногда может возникнуть [проблема](http://habrahabr.ru/blogs/net/60170/#comment_1754811) перезапуска стейт-сервера (хотя мои более опытные товарищи с ней не сталкивались).
Если всё-таки вы решили оставить ViewState на стороне браузера, возникает другая проблема (помимо раздувшегося html) — при прочих равных условиях поисковики ранжируют информацию лучше, если она содержится ближе к началу страницы. Естественно наличие громадного ViewState в начале каждой страницы нежелательно.
### Решение
Итак, все что нам нужно, это перехватить выходной поток, вырезать из начала страницы скрытое поле с ViewState и вставить его перед закрывающим тегом form.
Напишем [адаптер страницы](http://msdn.microsoft.com/ru-ru/library/system.web.ui.adapters.pageadapter.aspx):
> `using System.IO;
>
> using System.Web.UI;
>
>
>
> namespace MyCompany.Web
>
> {
>
> ///
>
> /// Адаптер для перемещения ViewState в конец страницы
>
> ///
>
> public class MoveViewStatePageAdapter : System.Web.UI.Adapters.PageAdapter
>
> {
>
> protected override void Render(HtmlTextWriter writer)
>
> {
>
> // получаем HTML, генерируемый предком
>
> var sw = new StringWriter();
>
> var hw = new HtmlTextWriter(sw);
>
>
>
> base.Render(hw);
>
> var html = sw.ToString();
>
>
>
> hw.Close();
>
> sw.Close();
>
>
>
> // ищем вхождение ViewState
>
> var start = html.IndexOf(@""hidden"" name=""\_\_VIEWSTATE""");
>
>
>
> if (start > -1)
>
> {
>
> var end = html.IndexOf("/>", start) + 2;
>
>
>
> // удаляем ViewState
>
> var viewstate = html.Substring(start, end - start);
>
> html = html.Remove(start, end - start);
>
>
>
> // ищем закрывающий тег формы и пишем перед ним ViewState
>
> var formend = html.IndexOf("") - 1;
>
> html = html.Insert(formend, viewstate);
>
> }
>
>
>
> // выводим HTML
>
> writer.Write(html);
>
> }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В папке App\_Browsers создаем файл default.browser с содержимым:
> `<browsers>
>
> <browser refID="Default">
>
> <controlAdapters>
>
> <adapter controlType="System.Web.UI.Page" adapterType="MyCompany.Web.MoveViewStatePageAdapter" />
>
> controlAdapters>
>
> browser>
>
> browsers>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Смотрим результат!
P.S. Использован код из [Moving ViewState to the Bottom of the Page](http://www.hanselman.com/blog/MovingViewStateToTheBottomOfThePage.aspx)
[Еще одно решение](http://www.csharphelp.com/archives4/archive681.html) с использованием http-модуля. | https://habr.com/ru/post/77187/ | null | ru | null |
# Основные приемы работы с Canvas [Part 1]
Привет! Сегодня я хотел бы начать цикл статей на тему того, как работать с canvas в HTML5 и как применять знания в области матанализа для реализации необычных и интересных эффектов.
Все навыки и умения, которые мы получим здесь, являются фундаментальными принципами и могут быть использованы для создания различных эффектов в играх и приложениях.
Сегодня мы рассмотрим, как рисовать различные фигуры, и реализуем алгоритм [fibonacci flower](https://thatsmaths.com/2014/06/05/sunflowers-and-fibonacci-models-of-efficiency/), также известный как [golden ratio](https://en.wikipedia.org/wiki/Golden_ratio) или [phyllotaxis](http://cs.smith.edu/~cgole/PHYLLOH/NSFcritiques/propose1.pdf).
Подготовительные аспекты
------------------------
Для начала создадим пустой html документ, добавим в него canvas с id = canvas и пропишем немного стилей:
```
#canvas {
position: absolute;
top: 0;
left: 0;
width: 100%;
height: 100%;
background: #fcfcfc;
}
```
Далее получим ссылку на созданый элемент:
```
const canvas = document.getElementById("canvas");
```
Для начала мы будем рассматривать принципы [canvas api](https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API), [webgl api](https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API) рассмотрим в рамках других статей. Для того, чтобы использовать canvas api, необходимо обратиться к интерфейсу CanvasRenderingContext2D, для этого создадим новую переменную context:
```
const ctx = canvas.getContext('2d');
```
А также установим высоту и ширину canvas, равную высоте и ширине окна браузера:
```
canvas.width = window.innerWidth;
canvas.height = window.innerHeight;
```
На этом подготовительные аспекты закончены, и можно приступать к непосредственно работе с графикой.
Arc
---
Arc метод — один из самых базовых методов canvas api и используется для рисования окружностей, а также кривых линий. Метод принимает следующие аргументы:
**x**
Горизонтальная координата центра дуги
**y**
Вертикальная координата центра дуги
**radius**
Радиус дуги
**startAngle**
Угол начала дуги в радианах
**endAngle**
Угол конца дуги в радианах
Сначала давайте нарисуем окружность. Для этого вызовем метод beginPath(), а после — метод arc следующим образом:
```
ctx.beginPath();
ctx.arc(100, 100, 50, 0, Math.PI * 2);
ctx.closePath();
ctx.stroke();
```
Таким образом можно получить окружность.
fillRect
--------
Также мы можем нарисовать прямоугольник используя метод fillRect, который принимает следующие параметры:
**x**
Координата начальной точки прямоугольника по оси X
**y**
Координата начальной точки прямоугольника по оси Y
**width**
Ширина прямоугольника
**height**
Высота прямоуголника
```
ctx.fillRect(0, 0, 100, 200);
```
Анимация
--------
Анимация в мире canvas — всего-навсего цикличная перерисовка, которая создает иллюзию движения. А как же можно создать цикличную перерисовку? Для этого создадим функцию animate и внутри данной функции вызовем метод requestAnimationFrame, передав в него ссылку на созданную функцию. Таким образом функция animate будет перевызываться вновь и вновь до тех пор, пока мы не остановим анимацию:
```
function animate() {
window.requestAnimationFrame(animate);
}
```
Поместим код для рисования окружности во внутрь функции animate и вызовем ее:
```
function animate() {
ctx.beginPath();
ctx.arc(100, 100, 50, 0, Math.PI * 2);
ctx.closePath();
ctx.stroke();
window.requestAnimationFrame(animate);
}
animate();
```
Как мы видим, анимация статична. Для того, чтобы проверить, что все работает корректно, создадим переменную radius и будем использовать ее в качестве аргумента метода arc:
```
function animate() {
size += 0.01;
// ...
ctx.arc(100, 100, size, 0, Math.PI * 2);
// ...
}
```
Также мы можем заставить двигаться нашу окружность, изменяя, например, параметр x метода arc:
```
function animate() {
size += 0.01;
positionX += 0.1;
// ...
ctx.arc(positionX, 100, size, 0, Math.PI * 2);
// ...
}
```
Однако, как можно заметить, мы будем видеть шлейф, идущий за окружностью. Это происходит потому, что мы видим элементы предыдущих фреймов. Для того, чтобы избавиться от данного поведения, можно использовать метод clearRect, который принимает такие же аргументы, как и метод fillRect. В данном случае мы хотим полностью обновить canvas, поэтому вызовем метод следующим образом:
```
ctx.clearRect(0, 0, canvas.width, canvas.height);
```
Fibonacci flower
----------------
Перед тем, как мы рассмотрим принцип реализации данного алгоритма, давайте немного отрефакторим методы анимации. Для этого весь код, который отвечает за рисование на canvas, вынесем в функцию draw. Далее определимся с основными терминами. В основе алгоритма fibonacci flower лежит приницип движения окружности по круговой траектории. Исходя из определения кругового движения, нам необходимо будет считать X как , а Y как 
Это работает потому, что [sin и cos математически связаны с единичной окружностью](https://en.wikipedia.org/wiki/Sine_and_cosine#Relation_to_the_unit_circle). Таким образом получим следующий код:
Развернуть
```
function draw() {
let positionX = 0;
let positionY = 0;
let angle = 0;
let radius = 0;
ctx.beginPath();
ctx.arc(positionX, positionY, 20, 0, Math.PI * 2);
ctx.closePath();
ctx.stroke();
}
function animate() {
draw();
window.requestAnimationFrame(animate);
}
animate();
```
Далее заведем переменный count и scale, в которых будем хранить количество окружностей (частиц) и коэффициент для расчета радиуса соответственно. Таким образом, код примет вид:
```
let count = 0;
let scale = 10;
function draw() {
let angle = count;
let radius = scale * Math.sqrt(count);
let positionX = radius * Math.sin(angle);
let positionY = radius * Math.cos(angle);
// ...
count++;
}
```
Здесь мы на каждой итерации изменяем переменную count, которая увеличивает значение radius, а также positionX и positionY, но чтобы это не происходило слишком быстро, будем использовать квадратный корень от count. Дело за малым, расположить fibonacci flower по центру экрана. Для этого прибавим к positionX и positionY canvas.width / 2 и canvas.height / 2 соответственно.
Меняя коэффициент перед count можно добиться различных результатов, таких как ниже:
РезультатыКоэффициент = 1Коэффициент = 2Коэффициент = 10Чтобы изменить поведение отрисовки, можно изменить параметр [globalCompositeOperation](https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation) на значение destination-over, тогда новые фреймы будут рисоваться под уже отрисованными, что даст вполне интересный эффект:
РезультатыКоэффициент = 0.6Коэффициент = 0.3Финальный листинг будет выглядеть так:
Финальный листинг
```
const canvas = document.getElementById("canvas");
const ctx = canvas.getContext("2d");
canvas.width = window.innerWidth;
canvas.height = window.innerHeight;
ctx.globalCompositeOperation = "destination-over";
let count = 0;
let scale = 10;
function draw() {
let angle = count * 0.1;
let radius = scale * Math.sqrt(count);
let positionX = radius * Math.sin(angle) + canvas.width / 2;
let positionY = radius * Math.cos(angle) + canvas.height / 2;
ctx.fillStyle = "#F24949";
ctx.strokeStyle = "#8B428C";
ctx.beginPath();
ctx.arc(positionX, positionY, 20, 0, Math.PI * 2);
ctx.closePath();
ctx.fill();
ctx.stroke();
count++;
}
function animate() {
draw();
if (count > 1000) return;
window.requestAnimationFrame(animate);
}
animate();
```
В дальнейших статьях мы рассмотрим другие, не менее интересные приемы работы с canvas api и webgl. До скорых встреч! | https://habr.com/ru/post/650175/ | null | ru | null |
# MagOS Linux (сентябрьский выпуск)
Из многих Linux дистрибутивов хотелось найти что-то необычное и обязательно разработанное своими софтвэр энжиниирами, оригинальное.
Magos оказался не совсем дистрибутивом в привычном понимании, а новым шагом живых операционных систем.
*Если взять Mandriva Linux, добавить скриптов linux-live.org и дополнить модульной архитектурой slax…
А потом, конечно же, немного обработать напильником — получим [magos-linux](http://www.magos-linux.ru/index.php?option=com_content&view=article&id=46&Itemid=28) ©*
От стандартных live-image дистров с сохранением, MagOS отличается модульностью, в squashfs помещается не целиком дистрибутив, а для каждой программы выделяется свой mem/loop сегмент, в который из модуля на-лету распаковывается исполняемый код.
Сегодня вышло обновление.
Одним из преимуществ такого подхода является возможное ускорение производительности на high-end cpu, если процессор будет обрабатывать распаковку модуля из .xzm быстрее, чем просто считывать с носителя, естественно используется вся доступная память и побольше.
Поскольку вся система держится в памяти то fault-tolerance в чём-то возрастает, так как изменить модули можно только при определённых условиях, но появляются и проблемы, ведь при отказе системы память будет очищена, а сохранённого состояния на диске не останется, но также появляются и новые возможности. Например, можно создать цельный модуль со всеми необходимыми библиотеками.
> Комментарий Михаила (автор, разработчик):
>
> Модули наслаиваются друг на друга, верхний слой выигрывает (если есть 2 разных файла с одним путем, то доступен только с верхнего слоя)
Сами модули создаются на-лету при установке из центра приложений или можно запустить утилиту и она сконвертирует rpm-пакет в модуль, уже сконвертированные модули можно скачать из хранилища.
На деле — каждый модуль имеет свою «файловую систему» систему и подключается к основной aufs, как живой диск — live-cd, поэтому «установка» проводится также простым копированием или удалением модуля из системы, из-за чего можно достаточно легко собрать постоянный пакет программ.
~~----------------------------------------------~~ Screens ~~----------------------------------------------~~ Screens ~~----------------------------------------------~~ Screens ~~----------------------------------------------~~
в qemu — лучше включить KVM, в virtualbox поддержку PAE.
в параметрах загрузки можно написать
`no3ddesktop, xdriver=fbdev`
чтобы отключить compiz, если нет его поддержки
 
в зависимости от железа и загружаемых модулей, загрузка отнимает определённое время
это «не-лтс» iso образ сегодняшнего выпуска, я дал 2 гига и 4 ядра виртуалке, загрузился примерно за полторы-две минуты, модуль ускорения, ускоряет это время до 20 секунд.
---
Поскольку разработка отнимает достаточно много времени, то было принято решение не заниматься своим дистрибутивом, а сначала обработать другой дистрибутив и проще оказалось работать с rpm, хотя в принципе можно взять любой дистрибутив — вопрос людей и времени доделать скрипты, сейчас это клонирование росы, раньше была магия, а началось ещё с мэндрайвы. Есть репозиторий на github, зеркала на яндексе, однако одной из интересных задач было создание — MagNet, распределённой сети для хранения модулей и общения между пользователями, сейчас концепция претерпевает некоторые изменения. вместе с объявившимися новыми облачными сервисами — появились и новые возможности для реализации.
Одним из лучших решений стала установка дистрибутива в два клика — распаковать и запустить скрипт для изменений в загрузчике, разметка областей диска не нужна — работает c ntfs, vfat, ext3, всё работает даже на текущей системе, легко ставится на флэшку, хотя потенциал есть и реализация возможна для более серьёзных задач, но это потребует больших усилий разработчиков, а необходимо и тестирование, отладка.
Сейчас работа сосредоточена над ускорением запуска системы до уровня DE с 90 секунд до 20, а также над разработкой конвертера в модули, исправлением части ошибок.
> Михаил:
>
> Насчет «с 90 секунд до 20» — эти цифры разные на разных машинах
>
> И я бы не сказал? что мы на этом сосредоточены. У нас не так много разработчиков и каждый занимается тем, что ему интересно. В данном случае Антон начал с этого модуля, в дальнейшем нам придётся заменить скрипты определения оборудования и либо оно войдёт в сборку, как наше отличие от росы, либо останется так же, как в росе.
>
> Из возможностей?
>
> — загрузка с носителя в память и извлечение носителя
>
> — три (четыре для 2012) среды на выбор пользователя + богатый набор приложений, всё это общим весом около 1Г
>
> — настройка через ini файл без изменения модулей дистрибутива
>
> — compiz эффекты раб. стола встроены и настроены для использования в КДЕ Гноме LXDE, их возможно включить с первого запуска
>
> — собственная модификация загрузчика grub4dos c поддержкой кнопок управления в граф. режиме.
>
> — загрузка по сети.
>
> — возможность превратить систему в сервер с ftp smb nfs dhcpd router freenx(терминальный сервер) pxe(загрузка тонких клиентов) sshd hostapd через правку одного ini файла
>
> …
>
> мои возможности ограничены тем временем что у меня остаётся
>
> Фактически остаётся чуть больше, чем требуется для поддержания сборки в текущем состоянии, выпуски сборок происходят раз в месяц.
>
> Развитие по-настоящему будет тогда, когда будут разработчики вроде Антона (neobht) и Александра (betсher), готовые взяться за что-то и довести это до рабочего решения.
Как настоящий openSource project здесь всё делается свободно.
С ответственностью за всё хорошее и плохое, как водится — GPL.
В полном виде дистрибутив занимает гиг [ссылка на зеркало](http://mirror.yandex.ru/mirrors/magos/dist/) или [ссылка на бт трэкер](http://tracker.magos-linux.ru/) поскольку сейчас за основу принят дистрибутив rosa lts (long-term-support) и fresh, то из доступных дэсктопов — gnome. kde. lxde. В tar.gz также лежат скрипты для конвертации в iso, поэтому после исправления конфигураций и смены паролей, можно сделать свой образ диска.
если интересно взглянуть на код или посодействовать — заходите на [github.com/magos-linux](https://github.com/magos-linux/magos-linux/wiki), основное общение происходит на [форуме](http://www.magos-linux.ru/index.php?option=com_agora&id=1&Itemid=55).
*Последняя сборка доступна на торрент-трэкере.*
Happy Linux!
P.S.
ссылки и описание также доступны в вики
[github.com/magos-linux/](https://github.com/magos-linux/magos-linux/wiki/Download) | https://habr.com/ru/post/195710/ | null | ru | null |
# Обходим запрет messages API Вконтакте через Python
Привет, Хабр. В своей [предыдущей статье](https://habr.com/ru/post/491276/) я рассказал о возможности доступа к методам раздела messages через документацию, для чего достаточно было лишь авторизоваться на сайте ВК. Многие тогда заявили, что это не является угрозой личным данным пользователей, а невозможность выкачать свои сообщения — недостаток платформы. Также в комментариях мне оставили ссылку на [node.js библиотеку](http://www.npmjs.com/package/vk-io), которая может авторизовываться по логину/паролю и предоставлять доступ к API сообщений, притворяясь официальным приложением.
> Дисклеймер:
> ===========
>
>
>
> Статья и весь написанный код создавались только в образовательных и исследовательских целях и никогда не использовались для незаконной деятельности. Автор не призывает вас повторять какие либо описанные здесь действия и не несёт за них никакой ответственности.
Но не все люди знакомы c javascript и node.js, поэтому я и решил написать свою библиотеку на python, которым сейчас пользуются многие, позволяющую через «тестовые запросы» документации предоставить полный функционал messages API. Сразу прошу не злиться на меня в местах, где я буду повторять аспекты прошлого «выступления», потому что я хочу оформить эту статью в виде независимой документации.
Как этим пользоваться?
----------------------
Сама библиотека находится [в репозитории github-a](https://github.com/Aragroth/vk_messages) (там же, в папке examples, находятся скрипт с примерами использования из этой статьи). Чтобы установить её на компьютер можно воспользоваться в терминале командой:
> pip install vk-messages
Теперь мы можем импортировать из этого пакета главный класс и создать его экземпляр, указав логин, пароль, какой вид авторизации использует данный аккаунт, а также директорию, куда мы хотим сохранить куки-авторизации пользователя. Это необходимо, чтобы пользователям с двухфакторной авторизацией не пришлось при каждом запуске скрипта постоянном вводить код из сообщения.
```
from vk_messages import MessagesAPI
login, password = 'login', 'password'
messages = MessagesAPI(login=login, password=password,
two_factor=True, cookies_save_path='sessions/')
```
И по сути, на этом всё. Теперь нам остаётся лишь открыть документацию и использовать интересующие нас методы. Хочу сразу отметить, что такой подход позволяет нам использовать практически любой метод из документации, даже не относящийся к разделу messages:
```
history = messages.method('messages.getHistory', user_id='1234567', count=5)
```
Также мы можем комбинировать данную библиотеку с другими, к примеру, через [vk\_api](https://github.com/python273/vk_api) мы можем загрузить фотографии с компьютера (код для этого действия приводится у них в разделе examples), а через vk\_messages прикрепить эти вложения к сообщению:
```
from vk_messages.utils import get_random
messages.method('messages.send', user_id=peer_id, message='Hello',
attachment='photo123456_7891011', random_id=get_random())
```
Из любопытства я реализовал классическую функцию, которая в заданной папке создаёт подпапки людей, с которыми общался человек, и пытается выкачать последние сообщения и абсолютные url-ы фотографий. К моему счастью, всё работало как часы, и лишних ошибок не было:
```
from vk_messages.utils import fast_parser
fast_parser(messages, path='parsing/',
count_conv=10, messages_deep=400, photos_deep=100)
```
Теперь же я хочу перейти к одной из самых интересных частей этой библиотеки: имея куки авторизации, мы можем выполнять абсолютно любые действия. Приведу свой личный пример, когда для постов группы, в которой я состою, мне нужно было составить таблицу, состоящую из ID поста и его *автора*. Но в чём была загвоздка: официальный api возвращает только человека, который *опубликовал* статью. Воспользовавшись сниффером, я увидел, что при наведении на дату публикации поста эти данные подгружаются с сервера. И после этого я написал обёртку, которая позволяла отправлять сколько угодно подобных запросов, используя лишь ссылку поста и куки авторизации, чтобы получать авторов. В примере ниже останется лишь избавиться от ненужных тегов:
```
def get_creators(post, cookies):
group = -int(post.split('_')[0])
response = requests.post('https://vk.com/al_page.php', cookies=cookies,
data=f"_ads_group_id={group}&act=post_author_data_tt&al=1&raw={post}")
response_json = json.loads(response.text[4:])['payload'][1]
return response_json[0]
authors = get_creators(post='-12345_67890',
cookies=messages.get_cookies())
print(authors)
```
Но что доказывает нам верхний кусок кода? Правильно, даже если ВК закроет тестовые запросы на своей документации, мы всегда сможем симулировать действия пользователя и получать нужную информацию. В качестве эксперимента я сделал небольшую функцию, которая через запросы «пролистывания» страницы может получать ссылки на фотографии без использования официального API.
**Код получился слишком большим, поэтому решил скрыть его**
```
def get_attachments(attachment_type, peer_id, count, offset, cookies_final):
if attachment_type == 'photo':
session = requests.Session()
parsed = []
response = session.post(f'https://vk.com/wkview.php',
data=f'act=show&al=1&dmcah=&loc=im&ref=&w=history{peer_id}_photo', cookies=cookies_final)
response_json = json.loads(response.text[4:])
try:
last_offset = response_json['payload'][1][2]['offset']
count_all = response_json['payload'][1][2]['count']
except:
last_offset = response_json['payload'][1][0]['offset']
count_all = response_json['payload'][1][0]['count']
while (len(parsed) < count + offset) and (last_offset != count_all):
response_json = json.loads(response.text[4:])
try:
last_offset = response_json['payload'][1][2]['offset']
except:
last_offset = response_json['payload'][1][0]['offset']
photos_vk = re.findall(r'
```
Выглядит ли это громоздко? Да. Работает ли это намного медленнее, чем официальный api? Да. Но если ВК отнимут последнюю возможность доступа к сообщениям, мы всегда сможем найти выход.
Также отмечу, что я постарался добавить во все места библиотеки, где возможны ошибки, исключения с пояснениями, но если вы найдёте какие-то события, к которым не отображается пояснение, то прошу сообщить мне об этом.
> Думаю, это довольно очевидно, но я всё-таки должен вас предупредить, что нужно быть осторожнее с сохранением куки, так как они по умолчанию сохраняются в той же папке, откуда был запущен скрипт, так что не бросайте их где попало, ведь именно для этого есть возможность выбрать их место сохранения. Кончено, через некоторое время эти куки сами по себе станут невалидными, но до этого момента они могут являться серьёзной угрозой безопасности вашего аккаунта.
>
>
Как это работает?
-----------------
Для тех, кто интересуется, что происходит под капотом данного скрипта, вкратце пройдусь по основным пунктам. При авторизации делаются простые request запросы, симулирующие вход пользователя, которые лишь слегка меняются в зависимости от вида авторизации, а после успешного входа куки сохраняются в pickle файл. При запросе к api через документацию, ко всем настраиваемым параметрам прибавляется «param\_», то есть значение offset превратится в param\_offset. Также в запросе передаётся hash-код, который содержится в атрибуте data-hash тэга кнопки «Выполнить». Насколько я заметил, это значение для каждого метода постоянно.
Так же отмечу один важный момент: пароль отправляется в кодировке ANSI, где символы русского алфавита разделяются знаком "%", и данного кода достаточно для реализации такого декодирования. Это может стать проблемой для некоторых линукс пользователей, ведь, насколько я помню, эта кодировка не входит по умолчанию в python на этой операционной системе.
```
self.password = str(password.encode('ANSI')).replace('\\x', '%')[2:-1]
```
Также одной из проблем для меня стало странное поведение некоторых методов. К примеру, если я менял местами параметры, то скрипт мог вернуть ответ в 10 раз меньше запрашиваемого или вообще ничего не вернуть. Для решения этой проблемы я просто решил распарсивать и отправлять параметры в строгом порядке, как они указаны в документации. Возможно это простое совпадение, но после этого проблем подобного рода у меня не возникало:
```
response = session.get(f'https://vk.com/dev/{name}', cookies=self.cookies_final)
hash_data = re.findall(r'data-hash="(\S*)"', response.text)
soup = BeautifulSoup(response.text, features="html.parser")
params = soup.findAll("div", {"class": "dev_const_param_name"})
params = [cleanhtml(str(i)) for i in params]
payload, checker = '', 0
for param in params:
if param in kwargs:
checker += 1
payload += '&{}={}'.format('param_' + \
param, quote(str(kwargs[param]) if type(kwargs[param]) != bool else str(int(kwargs[param]))))
if checker != len(kwargs):
raise Exception_MessagesAPI('Some of the parametrs invalid', 'InvalidParameters')
```
Итог
----
Что же, для меня данная библиотека стала первым опытом написания «открытых» проектов, поэтому я прошу не судить её строго. Я просто хотел помочь людям, которые столкнутся с такой же проблемой как и я: ограничение messages API. Также я очень хочу поблагодарить знакомых, которые помогали мне с написанием этой статьи и тестированием кода. | https://habr.com/ru/post/491554/ | null | ru | null |
# Катаморфизм в F#
### Введение
Упомяну сразу, данная статья написана по мотивам целой серии постов в отличном блоге [Inside F#](http://lorgonblog.spaces.live.com). Тем не менее она не является переводом в чистом виде, а скорее вольным изложением, чтобы доступным языком объяснить — что же за зверь такой, катаморфизм, и с чем его едят. Слово это думаю не очень на слуху, чего стоит хотя бы тот факт, что статьи по нему нет в русской википедии (и вообще ни в одной национальной, кроме почему-то голландской. Наверно ФП как-то соответсвует духу травокурения)
Итак, строго говоря, [катаморфизм](http://en.wikipedia.org/wiki/Catamorphism) в функциональном программировании — это обобщение свертки списков, которые (как я уже [рассказывал](http://habrahabr.ru/blogs/programming/55272/)) являются специфическим типом размеченного объединения, на произвольные размеченные объединения.
### Свертка списков
Начнем по порядку — со свертки списков. Собственно мы уже знаем, что это такое и как ее использовать, но для того, чтобы распространить ее на другие типы данных, нам еще надо понять, как она осуществляется.
Вот стоит перед нами задача — просуммировать элементы списка. А как вы знаете ~~в СССР секса нет~~ в ФП циклов нет. (Есть конечно, но мы об этом никому не скажем). Вариант List.fold\_left (+) 0 официально объявляется читерским. Что же приходит на ум? Ну вот так (в стиле горячо любимых преподавателями примеров рекурсии для Фибоначчи или факториала):
> `let rec sum list =
>
> match list with
>
> |[] -> 0
>
> |head::tail -> head + sum tail`
Нет друзья, это конечно решение, но будем честны перед собой — хвастаться тут нечем. Потому что при длине цикла скажем, миллион, компилятор выдаст нам System.StackOverflowException, и будет тысячу раз прав — нельзя так над ним издеваться. Окей, перепишем это дело в виде хвостовой рекурсии:
> `let sum\_tail list =
>
> let rec loop list acc =
>
> match list with
>
> |[] -> acc
>
> |head::tail -> loop tail (acc+head)
>
> loop list 0`
Здесь у нас все вычисления происходят немедленно, так что тащить за собой весь хвост нет компилятору никакой необходимости, что его всегда безумно радует. Ну ладно, а что если нам надо скажем найти длину списка (опять же без метода List.length)? Да нет проблем.
> `let rec length list =
>
> let rec loop list acc =
>
> match list with
>
> |[] -> acc
>
> |head::tail -> loop tail (acc+1)
>
> loop list 0`
Думаю, даже не самый наблюдательный читатель может увидеть похожесть двух этих алгоритмов. Разница только в способе обработки аккумуляторного значения. В первом случае мы для каждого рассматриваемого элемента (головы оставшегося куска списка) прибавляем к аккумулятору его значение, во втором — просто единицу. Что это такое по сути? Ничего более чем функция от 'a -> 'b -> 'a, где 'a — тип аккумулятора, 'b — тип элемента списка.
fun acc h -> acc + h (или просто (+)) для первого, fun acc h -> acc + 1 для второго. Свертка списка как раз и является функцией высшего порядка, которая применяет такую функцию ко всем элементам списка, чтобы получить некое атомарное значение. Вот как это выглядит:
> `// ('a -> 'b -> 'a) -> 'a -> list<'b> -> 'a
>
> let rec fold func acc list =
>
> match list with
>
> |[] -> acc
>
> |head::tail -> fold func (func acc head) tail`
И очевидно, что:
> `let sum\_tail = fold (+) 0
>
> let length = fold (fun acc \_ -> acc + 1) 0`
Кстати, не стоит так уж формально относиться к словам о том, что свертка должна возвращать атомарное значение. Взгляните, что делает эта функция?
> `let reverse = fold (fun acc h -> h::acc) []`
Думаю, вы догадались, что она переворачивает список. То есть ее реазультатом тоже является список — такое вот вполне себе атомарное значение.
Ну хорошо, вроде со сверткой разобрались. На самом деле не совсем. Ведь это у нас так называемая левоассоциативная свертка, то есть просмотр элементов и выполнение свертывающей функции на них у нас идет от головы к хвосту. Вот так (f — свертывающая функция): f(… f (acc i0) i1)i2)...ik) А как бы нам сделать правоассоциативную функцию, чтобы было вот так: f i0 (f… (f ik acc)))) (Зачем? Потому что именно от нее будет очень удобно распространять нашу свертку на другие типы данных)
Напишем функцию по аналогии с левоассоциативной сверткой:
> `let rec fold\_right func acc list =
>
> match list with
>
> |[] -> acc
>
> |head::tail -> func head (fold\_right func acc tail)`
и тут же заметим, что теперь у нас рекурсия осуществляется внутри вычисления функции, так что компилятору волей-неволей придется тащить ее в стек, короче, прости-прощай хвостовая рекурсия, здравствуй неминуемй stack overflow. Чтобы избежать этого позора нам необходимо каким-то образом добраться до самого конца списка, запоминая при этом последовательность элементов в обратном порядке, чтобы их свертывать. Но не в стеке же конечно этим заниматься, как в вышеприведенном примере, а в какой-нибудь структуре данных. Простейший способ очевиден — развернуть список, а потом применить на нем левоассоциативную свертку. При этом нашей вспомогательной структурой будет инвертированный список. Все просто и очевидно.
Однако мы пойдем другим путем. В качестве вспомогательной структуры мы будем использовать функцию континуации. Что это такое? — Это такая функция, которая содержит в себе весь необходимый ход вычислений, но не производит, заметьте, сами вычисления, пока мы ей на это специально не укажем. Вот такую функцию мы хотим получить: cont x = f i0 (f… (f ik x)))), все строго согласно определению. В нужный момент она примет в качестве параметра начальное значение аккумулятора и все разом посчитает, как велено. Замечательная функция, не правда ли? Осталось ее получить:
> `let fold\_right func acc list =
>
> let rec loop list cont = //сюда мы передаем текущую функцию континуации
>
> match list with
>
> |[] -> cont acc //а вот и наше ключевое вычисление.
>
> |head::tail -> loop tail (fun racc -> cont (func head racc))
>
> loop list (fun x -> x)`
Заметьте, что теперь функция стала вновь хвостово-рекурсивной, все вычисления производятся безотлагательно, и в следующий шаг рекурсии передается их результат — обновленная функция континуации. И еще, на протяжении всей работы функции, пока список не исчерпается, acc равен начальному значению, то есть называться аккумулятором он уже как-то и не достоин. Скорее это init\_value. А сама функция континуации от шага к шагу меняется вот так:
> `0: x -> x
>
> 1: x -> f i0 x
>
> 2: x -> f i0 (f i1 x)
>
> 3: x -> f i0 (f i1 (f i2 x))`
думаю далее расписывать ход вычислений нет необходимости. Подставив вместо x начальное значение мы получим ровно то, что и хотели.
Что ж, мы разобрались со свертками списков. Правда, пока не понятно, к чему было огород городить, но скоро вы все поймете.
### Свертка деревьев
Итак, как упомянуто во введении, катаморфизм — это обобщение свертки списков на любые алгебраические типы, или размеченные объединения, как они называются в F#. (Как вы помните, список — тоже размеченное объединение)
А теперь рассмотрим вот такое размеченное объединение:
> `type Tree<'a> =
>
> | Node of 'a \* Tree<'a> \* Tree<'a>
>
> | Leaf`
Это у нас, как не сложно догадаться, бинарное дерево, у которого есть осмысленные узлы (кортеж, описывающий его, представляет собой значение и две ветви), и листы-заглушки, употребление которых в кортеже узла просто означает, что данной ветви у него нет.
Вот пример такого дерева:
> `let tree = Node(4, Node(2,Node(1, Leaf,Leaf),Node(3,Leaf,Leaf)),Node(6,Node(5, Leaf,Leaf),Node(7,Leaf,Leaf)))`
А теперь нам очень хочется на этом дереве выполнить некоторые вполне жизненные операции: найти сумму всех значений, или найти высоту, ну и в список растянуть было бы нелишним. Наивные рекурсивные решения этих задач столь же неудобоваримы, как и подобные им на списках.
К примеру, простейший способ разложения в список
> `let rec to\_list tree =
>
> match tree with
>
> |Node(v, ltree, rtree) -> (to\_list ltree)@[v]@(to\_list rtree)
>
> |Leaf -> []`
Этот метод мало того, что опять может привести к переполнению стека, так еще вдобавок использует функцию конкатенации списков, которая, скажем по секрету, очень неэффективно их обрабатывает. Так у нас дела не пойдут.
Но ведь не зря мы, в конце концов, так долго мучались, пока не написали fold\_right с применением функции континуации. Это было неспроста. Данный способ очень хорошо применим и для дерева.
Примечание: А сейчас, если у вас в домашней аптечке случайно завалялись препараты, расширяющие сознание, не сочтите за труд, сходите, выпейте таблеточку. Может пригодится.
В чем заключается отличие дерева от списка? Появилась просто-напросто вторая ветвь для каждого узла. То есть, на каждом шаге нашей свертки у нас будет образовываться не один, а два хвоста, а значит и функция свертки должна иметь вид: 'b -> 'a -> 'a -> 'a, где второй и третий аргумент ее обозначают аккумуляторы для левого и правого хвостов. Такой будут функции свертки для суммирования и поиска высоты:
> `fun x left right -> x + left + right
>
> fun \_ left right -> 1 + max left right`
Попробуем. Поскольку у нас на каждом этапе есть две возможности продолжения просмотра, то и вложенный цикл должен быть двойной. Как это сделать применительно к нашей функции континуации? — очень просто:
> `let FoldTree treeF leafV tree =
>
> let rec loop tree cont =
>
> match tree with
>
> |Node (val, left, right) -> loop left (fun lacc ->
>
> loop right (fun racc ->
>
> cont (treeF val lacc racc)))
>
> |Leaf -> cont leafV
>
> loop tree (fun x -> x)`
Как видим, здесь по сути на каждом шаге есть две функции континуации — одна накапливает значение для левого поддерева, вторая, внутренняя — для правого, после чего все это фолдится с помощью функции treeF. При попадании в лист мы применяем накопленную нами для текущего поддерева функцию к начальному значению, соответсвующему листьям — leafV.
Можно заметить, что пока мы будем перебирать значения левого поддерева, в функции континуации будут накапливаться рекурсивные вызовы к loop для правых поддеревьев, однако именно что в функции, а не в стеке, так что и с точки зрения «хвостовости» здесь все хорошо.
Вот как это выглядит для нашего дерева:
4
2 6
1 3 5 7
> `4: x -> x
>
> 2: x -> loop (6,5,7) (y -> treeF 4 x y)
>
> 1: x -> loop (3) (y -> loop (6,5,7) (z -> treeF 4 (treeF 2 x y) z))
>
> Ll: x -> loop Lr (y -> loop (3) (z -> loop (6,5,7) (q -> treeF 4 (treeF 2 (treeF 1 x y) z) q)))`
Здесь Ll — это левый лист, Lr — правый. Попав в лист мы должны применить функцию к начальному значению, а значит — и выполнить вдобавок самый внешний loop.
> `Lr: y -> loop (3) (z -> loop (6,5,7) (q -> treeF 4 (treeF 2 (treeF 1 leafV y) z) q))`
Проделываем ту же операцию для правого листа и получаем:
> `3: z -> loop (6,5,7) (q -> treeF 4 (treeF 2 (treeF 1 leafV leafV) z) q)`
Заметьте, что сейчас (treeF 1 leafV leafV) — это уже не функция, а значение, т.е. для крайнего левого дерева (того, которое просто 1) фолд уже произведен. Дальше все происходит таким же образом, думаю, читатель может представить, как.
Теперь желаемые нами операции выглядят следующим образом:
> `let SumTree = FoldTree (fun x left right -> x + left + right) 0
>
> let HeightTree = FoldTree (fun \_ left right -> 1 + max left right) 0
>
> let Tree2List = FoldTree (fun x left right -> left @ [x] @ right)`
На самом деле, проблема конкатенации в последней функции у нас сохранилась, но, хотя она и разрешима, мы не будем об этом решении говорить сейчас, дабы еще более не углубляться в не столь уж доброжелательные дебри ФП.
### Свертка на обобщенных размеченных объединениях
Напоследок рассмотрим катаморфизм на другом любопытном типе размеченных объединений, задающем, условно говоря, некоторый язык программирования:
> `type Op =
>
> |Plus
>
> |Minus
>
> override this.ToString() =
>
> match this with
>
> |Plus -> "+"
>
> |Minus -> "-"
>
>
>
> type Expr =
>
> |Literal of int
>
> |BinaryOp of Expr\*Op\*Expr
>
> |IfThenElse of Expr\*Expr\*Expr`
В данном случае это очень простой язык вычисления математических выражений, снабженный дополнительно условным оператором (для простоты будем считать, что любое ненулевое значение выражения в условии соответствует true). Пример такого выражения:
> `let expr = IfThenElse (Literal 1, BinaryOp (Literal 12, Minus, Literal 10), Literal 32)`
Что бы нам хотелось сделать с этим выражением? Ну например, вывести его в удобоваримой форме:
> `if 1 then (12 - 10) else 32 endif`
а еще — собственно посчитать результат, здесь это будет 2. Что нам поможет одновременно решить две эти вроде бы не похожие задачи? — правильно, катаморфизм. Думаю, после примера на деревьях, написать свертку для этого типа будет совсем не сложно. Нам нужно иметь кроме самого выражения еще три функции-аргумента — по одной на каждый тип выражения. Напишем для нее функцию свертки:
> `let FoldExpr funL funB funIf expr =
>
> let rec loop expr cont =
>
> match expr with
>
> |Literal x -> cont (funL x)
>
> |BinaryOp (left,op,right) -> loop left (fun lacc ->
>
> loop right (fun racc ->
>
> cont (funB lacc op racc)))
>
> |IfThenElse (condExp,thenExp,elseExp) -> loop condExp (fun cacc ->
>
> loop thenExp (fun tacc ->
>
> loop elseExp (fun eacc ->
>
> cont (funIf cacc tacc eacc))))
>
> loop e (fun x -> x)`
Посмотрите, ровным счетом ничего нового по сравнению с деревьями, разве что при рассмотрении IfThenElse у нас аж три вложенных цикла, но это и неудивительно, ведь нам надо развернуть как условие, так и две возможные ветви продолжения. Функции funL, funB, funIf служат для обработки литералов, бинарных операций и условных операторов соотвественно.
Теперь мы можем спокойно написать обе нам необходимые функции. Так мы выведем в строку выражение (кстати заметьте, что мы не зря переопределили в типе Op метод ToString():
> `let Printer =
>
> FoldExpr (fun x -> sprintf "%d" x) //обработка литералов
>
> (fun l op r -> sprintf "(%s %s %s)" l (op.ToString()) r) //обработка бинарных операторов
>
> (fun c t e -> sprintf "if %s then %s else %s endif" c t e) //обработка условных операторов`
Ну а теперь собственно «компилятор»:
> `let Eval =
>
> FoldExpr (fun x -> x)
>
> (fun l op r -> match op with |Plus -> l + r |Minus -> l - r)
>
> (fun c t e -> if c > 0 then t else e)`
Как видите, функции обработки очень просты и интуитивно понятны.
Конечно, сам тип Expr в данном примере не очень сложный, однако на самом деле с помощью размеченных объединений можно реализовать довольно замысловатые «ЯП», ну и далеко не только «ЯП», естественно. А уж свертка на таком размеченном объединеннии с большой вероятностью будет незаменимым орудием на все случаи жизни. Такой вот катаморфизм.
P.S. Не знаю, стоит ли переносить в какой-то коллективный блог, все-таки тема специфическая.
UPD: Долго выбирал, куда перенести, решил в .Net, как наиболее нейтральный. | https://habr.com/ru/post/57503/ | null | ru | null |
# Про утечку памяти в одном серверном приложении
Прочитав данную заметку вы узнаете, через что пришлось пройти после неожиданно возникшей утечки памяти серверного приложения в ОС FreeBSD. Какие современные средства обнаружения подобных проблем существуют в данной среде и почему самое мощное из них может оказаться совершенно бесполезным ~~в кривых руках~~.
В один прекрасный полдень четверга, на 5 из 50 серверов Zabbix прислал уведомления о заканчивающемся месте на swap-разделе. График на КПДВ (свободная память) наглядно демонстрирует масштаб проблемы (холмики справа — высвобождение памяти за счет вытеснения в swap). Благо, впереди пятница, и можно спокойно все исправить за выходные. В тот момент еще никто не предполагал, что на поиски и устранение причины уйдет больше 6 суток.
**О серверах.** Типичные сервера поколения десятых-одиннадцатых годов с 8Гб памяти (практически полностью идентичны и даже одного бренда). Сервера поделены на группы для обслуживания разных наборов пользовательских аккаунтов.
**О приложении.** Ad-server, HTTP (libh2o) с логикой на C\С++, кучей сторонних библиотек и велосипедов вроде стандартных C++ контейнеров в shared memory и т.п. Принимает входящий запрос, перенаправляет на несколько вышестоящих серверов, проводит аукцион по ответам и возвращает ответ клиенту. Все крутится на FreeBSD 11.0\11.1.
Кто виноват?
------------
Последние изменения в кодовой базе были около десяти дней назад, все эти дни с памятью не происходило ничего примечательного. Беглый анализ давал такой список наиболее вероятных причин:
* изменились качественные либо количественные характеристики входящих\исходящих запросов, что привело к ошибкам при выделении\освобождении памяти;
* велосипеды с контейнерами в shared memory. Они всегда вызывают подозрение, если что-то идет не так;
* никакой утечки нет, просто стало больше данных и они теперь перестали влазить;
* результат обновления ядра ОС \ библиотек. Но никаких авто-обновлений по умолчанию нет, это не какая-нибудь Windows которая, прости Господи, может [накатить обновлений](https://www.raymond.cc/blog/disable-and-stop-restart-or-reboot-after-installing-windows-update/), когда вздумается и, вдобавок, перезагрузить машину. *Пару месяцев назад так обвалилось много сервисов на соседнем проекте.*
* кто-то проводит целенаправленную сетевую атаку, вызывающую переполнение;
* Meltdown\Spectre. Да! Ну конечно же. Не помню, чтобы мы накатывали какие-либо обновления, боясь замедления, но такой пункт сегодня просто обязан иметь место быть в любой нештатной ситуации;
Но характеристики запросов\ответов не изменились (по крайней мере, по всем собираемым метрикам). Данных больше не стало, с сетью порядок, куча свободных ресурсов, сервер отвечает быстро… Неужели изменилась внешняя среда?
Что делать?
-----------
Пару лет назад всплывало нечто подобное, но успели забыться практически все инструменты, которые помогли решить проблему тогда. Хотелось просто поскорее избавиться от всего за пару часов, поэтому первая наивная попытка — найти ответ на StackOverflow… В основном народ рекомендует Valgrind и какие-то неизвестные поделки (видимо, сами же авторы), либо плагины к VisualStudio (неактуально). Поделки падали практически все, даже не начав толком работать (memleax, ElectricFence и т.п.), останавливаться на них подробно не будем.
Попутно вспоминаем все недавно выпущенные фичи, благо, изменений за последний месяц было немного, из основных — прикручивание баз GeoIP, и так, по-мелочи…
Пытаемся поочередно отключать клиентов и вышестоящие сервера (данный метод был опробован одним из первых, но почему-то не дал никакого результата, утечка проявлялась во всех комбинациях с разной степенью интенсивности, наблюдалась лишь линейная зависимость от входящих запросов).
Тут же были предприняты попытки отката на старые версии, вплоть до ревизии двухмесячной давности. Память продолжала утекать и там. Откат на еще более ранние версии не представлялся возможным по причине несовместимости с остальными компонентами.
Главный вопрос — почему именно эти 5 серверов? Все машины практически идентичны (кроме разницы в версии ОС 11\11.1). Проблема возникает только на определенной группе аккаунтов. На остальных нет и намека на такое поведение, значит, должно быть, точно зависимость от входящих запросов…
**Лирическое отступление**Неоднократно сталкиваясь с утечками в разных проектах, довелось наслушаться жутких историй про самый популярный и действенный способ лечения — периодически перезагружать ущербное приложение. Да да, оказывается, такое работает годами в весьма уважаемых компаниях. Мне это всегда казалось полной дичью, и что я никогда в жизни не опущусь до этого, какого бы масштаба не возникла проблема. Однако, уже на вторые сутки пришлось прописать позорный рестарт в cron-е, т.к. перезагружать приложение раз в несколько часов оказалось довольно утомительным занятием (особенно по ночам).
Зачем-то захотелось сделать все красиво, а именно найти место утечки универсальными средствами. Наверно, это была одна из основных ошибок, допущенных на ранней стадии.
Итак, какие же универсальные средства решения описанной проблемы существуют сегодня? В основе своей, это сторонние библиотеки, оборачивающие вызовы к malloc\free и следящие за всеми операциями с памятью.
### valgrind
Прекрасное средство обнаружения проблем. Действительно, ловит практически все виды (двойное освобождение, выход за границы, утечки и т.п.). Тут бы вся эта история и закончилась, не начавшись. Но с valgrind есть одна проблема — практически полная бесполезность для высоко-нагруженных приложений. Выглядит это примерно так: программа стартует в 20-50 раз дольше обычного, потом так же работает, при этом большинство запросов, естественно, не успевают отработать и заканчиваются по таймаутам. Ядра CPU загружаются на 100%, при этом никаких полезных действий приложение не производит, тратя все ресурсы на виртуальную машину valgrind-а. В логах вы обнаружите жалкие доли процента от всех запросов, которые проходят в штатном режиме. После нажатия Ctrl+C, если повезет, через несколько минут появится лог, либо же все упадет (у меня было чаще второе, либо практически пустой лог). В общем, не взлетело.
### tcmalloc
Библиотека доступна из порта google-perftools. По [заявлением разработчиков](https://gperftools.github.io/gperftools/heapprofile.html):
> This is the heap profiler we use at Google.
Как и большинство подобных средств, подключается либо с помощью переменной окружения (LD\_PRELOAD) либо вкомпиливанием самой библиотеки (-ltcmalloc). Ни тот ни другой способ не сработал. В процессе обнаружился еще один способ — вызов статического метода HeapLeakChecker::NoGlobalLeaks() из кода. Но он почему-то не экспортировался ни в одной из версий библиотеки. В последствии [выяснится](https://github.com/gperftools/gperftools/blob/master/INSTALL):
> [on FreeBSD] libtcmalloc.so successfully builds, and the «advanced» tcmalloc functionality all works except for the leak-checker, which has Linux-specific code.
:( Поехали дальше.
### libumem
Доступна из порта umem. Шикарный способ обнаружения проблем с памятью. Особенно в [сочетании с MDB](https://blogs.oracle.com/jwadams/debugging-with-libumem-and-mdb). К сожалению, доступно все это только в ОС Solaris, а на FreeBSD MDB было бы [неплохо портировать](https://wiki.freebsd.org/Debugging). Запустить с ним приложение не удалось. При старте, до вызова main, происходит вызов calloc из libthr.so, который уже перехвачен libumem-ом. В свою очередь, libumem пытается инициализировать работу с потоками у себя в коде. Рекурсия-с. В общем стек еще задолго до вызова main выглядит примерно так:
Типичная проблема яйца и курицы, которую непонятно как обойти. Идею выпилить много-поточность (благо, у нас она используется только где-то в boost-зависимостях и в обертке над getaddrinfo) было решено отложить на самый крайний случай. Ну что ж, отпишем разработчикам (если остались еще [живые](https://github.com/gburd/libumem/issues/10)) в открытый кем-то [похожий тикет](https://github.com/gburd/libumem/issues/9) и поедем дальше.
### dmalloc
Доступна из одноименного порта. Обладает неплохой документацией. Стек при запуске удивительно напоминает предыдущий случай:
```
(gdb) bt
#0 0x0000000802c8783e in dmalloc_malloc ()
from /usr/local/lib/libdmallocthcxx.so.1
#1 0x0000000802c88623 in calloc () from /usr/local/lib/libdmallocthcxx.so.1
#2 0x00000008038a8594 in ?? () from /lib/libthr.so.3
#3 0x00000008038a98d4 in ?? () from /lib/libthr.so.3
#4 0x00000008038a58fa in pthread_mutex_lock () from /lib/libthr.so.3
#5 0x0000000802c87641 in ?? () from /usr/local/lib/libdmallocthcxx.so.1
#6 0x0000000802c87bb3 in ?? () from /usr/local/lib/libdmallocthcxx.so.1
#7 0x0000000802c8787a in dmalloc_malloc ()
from /usr/local/lib/libdmallocthcxx.so.1
#8 0x0000000802c88623 in calloc () from /usr/local/lib/libdmallocthcxx.so.1
#9 0x00000008038a8594 in ?? () from /lib/libthr.so.3
#10 0x00000008038a98d4 in ?? () from /lib/libthr.so.3
#11 0x00000008038a58fa in pthread_mutex_lock () from /lib/libthr.so.3
#12 0x0000000802c87641 in ?? () from /usr/local/lib/libdmallocthcxx.so.1
#13 0x0000000802c87bb3 in ?? () from /usr/local/lib/libdmallocthcxx.so.1
#14 0x0000000802c8787a in dmalloc_malloc ()
```
Но здесь автор в курсе [проблемы](http://dmalloc.com/docs/latest/online/dmalloc_18.html) и предусмотрел оригинальный способ обхода: при старте задавать параметром кол-во вызовов malloc-ов, которые нужно игнорировать (дабы избежать рекурсии):
> You know its too low if your program immediately core dumps and too high if the dmalloc library says its gone recursive although with low values, you might get either problem.
Мило. Подбирая заветное число, пометавшись между core-dump-ами и рекурсией всю эту затею было решено предать анафеме.
Тем временем, память на серверах стала заканчиваться еще быстрее. Если раньше было 5-6 часов до полного выедания, то сейчас память уходила за час полностью. Пришлось подкручивать cron :( К тому же, набор серверов, подверженных проблеме, стал расти. Правда, на новом наборе серверов память заканчивалась в течении суток. При этом, на большинстве машин до сих пор не было вообще никаких видимых проблем с памятью.
Параллельно, у инженеров в ДЦ запросили дополнительной памяти на один из серверов, чтобы проверить теорию о том, что «это данных стало больше» (последняя, отчаянная попытка убедиться, что это не утечка). ДЦ весьма оперативно предоставил дополнительные 8Гб, которые были благополучно выедены за ночь. Больше в наличии утечки никто не сомневался.
### dtrace
В процессе беспощадного гуглежа все больше стали попадаться загадочные скрипты на не менее загадочном языке D. Оказалось, что все они предназначены для невероятно крутой системной утилиты — dtrace, эдакий **IDDQD** в анализе и отладке практически любого кода. Много про него слышал, но не доводилось использовать в бою.
Т.е. вы можете попросить сохранять все обращения к определенным функциям libc, например, malloc\free, поставив на них датчики (probes), попутно собирая общую статистику, и даже строить [диаграммы распределения](http://dtrace.org/guide/chp-aggs.html#chp-aggs-2), и все это в несколько строк кода! Например, вот так:
```
sudo dtrace -n 'pid$target::malloc:entry { @ = quantize(arg0); }' -p 15034
```
— вы можете узнать распределение выделяемых блоков в любом запущенном процессе (в примере — pid=15034). Вот как выглядит распределение в нашем приложении за несколько секунд мониторинга:
```
value ------------- Distribution ------------- count
2 | 0
4 | 1407
8 | 455
16 |@@ 35592
32 |@@@@@@@@@@@@@@@@ 239205
64 |@@@@@@@ 112358
128 |@@@@ 55813
256 |@@@@@@ 91368
512 |@ 17204
1024 |@ 19751
2048 |@@ 33310
4096 | 2082
8192 | 554
16384 | 15
32768 | 0
65536 | 3960
131072 | 0
```
Круто, правда? Все это на лету, без перекомпиляции! Мы, должно быть, где-то очень близко к разгадке всех тайн.
Также вы можете собирать любую статистику по любой функции, экспортируемой из вашего приложения! Правда, с опциями компиляции -O1 и выше большинство интересных функций может попросту пропасть из экспорта, компилятор «заинлайнит» их в код и вам не на чем будет ставить «пробы».
Брендан Грег (Brendan Gregg), апологет dtrace, стал учителем и наставником на все эти безумные дни:
> In some cases, this [dtrace] isn’t a better tool – it’s the only tool.
— заявлял он.
Вот [здесь](http://www.brendangregg.com/Solaris/memoryflamegraphs.html) нечто похожее на то, что нам нужно, однако Брендан оставил комментарий:
> FreeBSD: DTrace can be used as with Solaris. I'll share examples when I get a chance.
До сегодняшнего дня случай ему, к сожалению, так и не выпал. Но по-сути там все то же самое, что и в Solaris, только вместо sbrk вызывается mmap\munmap.
Пришлось вникать в премудрости языка D. Многие области, например, приведение типов, особенно агрегированных значений, так и не удалось победить.
Вначале я решил испробовать немного переделанный скрипт [отсюда](https://blogs.oracle.com/openomics/investigating-memory-leaks-with-dtrace):
**Код**
```
#!/usr/sbin/dtrace -s
/*#pragma D option quiet*/
/*#pragma D option cleanrate=5000hz*/
pid$1::mmap:entry
{
self->addr = arg0;
self->size = arg1;
}
pid$1::mmap:return
/self->size/
{
addresses_mmap[arg1] = 1;
printf("<__%i,%Y,mmap(0x%lx,%d)->0x%lx\n", i++, walltimestamp, self->addr, self->size, arg1);
/*ustack(2);*/
printf("__>\n\n");
@mem_mmap[arg1] = sum(1);
self->size=0;
}
pid$1::munmap:entry
/addresses_mmap[arg0]/
{
@mem_mmap[arg0] = sum(-1);
printf("<__%i,%Y,munmap(0x%lx,%d)__>\n", i++, walltimestamp, arg0, arg1);
}
pid$1::malloc:entry
{
self->size = arg0;
}
pid$1::malloc:return
/self->size > 0/
{
addresses_malloc[arg1] = 1;
/*
printf("<__%i,%Y,malloc(%d)->0x%lx\n", i++, walltimestamp, self->size, arg1);
ustack(2);
printf("__>\n\n");
*/
@mem_malloc[arg1] = sum(1);
self->size=0;
}
pid$1::free:entry
/addresses_malloc[arg0]/
{
@mem_malloc[arg0] = sum(-1);
/*printf("<__%i,%Y,free(0x%lx)__>\n", i++, walltimestamp, arg0);*/
}
END
{
printf("== REPORT ==\n\n");
printf("== MMAP ==\n\n");
printa("0x%x => %@u\n",@mem_mmap);
printf("== MALLOC ==\n\n");
printa("0x%x => %@u\n",@mem_malloc);
}
```
Выглядит достаточно просто: сохраняем все вызовы malloc\free, а также места их вызовов. На malloc — увеличиваем счетчик у адреса, на free — уменьшаем. Затем изучаем полученный лог и находим утечку (адреса с счетчиками > 0). Вся проблема заключается в том, что при ~150К malloc-ов в секунду, функция ustack() (сохраняющая стек, т.е. место вызова) начинает буквально хоронить весь процесс своим весом (похоже на случай с valgrind-ом). Я попытался убрать стек из вывода и просто собирать адреса и счетчики к ним, в итоге почему-то многие счетчики были глубоко в минусах (неужели испорченная куча и двойные освобождения?), а адресов с положительными значениями счетчиков практически не было… При этом dtrace часто плевался ошибками вида:
```
dtrace: 3507 dynamic variable drops with non-empty dirty list
dtrace: 2133 dynamic variable drops
dtrace: 120 dynamic variable drops with non-empty dirty list
dtrace: 993 dynamic variable drops
dtrace: 176 dynamic variable drops with non-empty dirty list
dtrace: 1617 dynamic variable drops
dtrace: 539 dynamic variable drops with non-empty dirty list
dtrace: 10252 dynamic variable drops
dtrace: 3830 dynamic variable drops with non-empty dirty list
dtrace: 17048 dynamic variable drops
dtrace: 39483 dynamic variable drops
dtrace: 1121 dynamic variable drops with non-empty dirty list
dtrace: 35067 dynamic variable drops
dtrace: 32592 dynamic variable drops
dtrace: 10081 dynamic variable drops with non-empty dirty list
```
Также часто мелькали сообщения о битых адресах в стеке.
Это наталкивало на мысль, что он просто не успевает правильно обрабатывать все события, поэтому счетчики уходят в минуса… Либо же это проблемы с кучей\стеком. Кроме того, вызовов free накручивалось в 1.5 раза больше, чем malloc-ов (значит, все-таки, двойные освобождения?)
Решил попросить помощи у участников [почтовой рассылки dtrace](http://dtrace.org/blogs/mailing-list/).
Судя по архиву, некогда оживленная рассылка переживала не лучшие времена. К большому изумлению, ответ последовал в первые же минуты, хотя отреагировали всего два участника. Один посоветовал использовать аргумент, задающий кол-во кадров стека для сохранения: ustack(nframes). Это не помогло, даже ustack(1) убивал весь процесс. Еще посоветовали использовать libumem (полагая, вероятно, что я приполз с Solaris-а).
Дальше пошли бессистемные попытки, как то: сбор статистики по размерам, выделяемым malloc-ами, и попытка отфильтровать только определенные размеры, ну чтоб хоть как-то уменьшить частоту срабатывания датчиков. Безрезультатно, такое чувство, что ustack() задуман для самых минимальных нагрузок, скажем, до 100 вызовов в секунду. Или же нужно уметь его правильно готовить, сохраняя результат в какой-то бесконечный внутренний буфер, без раскручивания стека на каждом запросе. Но до этого, к сожалению, так и не дошло.
Попытался подойти к задаче с другой стороны — начать подсчет вызовов конструкторов и деструкторов всех объектов в коде, тогда мне фактически не нужно сохранить стек. Результатов это тоже не дало. Никаких расхождений выявлено не было, хотя, конечно же, я поленился «опробировать» все объекты в коде, а ограничился только лишь вызывающими подозрения.
**О demangle**Для установки датчиков в вызовы своих функций, требуется произвести т.н. demangle имен. Тут, как на зло, FreeBSD подкинула очередной [сюрприз](https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=223333). Простой:
```
echo _ZZN7simlib318SIMLIB_create_nameEPKczE1s | /usr/bin/c++filt
```
обрушивает утилиту. Баг до сих пор не исправлен в 11.1. Пришлось запускать demangle-инг на одном из серверов с версией 11.0.
Все стало походить на борьбу с ветряными мельницами.
Вообще, вывод dtrace уверял, что это не утечка, а испорченная куча \ двойное освобождение. Если это правда, то все очень плохо, без спец. библиотеки тут не обойтись.
Но все это оказалось полной ерундой и лишь увело от цели в сторону на несколько дней.
### jemalloc
Примечательно, что в самой FreeBSD используется очень крутой и продвинутый менеджер памяти, еще аж с лохматой 7-ой версии. Вернее, я просто совершенно забыл про это… По количеству [настроек и опций](http://jemalloc.net/jemalloc.3.html) все остальные библиотеки-обертки даже рядом не валялись. Повозившись с доками, удалось запустить приложение с опцией:
```
setenv MALLOC_CONF utrace:true
```
После чего, следуя инструкции [отсюда](https://keramida.wordpress.com/2008/10/15/extracting-useful-info-from-freebsd-malloc-tracing/) собрать (ktrace) и сгенерить (kdump) лог всех операций с памятью. В их числе оказались и realloc-и, которые в скрипте из статьи не работали, а [вторая версия](http://people.freebsd.org/~keramida/alloctrace-2.py.txt) скрипта из комментариев (корректно обрабатывающая realloc-и) вела на несуществующую страницу (и даже «Wayback Machine» ничего не смог найти). Пришлось дописать поддержку realloc-ов, но по сути это дало лишь кучу указателей, где, возможно, происходит утечка, без какого-либо намека на то, где и кем они были выделены.
> By skimming through nearby trace output, we may be able to understand a bit more about the location of the leak in the source too :-)
— шутил автор статьи.
Чтобы заработали другие опции jemalloc-а (как-то: обнаружение двойных освобождений, выход за пределы массивов, расширенная статистика по обращению к памяти и т.п.), требовалась либо перекомпилляция всего ядра с доп. опциями, либо CURRENT сборка ОС (то, что удалось понять из man-а). Однако, шли шестые сутки поиска и дальнейшее копание в jemalloc было решено приостановить, хотя тема весьма интересна и я надеюсь к ней еще вернуться (надеюсь, не в похожих обстоятельствах).
### Что в итоге помогло найти утечку
Поочередное отключение каждого модуля и подсистемы приложения и их комбинаций. Пойди я этим путем в самом начале — и проблема была бы решена в течении суток, но ведь сколько всего нового и интересного пришлось бы пропустить!
В каждой грустной истории должны найтись и положительные стороны.
### Нотки позитива
* в процессе поиска иголки было исправлено некоторое количетсво мелких (и не очень) багов, в основном, выделения памяти, там где можно обойтись без оных;
* убран ARC ZFS (зачем он нужен на HTTP сервере, который ничего не пишет на диск, только память жрет, причем [весьма существенно](https://forums.freebsd.org/threads/freebsd-11-1-zfs-using-to-much-wired-memory.64702/));
* проштудированы статьи на тему виртуальных деструкторов и прочих хитрых штук из мира C++;
* написан с десяток скриптов на D, просмотрено несчетное кол-во туториалов (по dtrace);
* погружение в разные реализации malloc\free, знакомство с понятиями arenas и slabs;
* изучены все изветсные баги, связанные с памятью во всех сторонних либах, использованных в проекте;
* узнал историю и драму, развернувшаяся вокруг ОС Solaris в последние годы ее существования;
* прокачаны \ восстановлены навыки работы с GDB.
### Безумства, в которые не стоит впадать даже в моменты полного отчаяния
* послать все подальше и переехать на Linux. Думаю, эта мысль не раз посетила любого ярого приверженца FreeBSD, вызвана будь-то отсутствием полноценного Google Chrome, Skype, либо [крутых самописных системных утилит](https://habrahabr.ru/company/odnoklassniki/blog/266005/). Не поддавайтесь панике, рано или поздно все проблемы решаться и вы вновь вернетесь к любимой ОС;
* попытки пролезть hex-view-ером в раздел со свопом (зачем? посмотреть что вытесняется из памяти и попробовать догадаться где утечка, хаха);
* выпилить всю многопоточность из приложения, чтобы большинство средств выше заработало;
* нанять фрилансера-профессионала, который все быстро починит.
Выводы
------
* Тщательное протоколирование всех изменений в релизах. Практически во всех случаях, утечка будет связана с одним из самых последних коммитов. Если вы крайне невезучи — то с коммитом за последние пару-тройку месяцев. Пробуйте откатывать все изменения, по одному и в комбинациях, перепроверяйте все по несколько раз. Малейшая оплошность — и вас унесет на несколько дней\недель не тем течением;
* Если вам дорого время — не пытайтесь использовать универсальные средства обнаружения утечек, особенно в high-load проектах;
* Не хватило виртуозности владения dtrace и можно было бы ухитриться обрабатывать только небольшой процент всех запросов. Но тут в post-mortem обработке нужно правильно отфильтровать ложные срабатывания и т.п. На освоение такого подхода, к сожалению, не хватило сил и времени.
Считаю финал этой истории крупным везением. Повезло, что утечка стабильно воспроизводилась на всем протяжении поиска. Что была возможность сколько угодно раз перезапускать заново собранное приложение на одном из релизных серверов без особого вреда пользователям. Что от релиза бага до возникновения проблемы прошло всего несколько дней, а не пол-года, когда шансы найти проблему стали бы исчезающе малы…
Вопросы и ответы
----------------
**Так в чем же, все-таки, была причина утечки?**
Как упоминалось выше, сервер проводит аукцион среди ответов вышестоящих серверов. Если ответов приходит больше максимального значения, то они «обрезаются» (берется top N results).
Топ хранится в std::list, где элементы — это указатели на объекты-биды. Один из коммитов привнес такой чудесный код для обрезания топа: list.resize(max\_results). Как вы уже догадались, list.resize не вызывает delete на элементы-указатели. Нужно пройтись и ручками освободить память всех лишних указателей до вызова resize.
**Почему такое продолжительное время после релиза версии с багом утечка не давала о себе знать?**
Ответы серверов всегда влазили в top N results и ничего не обрезалось. Просто у определенных пользователей в какой-то момент ответов стало больше и они перестали влазить в топ.
**Почему откат на предыдущие версии не помог сразу выявить проблему?**
Здесь сыграл человеческий фактор. Дело в том, что на старте приложение начинает весьма активно отъедать память, замедляя интенсивность в течении несколько часов. Вероятно, в угаре поиска, это было воспринято как продолжающаяся утечка, и проблемное место выявить не удалось.
**Почему проблема всплыла лишь на определенной части серверов?**
Из-за обслуживаемых на данной группе серверов аккаунтов. У каких-то из них в аукционе стало возвращаться огромное количество бидов, не влазящих в топ. У остальных аккаунтов, обслуживаемых другими серверами, в топ аукциона попадали все ответы, либо редко превышали макс. размер списка.
Расскажите свои истории борьбы с утечками, особенно на ЯВУ. Действительно ли способ «рестартуем приложение каждые N минут» настолько популярен в качестве универсального решения? Так ли же все печально в среде ОС Linux или «tcmalloc и co.» действительно сходу помогают «найти и обезвредить»?
**UPD1**: Пока готовил этот текст, случайно наткнулся на [возможность выявления утечек средствами clang](https://clang.llvm.org/docs/LeakSanitizer.html), интересно было бы попробовать…
Спасибо всем, кто дочитал до конца! | https://habr.com/ru/post/354370/ | null | ru | null |
# Настройка DKIM/SPF/DMARC записей или защищаемся от спуфинга
Приветствую, Хабр! В этой статье будет инструкция по настройке DKIM/SPF/DMARC записей. А побудило меня написать эту статью полное отсутствие документации на русском языке. Все статьи на эту тему, которые были мной найдены, были крайне не информативны.
### 1. DKIM
DKIM (DomainKeys Identified Mail) — это метод e-mail аутентификации, основанный на проверке подлинности цифровой подписи. Публичный ключ хранится TXT записи домена.
#### Зачем же он нужен?
DKIM необходим для того, чтобы почтовые сервисы могли проверять, является ли отправитель достоверным или нет. Т.е. защищает получателя письма от различных мошеннических писем (которые отправлены с подменой адреса отправителя).
#### Настройка DKIM подписи и DNS записей
Для это нам необходимо создать пару ключей:
```
openssl genrsa -out private.pem 1024 //генерируем секретный ключ длинной 1024
```
```
openssl rsa -pubout -in private.pem -out public.pem //получаем публичный ключ из секретного
```
Или можно воспользоваться онлайн-сервисом, чего я крайне не советую.
Далее необходимо указать путь с секретному ключу в файле конфигурации (для этого лучше почитать документацию) почтового сервера и публичный ключ в DNS.
Примером записей является
`mail._domainkey.your.tld TXT "v=DKIM1; k=rsa; t=s; p=<публичный ключ>"`
где
`mail` — селектор. Можно указать несколько записей с разными селекторами, где в каждой записи будет свой ключ. Применяется тогда, когда задействовано несколько серверов. (на каждый сервер свой ключ)
`v` — версия DKIM, всегда принимает значение `v=DKIM1`. (обязательный аргумент)
`k` — тип ключа, всегда `k=rsa`. (по крайней мере, на текущий момент)
`p` — публичный ключ, кодированный в base64. (обязательный аргумент)
`t` — Флаги:
`t=y` — режим тестирования. Такие отличают отличаются от неподписанных и нужны лишь для отслеживания результатов.
`t=s` — означает, что запись будет использована только для домена, к которому относится запись, не рекомендуется, если используются субдомены.
возможные:
`h` — предпочитаемый hash-алгоритм, может принимать значения h=sha1 и h=sha256
`s` — Тип сервиса, использующего DKIM. Принимает значения `s=email` (электронная почта) и `s=*` (все сервисы) По-умолчанию "\*".
`;` — разделитель.
Так же стоит прописать ADSP запись, которая позволяет понять, обязательно должно быть письмо подписано или нет.
`_adsp._domainkey.example.com. TXT "dkim=all"`
Значений может быть три:
`all` — Все письма должны быть подписаны
`discardable` — Не принимать письма без подписи
`unknown` — Неизвестно (что, по сути, аналогично отсутствию записи)
### 2. SPF
SPF (Sender Policy Framework) — расширение для протокола отправки электронной почты через SMTP. SPF определен в RFC 7208 ([Wiki](https://ru.wikipedia.org/wiki/Sender_Policy_Framework)). Если простым языком, то SPF — механизм для проверки подлинности сообщением, путем проверки сервера отправителя. Как по мне, данная технология полезна в связке в другими (DKIM и DMARC)
#### Настройка SPF записей
Примером обычной SPF записи является `your.tld. TXT "v=spf1 a mx ~all"`
Здесь:
`v=spf1` является версией, всегда spf1
`a` — разрешает отправляет письма с адреса, который указан в A и\или AAAA записи домена отправителя
`mx` — разрешает отправлять письма c адреса, который указан в mx записи домена
(для a и mx можно указать и другой домен, например, при значении `a:example.com`, будет разрешена а запись не домена отправителя, а *example.com*)
Так же можно добавлять и отдельные ip адреса, используя `ip4:` и `ip6:`. Например, `ip4:1.1.1.1` `ip6: 2001:0DB8:AA10:0001:0000:0000:0000:00FB`. Еще есть `include:` (`include:spf.example.com`), позволяющий дополнительно подключать spf записи другого домена. Это все можно комбинировать через пробел. Если же нужно просто использовать запись с другого домена, не дополняя её, то лучше всего использовать `redirect:` (`redirect:spf.example.com`)
`-all` — означает то, что будет происходить с письмами, которые не соответствуют политике: "-" — отклонять, "+" — пропускать, "~" — дополнительные проверки, "?" — нейтрально.
### 3.DMARC
Domain-based Message Authentication, Reporting and Conformance (идентификация сообщений, создание отчётов и определение соответствия по доменному имени) или DMARC — это техническая спецификация, созданная группой организаций, предназначенная для снижения количества спамовых и фишинговых электронных писем, основанная на идентификации почтовых доменов отправителя на основании правил и признаков, заданных на почтовом сервере получателя ([Wiki](https://ru.wikipedia.org/wiki/DMARC)). То есть почтовый сервер сам решает, хорошее сообщение или плохое (допустим, исходя из политик выше) и действует согласно DMARC записи.
#### Настройка DMARC записей
Типичная запись выглядит так: `_dmarc.your.tld TXT "v=DMARC1; p=none; rua=mailto:postmaster@your.tld"`
В ней не предпринимаются никакие действия, кроме подготовки и отправки отчета.
Теперь подробнее о тегах:
`v` — версия, принимает значение `v=DMARC1` (обязательный параметр)
`p` — правило для домена. (Обязательный параметр) Может принимать значения `none`, `quarantine` и `reject`, где
`p=none` не делает ничего, кроме подготовки отчетов
`p=quarantine` добавляет письмо в СПАМ
`p=reject` отклоняет письмо
Тэг `sp` отвечает за субдомены и принимает такие же значения, как и `p`
`aspf` и `adkim` позволяют проверять соответствиям записям и могут принимать значения `r` и `s`, где r — relaxed более мягкая проверка, чем s — strict.
`pct` отвечает за кол-во писем, подлежащих фильтрации, указывается в процентах, например, `pct=20` будет фильтровать 20% писем.
`rua` — позволяет отправлять ежедневные отчеты на email, пример: `rua=mailto:postmaster@your.tld`, так же можно указать несколько email через пробел (`rua=mailto:postmaster@your.tld mailto:dmarc@your.tld`)
**Пример отчета**
```
1.1.1.1
1
none
your.tld
your.tld
pass
your.tld
pass
1.1.1.1
1
none
forwarded
your.tld
your.tld
pass
your.tld
pass
```
`ruf` — отчеты писем, не прошедшие проверку DMARC. В остальном все так же, как и выше.
### Эпилог
Мы научились настраивать DKIM/SPF/DMARC и противостоять спуфингу. К сожалению, это не гарантирует безопасность в случае взлома сервера или же отправки писем на серверы, не поддерживающие данные технологии. Благо, что популярные сервисы все же их поддерживают (а некоторые и являются инициаторами данных политик).
Эта статья — лишь инструкция по самостоятельной настройке записей, своего рода документация. Готовых примеров нет намеренно, ведь каждый сервер уникален и требует своей собственной конфигурации.
Буду рад конструктивной критике и правкам. | https://habr.com/ru/post/322616/ | null | ru | null |
# Учим NAS Synology маршрутизировать трафик в OpenVPN туннель с аутентификацией по сертификату
Понадобилось мне чтобы некоторые сайты думали что я нахожусь не в Европе, а в России. Да и свой интерес к торрентам хотелось скрыть от местных властей (не уверен что они следят, но тем не менее.) И были у меня файл конфигурации клиента OpenVPN и сертификаты к нему. Кроме того, очень не хотелось ставить OpenVPN на каждое устройство в сети. Домашний маршрутизатор относится к крайне нижней ценовой группе и точно не умеет работать с OpenVPN. И вспомнил я про свое сетевое хранилища данных, которое у меня только и делает что данные хранит. Раньше еще и торренты качало, но после переезда от торрентов было решено временно отказаться. Вот его-то (Synology DS211j) и было решено превратить в шлюз в Российский интернет, а то что процессорные мощности простаивают.
Заранее предупреждаю что все манипуляции были произведены на DSM версии 5.0-4458 и на других версиях все может быть иначе.
#### Настройка OpenVPN подключнения на synology
В первую очередь заходим в web-интерфейс нашего хранилища в раздел «Панель управления>Сеть>Сетевой интерфейс» и создаем там профиль OpenVPN. К сожалению web-интерфейс рассчитан только на создание подключения с парольной аутентификацией. Нас же интересует аутентификация по сертификату. Поэтому заполняем предложенные поля любыми данными:
Щелкаем далее, и устанавливаем следующие настройки:
Обратите внимание на второй пункт настроек. Что имеется в виду не очень понятно. В DSM версии 4.3 таких недостатков перевода мною замечено не было.
Затем в разделе «Панель управления>Терминал и SNMP>Терминал» включаем тот способ коммуникации с хранилищем который вам идеологически ближе:
Подключаемся к synology c использованием выбранного протокола. Затем нам будет необходимо поправить созданный автоматически файл /usr/syno/etc/synovpnclient/openvpn/client\_oXXXXXXXXXX. Гуру vi могут это сделать прямо в консоли, остальным может быть удобно скопировать файл к себе в папку общего доступа и отредактировать файл там с использованием более привычных инструментов. Делается это следующей командой
`cp /usr/syno/etc/synovpnclient/openvpn/client_oXXXXXXXXXX /volume1/Share`
При редактировании файла обратите внимание что у Linux и windows разные подходы к обозначению конца строки, поэтому используйте текстовый редактор который сможет сохранить файл в привычном synology формате.
В моем случае файл конфигурации выглядит следующим образом:
`client`
`dev tun`
`proto udp`
`remote 255.255.255.255 1194`
`resolv-retry infinite`
`nobind`
`persist-key`
`persist-tun`
`ca keys/ca.crt`
`cert keys/client.crt`
`key keys/client.key`
`ns-cert-type server`
`cipher AES-128-CBC`
`auth SHA1`
`redirect-gateway def1`
Затем с помощью команды mkdir создаем директорию keys в директории /usr/syno/etc/synovpnclient/openvpn/ куда и положим с помощью команды cp имеющиеся у нас файлы сертификатов и ключи от них. С помощью этой же команды необходимо скопировать измененный файл конфигурации обратно в соответствующую директорию.
Для того чтобы подключиться к серверу OpenVPN необходимо зайти в «Панель управления>Сеть>Сетевой интерфейс», выбрать созданное нами подключение и нажать на кнопку «Подключить». Благодаря строке «redirect-gateway def1» в конфигурационном файле synology будет использовать созданный туннель в качестве основного канала для доступа к интернет, а при отключении от VPN сервера наше хранилище будет вновь использовать имеющийся в локальной сети маршрутизатор для доступа в глобальную сеть.
#### Настраиваем остальные устройства
Теперь осталось научить остальные устройства выбирать путь в интернет. Для этого у меня создано два скрипта с следующим содержимым:
напрямую.bat:
`route change 0.0.0.0 mask 0.0.0.0 255.255.255.254 metric 1`
через туннель.bat:
`route change 0.0.0.0 mask 0.0.0.0 255.255.255.255 metric 1`
где 255.255.255.254 — адрес домашнего маршрутизатора, а 255.255.255.255 — адрес synology в локальной сети.
При необходимости выпустить одно из устройств в интернет через российский канал на synology через web-интерфейс поднимается VPN подключение, а на ПК, с помощью скрипта, меняется шлюз по умолчанию. Когда необходимость пропадает — подключение на synology гасится, а на ПК, с помощью другого скрипта, шлюз по умолчанию возвращается обратно.
##### Скорость
При моем паттерне использования подобной конфигурации нагрузка на процессор хранилища не превышает 80% что много, но не критично. Не стоит также забывать, что подобная конфигурация вносит большие задержки, а скорость через туннель в моем случае не превышает 8 мегабит при скорости домашнего интернета в 20 мегабит и скорости в 40 мегабит на том конце туннеля. | https://habr.com/ru/post/216197/ | null | ru | null |
# Замолвим слово об отладке и профилировании [PHP]
Все идет от лени. Вы получили чужой очень большой проект в котором нужно сделать небольшие правки, или же написали скрипт и сразу не очевидно, что в нем еще требует оптимизации. Как быть? Читать и анализировать код, выводить каждый шаг на экран или в файл (var\_dump() и т.д.) не всегда эффективно, ведь можно воспользоваться средствами отладки, которых на сегодняшний день очень много. Кратко перечислю часто встречающиеся…
**Xdebug Debugger and Profiler Tool** — расширение PHP. Требует установки на сервер и настройки. Может отображать: стек вызовов функций, распределение памяти. Возможности: профайлинг, анализ покрытия кода, защита от бесконечной рекурсии, интерактивная отладка скриптов. ПО для визуализации логов xdebug: [Webgrind](https://code.google.com/p/webgrind/) – веб-интерфейс для профайлинга Xdebug, написанный на PHP, [MacGDBp](https://www.bluestatic.org/software/macgdbp/) – Mac OS X клиент, который позволяет отлаживать PHP приложения при помощи Xdebug. Linux GUI [kcachegrind](http://kcachegrind.sourceforge.net/html/Home.html). Бесплатный. Интегрируется с многими IDE. См [Profiling PHP Applications With xdebug](http://habrahabr.ru/post/31468/). При включении опции в php.ini:
```
html_errors = On
```
будет форматировать вывод var\_dump() и сообщения об ошибках.
**Xhprof** — расширение PHP от facebook. Требует установки на сервер и настройки. Позволяет собирать время выполнения каждой функции, использование памяти, время ожидания, количество вызовов и многое другое. Это расширение доступно из [репозитория PECL](http://pecl.php.net/package/xhprof). Почитать документацию можно тут [[тыц]](http://php.net/xhprof). Так же [Профилирование и отладка php-приложений с помощью xhprof & FirePHP](http://habrahabr.ru/post/145895/). Из преимуществ сильно не грузит систему, можно ставить на бой. Бесплатный.
**DBG** (PHP Debugger and Profiler) — расширение PHP. Требует установки на сервер и настройки. Позволяет работать на тестовом или/и рабочем сервере и отлаживать скрипты локально или удаленно, из IDE или консоли. Платная/бесплатная версии.
**ZendDebug** — расширение PHP, входит в состав Zend Studio (платная IDE). Требует установки на сервер и настройки. Позволяет практически все тоже, что и xdebug, GUI в IDE Zend Studio или Zend Server. Платный. Чуть ниже рассмотрим его более подробно.
**Memtrack** — расширение PHP. Позволяет искать утечки памяти. Удобно проверять скрипты запускаемые по крону или в качестве демона. Бесплатный. См. [[тыц]](http://www.php.net/manual/en/book.memtrack.php)
**APD Advanced PHP debugger** — расширение PHP. Слабый конкурент xdebug, но имеет в себе возможности memtrack. Плохо интегрируется с IDE, однако имеет консольный интерфейс (см. [[тыц](http://www.php.net/manual/en/book.apd.php)]). Бесплатный.
**DTrace + PHP** — расширение PHP. Низкоуровневая отладка. См. [[тыц]](http://www.php.net/manual/en/features.dtrace.php). Так же не нужно забывать о существовании [Strace](http://habrahabr.ru/post/215577/) и прочих системных отладчиков, которые порой способны показать где, так сказать, «собака порылась». Например
`strace -p 1111`
анализ системных вызов скрипта, с PID=1111. Также сетевые анализаторы [wireshark](http://ru.wikipedia.org/wiki/Wireshark) (Windows), [ngrep](http://en.wikipedia.org/wiki/Ngrep), [tcpdump](http://ru.wikipedia.org/wiki/Tcpdump) (Linux) — для анализа сетевого трафика, протоколов и т.д.
**FirePHP** — класс, написан на php + расширение для FireFox. Дает возможность посылать отладочные сообщения в консоль Firebug с помощью вызова php методов. Вся информация посылается через заголовки X-FirePHP-Data, тем самым не пересекаясь с основным контентом страниц. Бесплатный. См. [Отладка PHP средствами Firebug](http://habrahabr.ru/post/28537/)
**php-console** — написан на php + расширение для Google Chrome. Аналог FirePHP, только для Google Chrome, но несколько с другим функционалом. Бесплатный. См. [php-console](https://github.com/barbushin/php-console)
**PHP\_Debug** класс, написан на php. Помогает в отладке PHP кода, показывает путь выполнения скрипта, отображает все переменные, время выполнения, включенные файлы, выполненные запросы, watch переменные… Эта информация собирается во время выполнения скрипта, и отображается по его завершению и потом может быть использована в любой момент. Бесплатный.
**Pinba** — сервис мониторинга и статистики в реальном времени. См
[Мониторим php в реальном времени](http://habrahabr.ru/post/129042/)
[Мониторинг производительности PHP-кода с помощью Pinba](http://habrahabr.ru/company/badoo/blog/149695/). Бесплатная.
Статьи общего характера:
[Профилирование PHP-кода](http://habrahabr.ru/post/78210/)
[Отладка сложных веб-приложений — эффективная багодробилка на production-серверах](http://habrahabr.ru/company/bitrix/blog/144482/)
**Отладчики в современных CMS/CMF/Framework**. Их не рассматриваем, т.к. зачастую они имеют специфику и разработаны под конкретную оболочку, что делает не возможным использование их извне (IDE) или применять без значительных изменений в своих разработках.
Для сбора и анализа узких мест в ваших приложениях иногда может пригодится методика централизованного хранении syslog, см [[тыц](http://habrahabr.ru/post/139040/)].
Вернемся к ZendDebug. Так как я в основном пользуюсь Zend Studio, то мне наиболее удобно с ним работать. Он позволяет сразу понять ход выполнения скрипта, поддерживает навигацию по коду из IDE. Не нужны никакие сторонние инструменты, кроме IDE. Это действительно удобно, так сказать настроил один раз и пользуешься.
Отладка и профилирование скриптов в Zend Studio возможна как минимум двумя способами при помощи xdebug или ZendDebug. Только вот профилирование сайта с xdebug у меня не заработало, пишет что нельзя так — только отладка.
Про локальную отладку кода писали еще во времена Zend Studio 5.5 [[тыц]](http://habrahabr.ru/post/43728/). С тех времен мало что изменилось. Но я столкнулся с проблемой, когда web сервер и отлаживаемый код находится на удаленном сервере. Часто такие песочницы закрыты извне, а отрыты только нужные для работы порты. Но если к такой песочнице есть доступ по SSH, то настроить ZendDebug все таки можно, не мешая фаерволу выполнять свою функцию.
Забегая вперед отмечу, что для этого нужно будет создать SSH туннель. Немного о том, зачем SSH туннель нужен в этом случае.
По умолчанию Zend Studio инициирует сеанс удаленной отладки, отправив HTTP запрос на отладочный сервер. Этот запрос содержит параметры обратного адреса (IP-адрес и номер порта), который ZendDebug (установленный на сервере) использует при запуске нового подключения к Zend Studio, чтобы ретранслировать информацию об отладке. Кстати, инициализировать сам сеанс отладки можно как из IDE, так и из браузера установив компонент, поставляемый вместе с Zend Studio, будет довольно удобно.
Обычная отладочная сессия будет иметь место, например, в случае, когда код, WEB сервер и IDE находятся на локальном компьютере.
Но зачастую WEB сервер разделен с IDE брандмауэрами, маршрутизаторами, прокси-серверами т.д. Тут-то и пригодится SSH туннель.
В случае с туннелем процесс установления сеанса отладки состоит из двух основных этапов:
— создания SSH туннеля;
— настройки Zend Debugger, для передачи своего трафика через SSH туннель.
Схема отладочной сессии через SSH туннель примет вид:
Обычная отладочная сессия через SSH туннель
Zend Studio, по умолчанию, открывает порт 10137. Его и будем использовать в примерах далее. Можно назначить и другой порт, если это необходимо.
Создание SSH туннеля в Linux или Mac OS X можно в командной строке:
ssh <порт Zend Studio >:127.0.0.1:<порт для открытия debug server> @пример:
```
user@workstation:~> ssh -R 10137:127.0.0.1:10137 user@debugserver
user@debugserver's password:
Welcome to the Debug Server!
user@debugserver:~$
```
Для создания SSH туннеля в Microsoft Windows, можно использовать [PuTTY](http://ru.wikipedia.org/wiki/PuTTY). После создания рабочего SSH соединения, необходимо дополнительно настроить туннель.
Со стороны IDE проверьте, что слушаются порт 10137 и локальный IP адрес 127.0.0.1
Практика тенулирования трафика вам может пригодится и для других целей. Например локальными утилитами делать SQL-дампы СУБД, когда удаленная база разрешает соединение только с 127.0.0.1 и т.д.
Думаю из списка выше каждый сможет найти себе удобный инструмент на каждый день. И что бы разработка приносила еще больше удовольствия, а на вопрос — «Что случилось? Почему лежим?», был всегда оперативный ответ.
Приятной отладки и скриптов без ошибок, спасибо за внимание.
udp. добавил php-console, спасибо [Arik](https://habrahabr.ru/users/arik/) | https://habr.com/ru/post/210202/ | null | ru | null |
# MS SQL 2011 — Обработка ошибок
Новое полезное дополнение для SQL Server 2011 (Denali) – выражение **Throw**. Разработчики на .Net уже догадались наверно, где и как оно будет использоваться.
Это слово может использоваться в сочетании с управляющей конструкцией Try…Catch и позволяет послать уведомление о возникновении ошибки времени исполнения. Когда возникает исключение, программа ищет ближайший по иерархии вверх блок Catch который может обработать исключение. Используя это выражение внутри блока Catch можно изменить вывод ошибки. Более того, теперь вызывать исключение можно произвольно в любом месте скрипта.
Далее рассмотрим различные способы поимки исключении, которые предоставляет SQL Server начиная с версии 2000 и до версии 2011, с указанием плюсов и минусов.
Для всех рассматриваемых случаев будет использоваться таблица *tbl\_ExceptionTest*.
[](https://habrastorage.org/getpro/habr/post_images/559/f66/ed5/559f66ed5deb82355466c7e9149ce00c.jpg)
Для того, чтобы не протыкивать дизайнер мышью, можно выполнить следующий скрипт для создания искомой таблицы (сгенерировано автоматически).
```
IF EXISTS (SELECT * FROM sys.objects WHERE name = 'tbl_ExceptionTest' AND type = 'U')
DROP TABLE tbl_ExceptionTest
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [dbo].[tbl_ExceptionTest](
[Id] [int] IDENTITY(1,1) NOT NULL,
[Phone Number] [int] NOT NULL,
CONSTRAINT [PK_tbl_ExceptionTest] PRIMARY KEY CLUSTERED
)
```
Далее будем пытаться добавить в таблицу несколько записей и при внесении неподходящих данных в колонку Phone Number генерировать исключения.
Обработка ошибок в SQL Server 2000 (Sphinx)
-------------------------------------------
### Использование глобальной переменной @@ERROR
Возвращаясь во времена использования SQL Server 2000, вспоминаем что использование переменной @@Error было на тот момент самым прогрессивным и эффективным способом обработки ошибок. Данная переменная отвечала за возврат целочисленного значения ошибки, которое произошло в последнем выполненном выражении. Значение ошибки могло быть как положительным, так и отрицательным, лишь 0 указывал на успешность выполнения операции. Значение переменной менялось после каждого выполненного выражения.
Посмотрим на использование @@Error в действии.
```
-- Если таблица #tblExceptionTest уже создана, то удалить ее.
If OBJECT_ID('tempdb..#tblExceptionTest') Is not null
Begin
Drop Table #tblExceptionTest
End
-- Создать временную таблицу #tblExceptionTest
Create Table #tblExceptionTest (Id int identity, [Phone Number] varchar(10) not null)
--Начало транзакции
Begin Transaction TranExcp__2000_@@Error
-- объявление переменных
-- локальная переменная хранящая номер ошибки из @@ERROR
Declare @ErrorNum int
-- локальная переменная работающая как счетчик
Declare @i int
-- инициализация переменных
Set @i =1
-- начало операции
While(@i <= 4)
Begin
-- симуляция ситуации когда пользователь пытается ввести null в колонку Phone Number
If(@i = 4)
Begin
Insert into #tblExceptionTest([Phone Number]) Values(null)
Set @ErrorNum = @@ERROR
End
Else
-- все данные будут внесены успешно
Begin
Insert into #tblExceptionTest([Phone Number]) Values(cast(@i as varchar(2)) + '12345678')
End
Set @i = @i +1
End -- конец while
-- если есть ошибки, вывести их и откатить транзакцию
If @ErrorNum <> 0
Begin
Rollback Transaction TranExcp__2000_@@Error
-- показать специальное сообщение об ошибке
RAISERROR ('Attempt to insert null value in [Phone Number] is not allowed',16,1)
End
-- сохранить изменения
Else If @ErrorNum = 0
Begin
Commit Transaction TranExcp__2000_@@Error
End
-- показать записи
Select * from #tblExceptionTest
```
Общий смысл скрипта сводиться к тому, что в последней записи мы намеренно вызываем ошибку и читаем ее значение из локальной переменной. Если значение ошибки не равно нулю, то показываем осмысленное предупреждение пользователю. Если ошибок нет, то сохраняем результаты.
Выполнение данного скрипта приведет к появлению ошибки, как показано ниже
***Msg 515, Level 16, State 2, Line 26 Cannot insert the value NULL into column 'Phone Number', table 'tempdb.dbo.#tblExceptionTest\_\_\_\_\_000000000023'; column does not allow nulls. INSERT fails. The statement has been terminated. Msg 50000, Level 16, State 1, Line 43 Attempt to insert null value in [Phone Number] is not allowed***
Естественно, что вся транзакция откатится назад и ничего не будет внесено в таблицу.
### Недостатки подхода с использованием @@Error
* Значение переменной @@Error должно быть проверено **сразу** после выполнения запроса/команды.
* Так как @@Error постоянно меняется, то мы вынуждены заводить отдельную переменную для сохранения и вывода кода ошибки.
* Вместе со специальным сообщением об ошибке указывающей на логический смысл ошибки выводится техническая информация, которая пользователям не интересна.
Если вы хотите узнать больше деталей и нюансов по использованию @@Error, то советую обратиться к статье про [@@Error](http://msdn.microsoft.com/en-us/library/aa933181(v=sql.80).aspx).
### Использование глобальной переменной @@TRANCOUNT
Эта переменная возвращает количество транзакций выполняющихся в момент обращения к переменной. Из описания уже понятно, что она постоянна примерно в той же мере, что и @@ERROR, т.е. постоянно меняется во время исполнения транзакций. Это опять подводит нас к тому, чтобы использовать локальные переменные для хранения значений в интересующий момент времени.
Каждый вызов BEGIN TRANSACTION увеличивает значение @@TRANCOUNT на 1 и каждый вызов COMMIT TRANSACTION уменьшает ее значение на 1. ROLLBACK TRANSACTION не изменяет значения @@TRANCOUNT. Записи считаются внесенными только когда значение @@TRANCOUNT достигнет 0.
Рассмотрим использование @@TRANCOUNT на следующем примере.
```
-- если таблица #tblExceptionTest существует, то удаляем ее
If OBJECT_ID('tempdb..#tblExceptionTest') Is not null
Begin
Drop Table #tblExceptionTest
End
-- создаем временную таблицу
Create Table #tblExceptionTest (Id int identity, [Phone Number] varchar(10) not null)
-- начинаем транзакцию
Begin Transaction TranExcp__2000_@@TRANCOUNT
--объявление переменных
-- локальная переменная хранящая значение @@TRANCOUNT
Declare @TransactionCount int
-- счетчик
Declare @i int
-- инициализация счетчика
Set @i =1
-- старт эксперимента
While(@i <= 4)
Begin
-- симуляция ситуации когда пользователь пытается ввести null в колонку Phone Number
If(@i = 4)
Begin
Insert into #tblExceptionTest([Phone Number]) Values(null)
Set @TransactionCount = @@TRANCOUNT
End
Else
-- все записи будут внесены успешно
Begin
Insert into #tblExceptionTest([Phone Number]) Values(cast(@i as varchar(2)) + '12345678')
End
Set @i = @i +1
End -- конец while
-- если есть ошибки, то уведомить об этом и откатить транзакцию
If @TransactionCount <> 0
Begin
Rollback Transaction TranExcp__2000_@@TRANCOUNT
-- показ специальной ошибки
RAISERROR ('Attempt to insert null value in [Phone Number] is not allowed',16,1)
End
-- подтверждение изменений
Else If @TransactionCount = 0
Begin
Commit Transaction TranExcp__2000_@@TRANCOUNT
End
-- вывод записей
Select * from #tblExceptionTest
```
В данном скрипте мы опираемся на количество закрытых транзакций. Транзакции могут быть вложенные, так что такой способ имеет право на существование.
Для получения дополнительной информации по [@@TRANCOUNT](http://msdn.microsoft.com/en-us/library/ms187967.aspx) обратитесь на MSDN.
### Использование глобальной переменной @@ROWCOUNT
Данная переменная возвращает количество измененных строк в результате выполнения запроса/команды.
Поведение такое же, как и у предыдущих двух, так что сохраняем промежуточные результаты в локальную переменную для последующего анализа.
Пример:
```
If OBJECT_ID('tempdb..#tblExceptionTest') Is not null
Begin
Drop Table #tblExceptionTest
End
Create Table #tblExceptionTest (Id int identity, [Phone Number] varchar(10) not null)
Begin Transaction TranExcp__2000_@@ROWCOUNT
Save Transaction TranExcp__SavePoint
Declare @RowCount int
Declare @i int
Set @i =1
While(@i <= 4)
Begin
If(@i = 4)
Begin
Insert into #tblExceptionTest([Phone Number]) Values(null)
Set @RowCount = @@ROWCOUNT
End
Else
Begin
Insert into #tblExceptionTest([Phone Number]) Values(cast(@i as varchar(2)) + '12345678')
End
Set @i = @i +1
End
If @RowCount = 0
Begin
Rollback Transaction TranExcp__SavePoint
RAISERROR ('Attempt to insert null value in [Phone Number] is not allowed',16,1)
End
Else If @RowCount <> 0
Begin
Commit Transaction TranExcp__2000_@@ROWCOUNT
End
Select * from #tblExceptionTest
```
В данном случае мы ожидаем, что вставится одна запись в таблицу, но если количество вставленных записей равно нулю, то явно что-то не в порядке.
Для того, чтобы получить больше деталей по использованию [@@ROWCOUNT](http://technet.microsoft.com/en-us/library/ms187316.aspx) читайте MSDN.
Обработка ошибок в SQL Server 2005/2008 (Yukon/Katmai)
------------------------------------------------------
После вывода на рынок SQL Server 2005 и развития его идей в SQL Server 2008 у разработчиков на TSql появился новый блок Try…Catch. Теперь стало возможно перехватывать исключения без потери транзакционного контекста.
Пример на использование блока Try … Catch.
```
If OBJECT_ID('tempdb..#tblExceptionTest') Is not null
Begin
Drop Table #tblExceptionTest
End
Begin TRY
Create Table #tblExceptionTest (Id int identity, [Phone Number] varchar(10) not null)
Begin Transaction TranExcpHandlingTest_2005_2008
Declare @i int
Set @i =1
While(@i <= 4)
Begin
If(@i = 4)
Begin
Insert into #tblExceptionTest([Phone Number]) Values(null)
End
Else
Begin
Insert into #tblExceptionTest([Phone Number]) Values(cast(@i as varchar(2)) + '12345678')
End
Set @i = @i +1
End
Commit Transaction TranExcpHandlingTest_2005_2008
End Try
Begin Catch
Begin
Rollback Transaction TranExcpHandlingTest_2005_2008
RAISERROR ('Attempt to insert null value in [Phone Number] is not allowed',16,1)
End
End Catch
Select * From #tblExceptionTest
```
В примере больше не используется вспомогательных переменных для определения ошибки выполнения скрипта по косвенным признакам.
После запуска скрипта получим сообщение следующего вида:
***Msg 50000, Level 16, State 1, Line 45 Attempt to insert null value in [Phone Number] is not allowed***
Как вы уже наверно заметили, на этот раз вывелось только то, что было задано в сообщении об ошибке. Никаких дополнительных, смущающих пользователя сообщений, SQL Server не показал. Выполняемый код обрамлен в блоке try и обработка ошибки в блоке catch. Получается чистый и ясный для понимания код. Если весь желаемый код прошел без ошибок, то код из блока Catch не будет вызван.
Самое важное то, что Catch блок представляет набор функций для детального разбора причин ошибки и возможность информирования пользователя на должном уровне. Функции для разбора исключительной ситуации:
* ERROR\_NUMBER
* ERROR\_SEVERITY
* ERROR\_STATE
* ERROR\_LINE
* ERROR\_PROCEDURE
* ERROR\_MESSAGE
С помощью этих функций попробуем переписать Catch блок скрипта, что бы представлен до этого.
```
Begin Catch
-- обработка ошибки
Begin
-- откат транзакции
Rollback Transaction TranExcpHandlingTest_2005_2008
SELECT
ERROR_NUMBER() AS ErrorNumber,
ERROR_SEVERITY() AS ErrorSeverity,
ERROR_STATE() AS ErrorState,
ERROR_PROCEDURE() AS ErrorProcedure,
ERROR_LINE() AS ErrorLine,
ERROR_MESSAGE() AS ErrorMessage;
End
End Catch
```
Теперь мы получим такой ответ от сервера:
[](https://habrastorage.org/getpro/habr/post_images/e79/d21/9e8/e79d219e848e3929045c857fed7d2102.jpg)
### Недостатки использования функции RaiseError
1 Если вспомнить, что показывала эта функция вызванная в Catch блоке, то заметим, что она ссылалась на строку номер 45, как источник проблем.
[](https://habrastorage.org/getpro/habr/post_images/c69/8f3/a9f/c698f3a9f0f771923a971f2bb0c896d4.jpg)
Однако в действительности ошибка произошла в строке номер 24, так где было написано
**Insert into #tblExceptionTest([Phone Number]) Values(null)**
В то время как функция ERROR\_LINE() возвращает всегда реальное место возникновения ошибки. Еще один способ, чтобы показать работу новых функций будет такой:
```
Begin Catch
Begin
Rollback Transaction TranExcpHandlingTest_2005_2008
DECLARE @errNumber INT = ERROR_NUMBER()
DECLARE @errMessage VARCHAR(500) = 'Attempt to insert null value in [Phone Number] is not allowed'
RAISERROR('Error Number: %d, Message: %s', 16, 1, @errNumber, @errMessage)
End
End Catch
```
В этом случае движок SQL Server выдаст такое сообщение:
[](https://habrastorage.org/getpro/habr/post_images/0f8/647/21f/0f864721f8bbb8b5b5c3c323573a420e.jpg)
Из чего можно заключить, что использование RaiseError не дает возможности указать на реальное место в скрипте, где произошла исключительная ситуация.
2 Следующий недостаток функции RaiseError состоит в том, что нет возможности повторно инициировать тоже самое исключение, для передачи вверх по иерархии вызовов. Так, если переписать блок Catch как показано ниже
```
Begin Catch
Begin
Rollback Transaction TranExcpHandlingTest_2005_2008
RAISERROR(515, 16, 1)
End
End Catch
```
То полученное сообщение об ошибке будет таким:
***Msg 2732, Level 16, State 1, Line 46 Error number 515 is invalid. The number must be from 13000 through 2147483647 and it cannot be 50000***
Причной этого является то, что для инициирования нового сообщения об ошибке, номер ошибки должен содержаться в таблице **sys.****messages**.
Для более детального изучения функции RaiseError, рекомендуется к прочтению:
* [Детальный взгляд на RaiseError в SQL Server 2005](http://www.codeproject.com/KB/database/Raiserror.aspx)
* [Использование RaiseError](http://msdn.microsoft.com/en-us/library/ms177497.aspx)
Обработка ошибок в SQL Server 2011 (Denali)
-------------------------------------------
Упомянутые выше недостатки функции RaiseError могут быть успешно преодолены с помощью **новой команды** **Throw**.
Первый недостаток функции RaiseError, на который мы указали ранее, невозможность сослаться на точную строку возникновения ошибки. Рассмотрим насколько далеко от места возникновения ошибки мы оказываемся при использовании команды Throw.
Перепишем блок Catch с использованием команды Throw.
```
Begin Catch
Begin
Rollback Transaction TranExcpHandlingTest_2011;
THROW
End
End Catch
```
Вывод будет таким:
[](https://habrastorage.org/getpro/habr/post_images/201/b88/ac6/201b88ac64b487b04f0f7d95d86fdca1.jpg)
Это точно то место, где произошла ошибка. Что ж, работает пока на отлично.
Вторым недостатком было то, что функция RaiseError не может повторно инициировать исключение потому, что RAISE ERROR ожидает номер ошибки, который хранится в таблице sys.messages. Команда Throw не ожидает, что номер ошибки должен быть из диапазона системной таблицы sys.messages, однако номер можно задать из диапазона от 50000 до 2147483647 включительно.
Снова изменим блок Catch в соответствии с новыми знаниями.
```
Begin Catch
Begin
Rollback Transaction TranExcpHandlingTest_2011;
THROW 50001,'Attempt to insert null value in [Phone Number] is not allowed',1
End
End Catch
```
Результатом возникновения исключения будет
***Msg 50001, Level 16, State 1, Line 45 Attempt to insert null value in [Phone Number] is not allowed***
На данный момент SQL Server предоставляет множество путей для отлова ошибок, но до сих пор не все ошибки могут быть пойманы с помощью блока Try…Catch. Например:
* Синтаксические ошибки отлавливаются редактором запросов в SSMS
* Неправильные имена объектов
Если попробовать подать на выполнение следующий скрипт:
```
Begin Try
--неверное использование объекта tblInvalid
Insert Into tblInvalid(Id,DOB) Values(1,DATEADD(year,1,'2011-02-26'))
End Try
Begin Catch
--кидаем ошибку
THROW
End Catch
```
Получим сообщение об ошибке следующего плана:
***Msg 208, Level 16, State 0, Line 3 Invalid object name 'tblInvalid’.***
Получается что почти невозможно перехватить такие типы ошибок.
Но. Как всегда есть небольшой трюк как осуществить желаемое. Основная идея в том, чтобы сделать две хранимых процедуры и вызывать одну из другой в блоке Try…Catch и ловить исключение. Для доказательства нашего предположения используем для экспериментов следующий скрипт.
```
-- проверить существование процедуры, если есть, то удалить
If Exists (Select * from sys.objects where name = 'usp_InternalStoredProc' and type = 'P')
Drop Procedure usp_InternalStoredProc
Go
-- создать внутреннюю хранимую процедуру
Create Procedure usp_InternalStoredProc
As
Begin
Begin Transaction TranExcpHandlingTest_2011
Begin Try
-- обращение к несуществующему объекту
Insert Into tblInvalid(Id,DOB) Values(1,DATEADD(year,1,'2011-02-26'))
-- закрытие транзакции
Commit Transaction TranExcpHandlingTest_2011
End Try
Begin Catch
If @@TRANCOUNT > 0 Rollback Transaction TranExcpHandlingTest_2011
Print 'In catch block of internal stored procedure.... throwing the exception';
-- инициирование исключения
THROW
End Catch
End
Go
-- скрипт для создания внешней хранимой процедуры
-- проверка существования процедуры, если есть, то удалить
If Exists (Select * from sys.objects where name = 'usp_ExternalStoredProc' and type = 'P')
Drop Procedure usp_ExternalStoredProc
Go
-- создание внутренней хранимой процедуры
Create Procedure usp_ExternalStoredProc
As
Begin
Begin Try
-- вызов внутренней процедуры
Exec usp_InternalStoredProc
End Try
Begin Catch
Print 'In catch block of external stored procedure.... throwing the exception';
SELECT
ERROR_NUMBER() AS ErrorNumber
,ERROR_SEVERITY() AS ErrorSeverity
,ERROR_STATE() AS ErrorState
,ERROR_PROCEDURE() AS ErrorProcedure
,ERROR_LINE() AS ErrorLine
,ERROR_MESSAGE() AS ErrorMessage;
THROW
End Catch
End
Go
-- вызов внешней процедуры
Exec usp_ExternalStoredProc
```
При запуске процедуры **ExternalStoredProc** получим сообщение:
```
In catch block of external stored procedure.... throwing the exception
(1 row(s) affected)
Msg 208, Level 16, State 1, Procedure usp_InternalStoredProc, Line 8
Invalid object name 'tblInvalid'.
```
И панель Result отобразит следующие данные:
[](https://habrastorage.org/getpro/habr/post_images/165/5fe/dab/1655fedabffd8140dab4b06f4eec10c9.jpg)
Что нам и требовалось!
Теперь немного объяснений как работает код. У нас есть 2 хранимых процедуры: *usp\_InternalStoredProc* и *usp\_ExternalStoredProc*. В *usp\_InternalStoredProc* мы пытаемся вставить запись в несуществующую таблицу #tblInnerTempTable, в результате чего получаем исключительную ситуацию, которая в свою очередь отлавливается внешним блоком Catch, расположенным во внешней процедуре.
Более того, строка и текст ошибки полностью соответствуют нашим ожиданиям и указывают на точное место.
Очень важно не забыть закрыть точкой с запятой предстоящее перед THROW выражение во внешней процедуре. THROW должен быть новым набором команд. В противном случае получите ошибку
***Incorrect syntax near 'THROW'.***
Больше детальной информации о [THROW](http://msdn.microsoft.com/en-us/library/ee677615(SQL.110).aspx) можно подчерпнуть из MSDN.
*Переводы из цикла:
MS SQL Server 2011: [Автономные базы данных](http://habrahabr.ru/blogs/htranslations/123345/), [новый объект Sequence](http://habrahabr.ru/blogs/sql/123446/), [оператор Offset](http://habrahabr.ru/blogs/sql/123491/), [обработка ошибок](http://habrahabr.ru/blogs/sql/123507/), [конструкция With Result Set](http://habrahabr.ru/blogs/sql/123573/), [новое в SSMS](http://habrahabr.ru/blogs/sql/123664/).* | https://habr.com/ru/post/123507/ | null | ru | null |
# SIM800L + STM32 Bluepill + Rust. Как оно?
Несколько лет назад сделал себе на Arduino блок мониторинга питания дачного котла от UPS. Как показала практика, связка Arduino MEGA + шилд на SIM900 со стандартными библиотеками работает очень нестабильно. Периодически всё зависает, само перегружается и т.д. Отладить это невозможно, поэтому стал искать другие варианты. В результате решил всё переделать на современных технологиях: взял за основу STM32 Bluepill, приобрел на али модуль SIM800L, но самое главное – весь код решил написать на Rust, купился на обещания его высокой надёжности. Что из этого получилось читайте дальше.
Функциональность
----------------
Несколько слов о том, что хотелось получить от новой самоделки.
У меня на даче стоит UPS Inelt, в котором есть порт RS232 для управления UPS. Он поддерживает довольно древний протокол обмена Megatec, с помощью которого можно выполнять несложные действия по управлению UPS и узнавать его текущее состояние. Управление меня не особо интересовало, а вот состояние работы знать хотелось: как там сетевое напряжение, живы ли батареи и пр. На рынке я не нашёл готовых решений, которые могли бы решить эту задачу, поэтому решил всё сделать сам. Всё в духе DIY.
Протокол Megatec
```
Megatec Protocol information
VERSION : 2.7
DATE : SEP. 30, 1995
DATE :V2.7 : JULY 30 ,1996
DATE DESCRIPTION MODIFY BY
2.6 95-9-30 UPDATE "D" COMMAND (SS.SS -> SSS.SS) Kevin Chiou
2.7 96-8-01 Disable "D" COMMAND Kevin Chiou
A. General: This document specifies the RS232C communication protocol of
the Advance-Intelligent UPS. The protocol provided the following
features :
1. Monitor charger status.
2. Monitor battery status and condition.
3. Monitor the utility status.
4. Provide the power switch function for computer to turn on and
off the utility on schedule for power saving.
Computer will control information exchange by a query followed by
. UPS will respond with information followed by a or
action.
B. Hardware:
BAUD RATE............... : 2400 bps
DATA LENGTH.......... : 8 bits
STOP BIT..................... : 1 bit
PARITY........................ : NONE
CABLING :
COMPUTER UPS
===================================
RX <---------- TX (pin 9)
TX ----------> RX (pin 6)
GND <---------- GND (pin 7)
(9 pins female D-type connector)
C. COMMUNICATION PROTOCOL:
1. Status Inquiry:
Computer : Q1
UPS : UPS status data stream, such as
(MMM.M NNN.N PPP.P QQQ RR.R S.SS TT.T b7b6b5b4b3b2b1b0
UPS status data stream :
There should be a space character between every field for data
separation. The meaning of each field is list as followed:
a. Start byte : (
b.I/P voltage : MMM.M
M is and integer number ranging from 0 to 9.
The unit is Volt.
c.I/P fault voltage : NNN.N
N is and integer number ranging from 0 to 9.
The unit is Volt.
\*\* For OFF LINE UPS\*\*
Its purpose is to identify a short duration voltage glitch
which cause OFF line UPS to go to Invter mode. If this occurs
input voltage will appear normal at query prior to glitch and
will still appear normal at next query.
The I/P fault voltage will hold glitch voltage till next
query. After query, the I/P fault voltage will be same as I/P
voltage until next glitch occurs.
\*\* For ON LINE UPS\*\*
Its purpose is to identify a short duration utility fail
which cause ON line UPS to go to battery mode. If this occurs
input voltage will appear normal at query prior to fail and
will still appear normal at next query.
The I/P fault voltage will hold utility fail voltage till
next query. After query, the I/P voltage will be same as I/P
voltage until next utility fail occurs.
d.O/P voltage : PPP.P
P is an integer number ranging form 0 to 9.
The unit is Volt.
e.O/P current : QQQ
QQQ is a percent of maximum current, not an absolute value.
f.I/P frequency : RR.R
R is an integer number ranging from 0 to 9.
The unit is HZ.
g.Battery voltage : SS.S or S.SS
S is an integer number ranging from 0 to 9.
For on-line units battery voltage/cell is provided in the
form S.SS .
For standby units actual battery voltage is provided in
the form SS.S .
UPS type in UPS status will determine which reading was
obtained.
h.Temperature : TT.T
T is an integer number ranging form 0 to 9.
The unit is degree of centigrade.
i.UPS Status :
is one byte of binary information such as
.
Where bn is a ASCII character '0' or '1'.
.
UPS status :
Bit Description
7 1 : Utility Fail (Immediate)
6 1 : Battery Low
5 1 : Bypass/Boost or Buck Active
4 1 : UPS Failed
3 1 : UPS Type is Standby (0 is On\_line)
2 1 : Test in Progress
1 1 : Shutdown Active
0 1 : Beeper On
j.Stop Byte :
Example: Computer : Q1
UPS :
(208.4 140.0 208.4 034 59.9 2.05 35.0 00110000
Means : I/P voltage is 208.4V.
I/P fault voltage is 140.0V.
O/P voltage is 208.4V.
O/P current is 34 %.
I/P frequency is 59.9 HZ.
Battery voltage is 2.05V.
Temperature is 35.0 degrees of centigrade.
UPS type is on-line , UPS failed. Bypass
active , and shutdown not active.
2. Test for 10 seconds:
Computer : T
UPS : Test for 10 seconds and return to utility.
If battery low occur during testing, UPS will return to
utility immediately.
3.Test until battery low :
Computer : TL
UPS : Test until battery low and return to utility.
4.Test for specified time period :
Computer : T
UPS : Test for minutes.
a. During testing, UPS returns to utility immediately, if
battery low occur.
b. is a number ranging from 01 to 99.
5. Turn On/Off beep -- Toggle the UPS beeper :
Computer : Q
When the AC power failed, UPS will generate a warning beep to
inform the manager. Manager could toggle the warning beep by
sending this command .
6. Shutdown Command :
Computer : S
UPS : Shut UPS output off in minutes.
a. The UPS output will be off in minutes, even if the
utility power is present.
b. If the battery low occurs before minutes, the
output is turned off immediately.
c. After UPS shutdown, the controller of UPS monitors the
utility power. If the utility is recovered, the UPS will wait
for 10 seconds and connect the utility to output.
d. is a number ranging form .2, .3, ..., 01, 02, ..., up to 10.
For example : S.3 --- shut output off in (.3) minutes
7. Shutdown and Restore Command :
Computer : SR
UPS : Shut UPS output off in minutes, and waiting
for minutes then turn on UPS output again.
a. The shutdown sequence is the same as the previous command.
When the minutes expired, the utility do not restore,
the UPS will wait until utility restore.
b. If UPS is in shutdown waiting state, the "C" command can
let the shutdown procedure cancelled.
c. If UPS is in restore waiting state, the "C" command can
let the UPS output turned on, but UPS must be hold off at
least 10 seconds. (if utility is present)
d. is a number ranging form .2, .3, ..., 01, 02, ..., up to 10.
e. is a number ranging form 0001 to 9999.
8. Cancel Shutdown Command :
Computer : C
UPS : Cancel the SN and SNR command.
a. If UPS is in shut down waiting state, the shut down command
is cancelled.
b. If UPS is in restore waiting state, the UPS output is turned
on, but UPS must be hold off at least 10 seconds.
(if utility is present)
9. Cancel Test Command :
Computer : CT
UPS : Cancel all test activity and connect the utility to
output immediately.
10. UPS Information Command:
Computer : I
UPS : #Company\_Name UPS\_Model Version
This function will make the UPS respond with the basic information
about the company who manufacture the UPS, the model name of the
UPS and the version number of the UPS firmware. The length of
every field is listed as follows:
Company\_Name : 15 characters, leave space if less than 15 characters
UPS\_Model : 10 characters, leave space if less than 10 characters
Version : 10 characters, leave space if less than 10 characters
There should be a space character between every field for separation.
11. UPS Rating Information:
Computer : F
UPS : #MMM.M QQQ SS.SS RR.R
This function makes the UPS answer the rating value of UPS. There
should be a space character between every field for
separation. The UPS's response contains the following information
field:
a. Rating Voltage : MMM.M
b. Rating Current : QQQ
c. Battery Voltage : SS.SS or SSS.S
d. Frequency : RR.R
D. COMMAND SUMMARY:
ITEM COMMAND DESCRIPTION
1a D Status Inquiry \*disable
1 Q1 Status Inquiry
2 T 10 Seconds Test
3 TL Test until Battery Low
4 T Test for Specified Time Period
5 Q Turn On/Off beep
6 S Shut Down Command
7 SR Shut Down and Restore Command
8 C Cancel Shut Down Command
9 CT Cancel Test Command
10 I UPS Information Command
11 F UPS Rating Information
E. Invalid Command/Information Handling
If the UPS receives any command that it could not handle, the UPS should
echo the received command back to the computer. The host should check if
the command send to UPS been echo or not.
If there is any information field in the UPS's response which is
unavailable or not supported, the UPS should fill the field with '@'.
```
Поле недолгих раздумий решил, что хочу получать ежедневное СМС сообщение о состоянии UPS и иметь возможность запросить его просто позвонив на модуль. Ну и для полноты картины решил добавить в модуль датчик температуры теплоносителя в системе отопления.
Пока проектировал электронику, решил добавить к модулю свой маленький UPS, т.е. микроконтроллер может у меня питаться либо от сети, либо от встроенной батареи. Раз такое дело, решил еще мониторить модулем напряжения питания сети и батареи.
Всё это было реализовано, как уже писал выше, на Arduino MEGA + SIM900. Теперь же нужно было всё это переделать на Bluepill с небольшими доработками схем питания и подключения датчиков. Аппаратные возможности bluepill существенно больше, чем Arduino, поэтому особых проблем с переходом нет, тем более, что многие контакты bluepill толерантны к 5 В сигналам. Единственная проблема, что в bluepill нет eeprom, поэтому пришлось подключить к конструкции дополнительную микросхему. В кладовке нашлась бесхозная 24LC16, поэтому использовал её, хотя мне нужно было всего несколько байт хранить. Как до меня дошло позже, эти байты можно было бы сохранить в ячейках SIM карты, но цели сделать оптимальное решение я не ставил. Наоборот, поскольку я решил использовать новые для себя технологии, то мне интересно было всё попробовать – испытать как можно больше аппаратных возможностей STM32 и попробовать embedded Rust в целях самообразования.
В конце статьи есть ссылка на репозитарий с исходным кодом, если посмотрите, то увидите, что я использовал очень многие блоки STM32. АЦП, таймеры, USART, прерывания, RTC и пр. Руки не дотянулись разве что до использования DMA и новомодной асинхронщины Rust.
Начало похода по граблям
------------------------
Если на STM32 у меня уже был некоторый опыт программирования на C++, то Rust был совершенно в новинку. Вообще использовать Rust пришло в голову, когда наткнулся на несколько заметок, что кому-то удалось помигать светодиодом на bluepill используя Rust. К сожалению, более содержательных статей я тогда не встретил, поэтому решил для начала почитать поподробнее документацию Rust. Язык оказался довольно сложный для меня, надо прямо сказать, намного труднее того, что используется в Arduino. Самое печальное было то, что в книгах по Rust очень много уделяется внимания стандартным библиотекам, которые, что позже стало для меня неожиданностью, вообще не используются в embedded версии. Все эти String, Vec, сотни адаптеров и замыканий, которым посвящены тысячи страниц в документации вообще бесполезны. Печаль.
Но ради главного преимущества Rust, предсказуемого поведения программы, я готов был с этим всем примериться. Наверняка те, кто не потратил много бессонных ночей в поисках seg fault, не поймут меня, ну да и ладно.
Основным источником информации для меня стали исходники примеров использования библиотек на crates.io. Надо сказать, что даже имеющиеся там примеры нужно было допиливать чтоб они заработали на bluepill. Но тем интереснее и продуктивнее изучение языка. Начинающим сразу предлагаю изучить крейт heapless и использовать его методы вместо Vec, String стандартной библиотеки.
Далее в порядке важности, нужно разобраться в крейте stm32f1xx-hal. Собственно, благодаря ему обычно и идёт взаимодействие с оборудованием bluepill. Увидев слово HAL, сразу приходит мысль о STM32 CubeMX, но это обманчиво, тут HAL совсем другой. Другие функции, способы доступа к железу. Хорошо хоть на совсем низком уровне сохранили названия регистров и блоков микроконтроллера, иначе вообще ничего понять было бы невозможно без примеров. Документация на крейт есть, но довольно посредственная. Мне постоянно приходилось смотреть исходный код библиотеки для понимания как там всё реально работает.
Железо и драйверы
-----------------
Отдельная тема — это поиск драйверов для всякого оборудования. Если для Arduino есть, видимо, драйвер для любого устройства, то с Rust не всё так радужно. Меня с самого начала интересовало, есть ли готовые библиотеки для eeprom, датчика температуры DS18B20, да и SIM800. К счастью, для памяти и датчика крейты есть, а для SIM800 всё пришлось делать самому. Для обучения самое то. Я изучил исходники ардуиновской библиотеки SIM900 и решил их творчески портировать на Rust в необходимом мне объёме.
Кстати, для DS18B20 есть несколько крейтов и я сперва взял первый попавшийся. И не попал. Он оказался очень нестабильным – датчик то считывал температуру, то выдавал ошибку CRC. Я сначала менял датчики, отключал прерывания, но ничего не помогало. В результате перешёл на другой крейт и всё заработало стабильно без танцев с бубном.
Надо сказать, что для работы с AT командами есть готовый крейт atat. Можно было попробовать его использовать. Но мне он показался сложным. Да и идеологически он обрабатывает ответы от модуля SIM800 не так, как это делает Arduino. Последний определяет окончание передачи по таймауту, а atat использует маркером конца передачи перевод строки. В результат добиваться работоспособности atat я не стал, а просто свой код написал.
Для меня основной головной болью работы с SIM800 оказались так называемые unsolicited result codes. Это когда вы посылаете в модуль какую-то команду и ждете в ответ ОК, а получаете сообщение о новом СМС или RING. Очень неудобно. К счастью в документации на SIM800 написано как большинство из них отключить. Но при этом теряется возможность принимать входящие звонки. В итоге я включаю возможность принимать RING только на определённое время ожидания звонка, в остальное время звонки отклоняются. Это несколько снизило удобство работы с модулем, поскольку иногда дозвониться до него с первого раза не удаётся, хотя и редко. Зато надёжность работы остальных команд возросла. И да, я использую довольно “наивный” способ выполнения AT команд: просто делается несколько последовательных попыток выполнить команду, если с первого раза не получилось.
С авторизацией звонков поступил просто – беру “доверенные” номера телефонов из первых трёх ячеек SIM карты. Модуль будет отвечать на звонки только с этих номеров и отправлять СМС на последний набранный номер.
Пришлось повозиться с проблемой связи между SIM800 и bluepill. Казалось бы, обычный RS232 и всё должно было бы сразу запуститься. Но нет, при независимом перезапуске или подаче питания на SIM800 и МК связь часто терялась. Пришлось использовать для устойчивого коннекта последовательную программную перезагрузку сначала SIM800, а потом, в случае неуспеха, и bluepill.
Что не понравилось
------------------
Больным вопросом оказалось быстрое распухание кода бинарника. Строчек 200 кода в отладочной сборке ещё влезали во флеш, а потом всё. Практически сразу пришлось установить несколько опций оптимизации и отлаживать уже релизную версию. Большой скачок в использовании памяти произошёл, как только я стал использовать математику с плавающей точкой. Библиотеки fp занимают около 9 кб, которые сразу прибавились к бинарнику. Точнее, всё перестало просто собираться и я не знал, что делать дальше. Помог stackoverflow, где посоветовали поставить опцию opt-level = "z". Только с ней и удалось сделать сборку. При этом финальный размер бинарника составил 45 килобайт при 1300 строках исходного кода. Не могу оценить эффективность компилятора, но такой размер не проблема даже для bluepill, где есть 64 Кб флеша.
Паттерны проектирования ООП. Тут у меня не сложилось со state machines. Хотелось бы всё сделать по канонам «лучших паттернов проектирования», тем более в коде я использую несколько машин состояний. Но вот плодить десяток структур и типажей, которые при переходе состояний пожирают друг друга мне совсем не понравилось. Отдельно стоит упомянуть отсутствие доступа в embedded к куче и, как следствие, таких вещей как Box<> и прочих контейнеров. Сейчас весь код машины состояний в “С” стиле умещается на странице, прост и понятен. Разубедите меня, если сможете.
Использование Result<> для возврата ошибок. Наверное это удобно, когда стек вызовов глубокий и активно применяется оператор “?”. В моем же случае всё довольно тривиально, а использование Result<> с разными типами ошибок только всё усложняет. Умные книги советуют для унификации передачи кодов ошибок опять же применять Box<>, которого в embedded нет. Ну или просто ради него не хочется делать свой аллокатор кучи и получать связанные с этим потенциальные проблемы.
Небольшой лайфхак
-----------------
Для отладки программы мне нужно было связываться с UPS, который на даче, а второго у меня нет. Поэтому решил в качестве эмулятора использовать бесхозный модуль Arduino Nano. Написал для него несколько строк кода, которые обеспечивают эмуляцию нужной мне части протокола. Посмотреть можно здесь:
Код скетча
```
#include
SoftwareSerial mySerial(10, 11); // RX, TX
String stringOne = "";
unsigned long myTime;
void setup() {
mySerial.begin(2400);
}
void loop() { // run over and over
stringOne = "";
myTime = millis();
for(;;) {
if (mySerial.available()) {
char c = mySerial.read();
Serial.write(c);
stringOne += c;
//Serial.print("char read \r\n");
if (c == '\r' || stringOne.length() > 100) {break;};
myTime = millis();
} else {
if (millis() - myTime > 200)
break;
};
}
if (stringOne == "Q1\r") {
if (millis() % 2) {
mySerial.print("(216.6 216.6 219.6 000 50.0 2.22 48.0 00000001\r");
} else {
mySerial.print("(219.6 219.6 000.0 000 50.0 2.22 48.0 10000001\r");
}
};
}
```
Работа с эмулятором оказалась очень удобна для отладки. Рекомендую.
Итого
-----
Всё задуманное получилось! По ходу дела не обошлось без проблем, но где их нет? Можно сказать, что связка технологий вполне рабочая и подходит для DIY.
Теперь модуль присылает мне такие сообщения:
[А вот и обещанная ссылка на исходники в GITHUB](https://github.com/lesha108/sim800_ups_monitor). | https://habr.com/ru/post/594885/ | null | ru | null |
# Knight rider. Программируем плавную анимацию на микроконтроллере
Доброго времени суток.
Сегодня хочу вам рассказать как сделать плавную анимацию на микроконтроллере с помощью светодиодов. За основу взято микросхему attiny2313 фирмы Atmel, именно такая у меня ~~валялась~~ нашлась. Не буду углубляться в подробности прошивки, программатора, все это было на хабре. [Вот](http://habrahabr.ru/blogs/selfmade_robot/38075) и [вот](http://habrahabr.ru/blogs/controllers/75303) и [под линукс](http://habrahabr.ru/blogs/controllers/72780/)
Большинство помнят фильм, а потом уже и сериал [«Рыцарь дорог» (Knight Rider)](http://www.imdb.com/title/tt0083437/). Кто в детстве не мечтал о такой машине? Ну вот, для примера решил сделать анимацию, такую как впереди самой машины.
Спаял схему по следующему принципу.
Планку со светодиодами взял от телевизора «Электрон», как раз там было 8 штук. Там были светодиоды на 3 вольта, поэтому в моем варианте, последовательно диодам я добавил резисторы по 200 Ом.
#### Теория
Тривиальная штука, если на порт вывода записать единицу, то диод будет светить, если ноль, он погаснет. Для того, чтобы он частично светил (светил, но не на полную мощность) нужно эмулировать [ШИМ](http://ru.wikipedia.org/wiki/%D0%A8%D0%B8%D1%80%D0%BE%D1%82%D0%BD%D0%BE-%D0%B8%D0%BC%D0%BF%D1%83%D0%BB%D1%8C%D1%81%D0%BD%D0%B0%D1%8F_%D0%BC%D0%BE%D0%B4%D1%83%D0%BB%D1%8F%D1%86%D0%B8%D1%8F) на каждом порту.
Точность формирования импульса решил разнести на 10 итераций. То есть возможно 10 разных вариантом силы свечения диода. Если у всех итераций на выходе будет 1, то это максимальное свечение, если 5 из 10 — получиться половинное. То есть, когда на выходе 1 он будет загораться, но дальше идет 0, и он угасает. Такой ШИМ-сигнал имеет несколько сотен килогерц, и сама инерция диода дает нам нужный эффект.
#### Реализация
Всю анимацию засунул в матрицу, это дает нам возможность легко и просто программировать саму анимацию.
> `const char mat[] =
>
> {
>
> 10,0,0,0,0,0,0,0,
>
> 6,10,0,0,0,0,0,0,
>
> 2,6,10,0,0,0,0,0,
>
> 0,2,6,10,0,0,0,0,
>
> 0,0,2,6,10,0,0,0,
>
> 0,0,0,2,6,10,0,0,
>
> 0,0,0,0,2,6,10,0,
>
> 0,0,0,0,0,2,6,10,
>
> 0,0,0,0,0,0,2,6,
>
> 0,0,0,0,0,0,0,2,
>
> 0,0,0,0,0,0,0,0,
>
> 0,0,0,0,0,0,0,0,
>
> 0,0,0,0,0,0,0,10,
>
> 0,0,0,0,0,0,10,6,
>
> 0,0,0,0,0,10,6,2,
>
> 0,0,0,0,10,6,2,0,
>
> 0,0,0,10,6,2,0,0,
>
> 0,0,10,6,2,0,0,0,
>
> 0,10,6,2,0,0,0,0,
>
> 10,6,2,0,0,0,0,0,
>
> 6,2,0,0,0,0,0,0,
>
> 2,0,0,0,0,0,0,0,
>
> 0,0,0,0,0,0,0,0,
>
> 0,0,0,0,0,0,0,0
>
> };
>
>
>
> short timeAnim = 3000;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
И так timeAnim это время всей анимации. Каждая строчка это 10 итераций одного фрейма, где каждая ячейка это «светловая сила» диода.
Осталось только вычислить время анимации для одного фрейма (одной строчки матрицы), сформировать результат и вывести его в порт.
> `//вычисляем время для одного фрейма
>
> sPeriodTime = timeAnim \* 4 / sizeof(mat) \* 8;
>
> iCycle = 0;
>
>
>
> // вычисляем количество фреймов для анимации
>
> iMaxCycle = sizeof(mat) / 8;
>
>
>
> while (1)
>
> {
>
> PORTB = 0;
>
> TCNT1 = 0;
>
> iCycle = 0;
>
> while(iCycle < iMaxCycle)
>
> {
>
> while(TCNT1 < (iCycle + 1)\*sPeriodTime)//проверяем, истекло ли время для анимации одного фрейма
>
> {
>
> for(i = 0; i < 10; i++) //анимация 10 подфреймов
>
> {
>
> iTemp = 0;
>
> for(j = 0; j < 8; j++)//формируем выходное значения
>
> {
>
> iTemp <<= 1;
>
> iTemp |= (mat[iCycle\*8 + j] - i) > 0;
>
> }
>
> PORTB = iTemp; //записываем значения в порт
>
> }
>
> };
>
> iCycle++;
>
> }
>
> };
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### Результат
Ну и кому интересно, [исходники](http://www.mediafire.com/?j5tgihujzvz)
По традициям хабра, это моя первая статья, сильно не пинайте.
Успехов. | https://habr.com/ru/post/79481/ | null | ru | null |
# Функциональное тестирование веб-приложений без боли
Иногда в жизни бывает так — вот ждёшь, ждёшь чего-то, изучаешь теорию по данному вопросу, рассматриваешь разные подходы к решению, дискутируешь с такими же ищущими как ты, внимаешь гласу признанных гуру, но не продвигаешься дальше ни на дюйм. Потом бросаешь, забываешь вообще об этом вопросе, занимаешься другими делами, и вдруг — на тебе, всё встало на свои места, из разрозненных элементов сложилась чудесная мозаика, нагрянуло просветление, а волосы вдруг стали густыми и шелковистыми.
Вот примерно такая же история с автоматическим функциональным(приёмочным) тестированием. О такой классной штуке как автоматические тесты писал ещё Сам Кент Бек. Ну, а автоматические функциональные тесты — это вообще лакомый кусок для современных agile методик разработки ПО. Например, тот же Scrum — включает в себя практику «Демо», в ходе которой заказчику нужно показать развитие продукта, осуществлённое в ходе итерации.
Я, конечно, не спец agile-практик, и не изучал рынок инструментов для функционального тестирование веб проектов — возможно, и раньше в этом сегменте всё было зашибись. Но за те 5 лет, что я работаю программистом — я всего лишь пару раз слыхал такие слова автоматическое функциональное тестирование, Selenium и ни разу не видел применения на практике.
Так вот, возвращаясь к лирическому вступлению, мне кажется, что то колоссальное качественное изменение как раз и произошло недавно. И есть ощущение, что в ближайшее время только ленивый пренебрежет функциональным тестированием своего веб проекта.
Что же собственно произошло? Я подписан на RSS-ку [блога Springsource](http://blog.springsource.com/), и однажды обнаружил статью с вот таким интригующим названием — [The future of functional web testing?](http://blog.springsource.com/2010/08/28/the-future-of-functional-web-testing/).
Инструменты [Geb](http://geb.codehaus.org/) и [Spock](http://code.google.com/p/spock/), описанные в данной статье, меня зацепили, и я решил попробовать.
Собственно далее, я постараюсь ~~наступить на горло песне~~ прервать приступ графоманства и описать простой пример с использованием данных инструментов.
### Установка инфраструктуры
Для проведения тестов нам понадобится:
* JDK 1.6 или выше, скачать [тут](http://www.java.com/ru/download/)
* Maven 2.2.1, скачать [тут](http://maven.apache.org/download.html), [инструкция по установке](http://maven.apache.org/download.html#Installation)
### Первый функциональный тест
В данном параграфе будет приведён пример автоматизации простого, но несомненно полезного функционального теста.
Суть функционального теста будет состоять в том, чтобы:
— войти на сайт Википедии
— набрать в поиске «Функциональное тестирование»
— убедиться в том, мы действительно попали на желаемую страницу
(например, мы поищем вхождение в текст страницы строки «это тестирование ПО в целях проверки реализуемости функциональных требований»)
### Структура каталога проекта
Структура каталога проекта для тестирования выглядит следующим образом:
[](https://habrastorage.org/getpro/habr/post_images/1b3/ded/d73/1b3dedd7378b8a05336d9ae117073e23.png/)
pom.xml — файл с описанием проекта в Maven
simplefunctest — пакет, в котором будут храниться классы для описания тестов
### Собственно Тест
> `package my.tests.simplefunctest
>
>
>
> import geb.spock.GebSpec
>
>
>
> class MyFirstSpec extends GebSpec {
>
>
>
> def "test search functional testing wiki page"() {
>
> given: "we are at main wiki page"
>
> to MainWikiPage
>
>
>
> when: "try to search functional testing page"
>
> searchField.value("Функциональное тестирование")
>
> searchButton.click()
>
>
>
> then: "check we are on functional testing page"
>
> at FunctionalTestingWikiPage
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Что здесь происходит?
— Мы создаём класс для пакета наших тестов, наследуемся от базового класса, описывающего пакет тестов *GebSpec*.(По идее здесь должна использоваться терминология BDD, а именно спецификации и т.д., но для краткости и понимания буду её опускать)
> `class MyFirstSpec extends GebSpec { ... }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
— Мы создаём описание конкретного теста, предназначенного для поиска страницы, посвященной функциональному тестированию, на сайте Википедии
> `def "test search functional testing wiki page"() { ... }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
— Мы оказываемся на главной странице Википедии
> `given: "we are at main wiki page"
>
> to MainWikiPage
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
— Мы вводим в поле поиска фразу «функциональное тестирование» и инициируем нажатие кнопки поиска
> `when: "try to search functional testing page"
>
> searchField.value("Функциональное тестирование")
>
> searchButton.click()
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
— Затем мы проверяем, что действительно находимся на странице Википедии, посвященной функциональному тестированию
> `then: "check we are on functional testing page"
>
> at FunctionalTestingWikiPage
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
### Описание главной страницы Википедии
> `package my.tests.simplefunctest
>
>
>
> import geb.Page
>
>
>
> class MainWikiPage extends Page {
>
> static url = "http://ru.wikipedia.org/"
>
> static at = {title == "Википедия — свободная энциклопедия"}
>
> static content = {
>
> searchField { $("input", id: "searchInput")}
>
> searchButton (to: FunctionalTestingWikiPage) { $("button", id: "searchButton")}
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Что здесь происходит?
— Мы создаём класс для описания главной страницы Википедии, наследуемся от базового класса, описывающего страницу *Page*
> `class MainWikiPage extends Page { ... }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
— Указываем URL страницы(требуется, так как с этой страницы начинается тест)
> `static url = "http://ru.wikipedia.org/"
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
— Описываем замыкание для проверки, что мы находимся на требуемой странице(в данном случае проверяем, что заголовок представляет собой «Википедия — свободная энциклопедия»)
> `static at = {title == "Википедия — свободная энциклопедия"}
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
— Описываем замыкание для наполнения страницы(в данном случае это — текстовое поле поиска и кнопка для осуществеления поиска(оба элемента будут найдены по тегу и id))(см. [статью про использование функции $()](http://geb.codehaus.org/manual/latest/navigator.html#the__function))
> `static content = {
>
> searchField { $("input", id: "searchInput")}
>
> searchButton (to: FunctionalTestingWikiPage) { $("button", id: "searchButton")}
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
### Описание страницы результата поиска
> `package my.tests.simplefunctest
>
>
>
> import geb.Page
>
>
>
> class FunctionalTestingWikiPage extends Page {
>
>
>
> static at = { $().text().contains("это тестирование ПО в целях проверки реализуемости функциональных требований") }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Надеюсь тут всё понятно.
### Собственно старт теста
Теперь перейдём к самому интересному, ради чего мы всё это затеяли, а именно к старту тестов.
В командной строке, в корневом каталоге проекта нужно выполнить:
> `mvn clean test
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Бинго! У вас должен стартовать FireFox(он настроен как браузер по умолчанию для тестов) и выполнить(без вашего участия(!!!)) то, что мы задумали.
Возможно, Firefox вам будет недостаточно и вы заходите прогнать тест в IE(для этого настроен специальный профиль):
> `mvn clean test
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Или может быть в Chrome:
> `mvn clean test -P chrome
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
### Заключение
Я не буду обременять ни себя, ни вас описанием библиотек-их есть у него в достаточном количестве на сайтах этих библиотек, а просто порекомендую забрать из репозитория проект и попробовать самостоятельно.
### Важные ссылки
* Статья, которая вдохновила меня на изучение данного вопроса [The future of functional web testing?](http://blog.springsource.com/2010/08/28/the-future-of-functional-web-testing/)
* Шикарнейший мануал по Geb: [The book of Geb](http://geb.codehaus.org/manual/latest/)
* Необычайной читабельности [mailing list'ы по Geb на MarkMail](http://markmail.org/search/?q=list%3Aorg.codehaus.geb)
* Рассмотренный проектик в [SVN](http://subversion.assembla.com/svn/archislav_public_projects/simple-func-test)
* Официальный сайт [Geb](http://geb.codehaus.org/)
* Официальный сайт [Spock](http://code.google.com/p/spock/)
* Консоль, чтобы поиграться со Spock [Spock Web Console](http://meetspock.appspot.com/?id=9001) | https://habr.com/ru/post/109077/ | null | ru | null |
# Готовим плацдарм для react-приложения
Я хочу рассказать о процессе создание платформы для react приложения, которая использует [mobx](https://github.com/mobxjs/mobx) в качестве **M**odel-и. Пройти путь от пустой директории проекта до рабочего примера. Рассмотреть основные моменты, на которые я обращал внимание в процессе разработки. Постараюсь насытить текст уточняющими ссылками, дополнительные заметки будут выделены курсивом с пометкой *«Note:»*.
Рассказ будет состоять из двух частей:
1. Готовим плацдарм для react приложения
2. Mobx + react, взгляд со стороны
Буду писать «как я вижу», поэтому предложения и замечания по улучшению приветствуются. Надеюсь, читатель знает, что такое npm, node.js и react.js, имеет базовые знания о props и state. На момент написания статьи, у меня стоит windows и нестабильная node.js 7.3.0 версии.
Готовим плацдарм для react приложения
-------------------------------------
Существуют тысячи [react skeleton-ов и boilerplate-ов](https://github.com/search?l=JavaScript&q=react+boilerplate&ref=searchresults&type=Repositories&utf8=%E2%9C%93), та что уж тут говорить, даже «fb» выпустил [свой](https://github.com/facebookincubator/create-react-app) с блекджеком и hotreload-ом. Мы же не будем использовать готовый, а соберем все своими руками и увидим, как это работает. Самостоятельно пройдем этот путь и заглянем во все темные углы, чтобы понять всю механику процесса, так же разобраться в тех деталях, которые были непонятны ранее. Я не претендую на очередной велосипед, скорее разработка ради просвещения. Переполняемые энтузиазмом, открываем консоль в любимой IDE, создаем новую директорию для проекта и переходим внутрь. Погнали!
```
npm init
```
Тут все просто, вам предложат несколько общих вопросов, после чего npm создаст для нас [package.json](https://docs.npmjs.com/files/package.json) файл управления зависимостями.
*Note: Чтобы каждый раз не заполнять информацию о себе, можно прописать*
```
npm set init.author.name "your name"
npm set init.author.email "your email"
npm set init.author.url "your site url"
```
Далее установим необходимые для работы react-а пакеты и сделаем о них запись в package.json в секции dependencies. Мы будем использовать [react-router](https://github.com/ReactTraining/react-router), поэтому сразу поставим и его:
```
npm i --save react react-dom react-router
```
Заложим структуру проекта и создадим пару директорий. В большинстве случаев требуется клиент-серверное приложение. Мне нравится иметь две отдельные директории для клиентской и серверной части, тут можно холиварить бесконечно долго, для примера я выбрал следующую структуру:
Для скелета нам понадобится:
* index.js – точка входа в клиентское приложение. Это первый файл в приложении, в который я смотрю, если вижу чужой проект в первый раз, это ниточка с которой начинаешь распутывать весь клубок;
* routes.js – настройка роутера. Для начала хватит одного роута, чтобы показать
* home.js – home page;
* index.html – мы будем делать [SPA](https://ru.wikipedia.org/wiki/%D0%9E%D0%B4%D0%BD%D0%BE%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B8%D1%87%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%B8%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5), index.html — это та единственная страничка;
**index.html**
```
```
Тут стоит обратить внимание на div#app, это контейнер для нашего будущего react приложения. Чуть позже мы добавим сюда скрипт.
**index.js**
```
import React from 'react';
import ReactDOM from 'react-dom';
import AppRouter from './routes';
ReactDOM.render(, document.getElementById("app"));
```
Рендерим в тот самый div#app.
**views/home.js es6**
```
import React from 'react';
export default class Home extends React.Component {
render() {
return (
Hello Kitty!
============
);
}
}
```
Перед роутом давайте посмотрим на домашнюю (и пока единственную) вьюшку. Это react компонент, который просто выводит надпись приветствия.
Мы будем использовать ES6 way при создании react компонент. Как подружить react с ES6, можно почитать в [документе](https://facebook.github.io/react/docs/react-without-es6.html) или [тут](https://habrahabr.ru/post/262183/) на русском. Рекомендую сразу пытаться писать на ES6, вы тут же почувствуете выгоду, тем более тема легкая для понимания.
Конечно же для удобства мы будем использовать jsx нотацию. Для того, чтобы браузер понял наш код, мы будем использовать [babel](https://babeljs.io/) транслятор, кроме того хочется идти в ногу со временем и использовать ES6/ES2015 [фичи](https://babeljs.io/learn-es2015/), но не все браузеры поддерживают этот стандарт, поэтому я опять обращусь к babel за помощью. Получается, babel – транспайлер, переписывающий код, написанный в новых стандартах, в код стандарта es5, который понимаю почти все браузеры, а также может транслировать react jsx код, в код понятный браузеру. А еще, он поддерживает кучу плагинов. Это очень круто!
*Note: Всю эту магию преобразований можно пощупать даже [онлайн.](https://babeljs.io/repl)
Попробуйте вставить любой react или es6 код и увидите во что он трансформируется, например, код из home.js*
Если вы проделали эту процедуру, то у вы могли заметить, что 9 строк react ES6 кода (~400 байт) превратились в 44! строки ES5 (~2200 байт)
Это расплата за синтаксический сахар, ведь, class-ов в javascript-e нет. Можно наблюдать как babel с легкой руки сделал из class-a функцию.
Наверно, на этом этапе нужно сказать пару строк о stateless компонентах. Грубо говоря, такими называются компоненты, у которых нет состояния. Наш Home компонент как раз не имеет состояния, поэтому мы можем переписать его как:
**stateless home.js**
```
import React from 'react';
const Home = (props) => {
return (
Hello Kitty
===========
);
};
export default App;
```
Мы избавились от class-а, поэтому этот код будет гораздо короче в конечном ES5 синтаксисе, а его объем уменьшится более чем в 5 раз. Кроме того, мы можем сделать исходный код еще лаконичнее:
**stateless home.js**
```
import React from 'react';
const Home = () => (
Hello Kitty
===========
);
export default App;
```
*Note: Мне нравится [эта](https://hackernoon.com/react-stateless-functional-components-nine-wins-you-might-have-overlooked-997b0d933dbc#.u1r0ecewm) статья на тему stateless components, рекомендую.*
**routes.js**
```
import React from 'react';
import {
Router,
Route,
browserHistory
} from 'react-router';
import Home from './views/home';
export default () => (
);
```
Наконец, в роутах пропишем только один path к Home компоненту. Тут вопросов не должно возникнуть, библиотека проста, но в тоже время обладает [мощным функционалом](https://reacttraining.com/react-router/).
Подсунуть браузеру, читаемый код – только пол дела, так как проект состоит из множества файлов, а в конечном результате нам нужен только один минимизированный js файл(который мы подключим к index.html), то нам понадобится еще и сборщик модулей. Собирать мы будем с помощью [webpack](https://webpack.github.io/).
Ставим его:
```
npm i --save-dev webpack
```
*Note: Обратите внимание, что webpack ставится в devDependencies секцию.
Все, что связано с разработкой и не будет использоваться в продукционной среде ставится с флагом --save-dev, зачастую это: сборщики и плагины к ним, тесты, линтеры, лоадеры, пост/препроцессоры и прочее.*
Как было описано выше для всех преобразований кода нам нужен babel и необходимые preset-ы(наборы плагинов) к нему:
```
npm i --save-dev babel-loader babel-core babel-preset-es2015 babel-preset-react
```
Webpack-у потребуется [файл конфигурации](https://webpack.github.io/docs/configuration.html), создадим webpack.config.js в корне директории проекта.
**webpack.config.js**
```
var webpack = require('webpack');
module.exports = {
entry: './client/index.js',
output: {
path: __dirname + '/public',
filename: 'bundle.js'
},
module: {
loaders: [
{
test: /.jsx?$/,
loader: 'babel-loader',
exclude: /node_modules/
}
]
}
};
```
Также babel рекомендует использовать .babelrc файл, тут опишем какие preset-ы мы хотим использовать.
```
{
"presets": ["es2015", "react"]
}
```
*Note: Пара полезных ссылок: [6 вещей](http://jamesknelson.com/the-six-things-you-need-to-know-about-babel-6/), которые необходимо знать о babel 6 и какая разница [в порядке объявления preset-ов](http://code.fitness/post/2015/11/babel-setting-up-.babelrc-for-babel-6.html).*
Тут мы говорим сборщику, что точка входа в наше приложение – client/index.js файл, webpack начнет свою работу с этого файла, нам не нужно указывать ему какие файлы должны войти в сборку, все это он сделает за нас сам. На выходе должен получиться один bundle.js файл в директории public. Грубо говоря, этим конфигом мы говорим babel-ю: «Эй, склей все необходимые файлы в один, начиная с index.js и позаботься о том, чтобы babel преобразовал все .js и .jsx файлы в код понятный браузерам.» Разве это не здорово? Настройка webpack-а готова, идем в консоль и запускаем сборщик:
```
webpack
```
В директории public должен появиться файл bundle.js. Public — это наша публичная директория, после билда все «готовые» файлы(для нас это index.html + bundle.js) должны попасть сюда. Бандл готов, пришло время заняться html. Тут стоит понимать, что текущий index.html — это только заготовка, в дальнейшем нам, например, нужно прицепить CSS или js файлы, минимизировать или добавить какое-то содержимое, при этом для разных сборок производить разные операции. Для этих целей нам потребуется [HtmlWebpackPlugin](https://github.com/jantimon/html-webpack-plugin). Ставим его:
```
npm i --save-dev html-webpack-plugin
```
После идем в файл конфигурации и настраиваем плагин:
**webpack.config.js**
```
var webpack = require('webpack');
var HtmlWebpackPlugin = require('html-webpack-plugin');
module.exports = {
entry: './client/index.js',
output: {
path: __dirname + '/public',
filename: 'bundle.js'
},
module: {
loaders: [
{
test: /.jsx?$/,
loader: 'babel-loader',
exclude: /node_modules/,
}
]
},
plugins: [
new HtmlWebpackPlugin({
template: './client/index.html',
inject: "body"
})
]
};
```
Этим мы говорим webpack-у, чтобы он вставил 'script' тег со ссылкой на сбилденый им bundle.js в нашу заготовку index.html. При этом «готовый» index.html будет лежать рядом с бандлом, т.е в public. Запустим webpack еще раз и убедимся в этом, проверив публичную директорию.
Давайте вернемся к нашему ба~~ра~~ндлу, который собрал нам webpack. Внимательный читатель заметит, что ~710KB многовато для 'Hello Kitty!'. Согласен, но у нас пока девелоп версия, которая предоставляет дополнительный функционал в помощь разработчику, например, показывает различные варнинги в консоли. Давайте попробуем намекнуть react-у, что мы хотим собрать проект под продукцию. Для этого нужно минимизицировать конечный bundle.js и задать NODE\_ENV переменной окружения значение «production». В конфиге добавляем плагины, при этом ничего дополнительного качать и устанавливать не нужно.
**webpack.config.js**
```
plugins: [
new webpack.DefinePlugin({
"process.env": {
NODE_ENV: JSON.stringify("production")
}
}),
new webpack.optimize.UglifyJsPlugin({
compress: {
warnings: true
}
}),
new HtmlWebpackPlugin({
template: './client/index.html',
inject: "body"
})]
```
Ознакомиться с полным списком плагинов можно [тут](https://webpack.github.io/docs/list-of-plugins.html).
*Note: Если не задать NODE\_ENV=production, а просто сжать файл, то react покажет предупреждение в консоли:
*
Пересоберем проект с использованием плагинов и вновь посмотрим на наш свежий бандл.
С этим уже можно работать, но это еще не предел, давайте посмотрим на еще одну настройку конфигурации webpack-а — "[devtool](https://webpack.github.io/docs/configuration.html#devtool)". Эта опция также влияет на размер конечного файла и скорость сборки. Поэтому мы будем использовать разные значения для продукции и девелопа. [Тут](https://webpack.js.org/configuration/devtool/) можно почитать как работает каждая опция. Для себя я выбрал «source-map» для продакшена и «inline-source-map» для девелопа, хотя, наверно, для разных проектов эти значения могут варьироваться. Тут нужно поиграть и выбрать оптимальное для себя.
Настало время изменить файл конфигурации, ведь теперь мы с лёгкостью можем собирать наш проект под разные нужды, мне не нравится решение, когда в одном конфиге через условия регулируются настройки. При увеличении настроек и/или типов сборок, конфиг становится тяжело читаем, поэтому будем использовать [webpack-config](https://www.npmjs.com/package/webpack-config).
```
npm install --save-dev webpack-config
```
Как видно из описания — это помощник для загрузки, расширения и мерджа конфигурационных файлов. В данном примере я бы хотел иметь возможность делать две сборки: development и production. Добавим директорию conf и три конфига, как показано на рисунке:
**webpack.base.config.js**
```
import Config from 'webpack-config';
import HtmlWebpackPlugin from 'html-webpack-plugin';
export default new Config().merge({
entry: './client/index.js',
output: {
path: __dirname + '/../public',
},
module: {
loaders: [
{
test: /.jsx?$/,
loader: 'babel-loader',
exclude: /node_modules/,
}
]
},
plugins: [
new HtmlWebpackPlugin({
template: './client/index.html',
inject: "body"
})]
});
```
В базовом конфиге находятся общие настройки, которые справедливы для двух сборок.
**webpack.development.config.js**
```
import Config from 'webpack-config';
export default new Config().extend('conf/webpack.base.config.js').merge({
output: {
filename: 'bundle.js'
}
});
```
В development конфиге мы указываем лишь имя конечного бандла — 'bundle.js'
**webpack.production.config.js**
```
import webpack from 'webpack';
import Config from 'webpack-config';
export default new Config().extend('conf/webpack.base.config.js').merge({
output: {
filename: 'bundle.min.js'
},
plugins: [
new webpack.optimize.UglifyJsPlugin({
compress: {
warnings: true
}
})]
});
```
Для production, мы добавляем плагин для минимизации, а так же меняем имя бандла. Как видно оба конфига расширяются от базового.
**webpack.config.js**
```
import Config, { environment } from 'webpack-config';
environment.setAll({
env: () => process.env.NODE_ENV
});
export default new Config().extend('conf/webpack.[env].config.js');
```
Теперь мы можем управлять сборками с помощью переменной среды NODE\_ENV, в зависимости от её значения, webpack-config будет автоматически подтягивать нужный файл.
*Note: webpack.config.js использует ES6 синтаксис, поэтому при попытке запустить webpack, вы увидите ошибку «SyntaxError: Unexpected token import». Для решения проблемы достаточно переименовать данный файл в webpack.config.babel.js. Этим мы пропускаем конфиг через babel-loader.*
Добавим необходимые скрипты запуска webpack-а в package.json в секцию [scripts](https://docs.npmjs.com/misc/scripts):
```
"scripts": {
"build-dev": "set NODE_ENV=development&& webpack --progress",
"build-prod": "set NODE_ENV=production&& webpack --progress"
},
```
С флагом *--progress* можно видеть прогресс выполнения и отчет по бандлам. Теперь мы можем собирать две разные сборки; для продукции:
```
npm run build-prod
```
и для разработки:
```
npm run build-dev
```
*Note: Я работаю в windows, поэтому присвоение выглядит так «set NODE\_ENV=production». Для других ОС присвоение выглядит по-другому.*
Остался последний штрих — hot loader. Эта штука позволяет пересобирать проект на лету при изменении в исходных файлах. При этом страница не будет перезагружена и состояния не буду потеряны. Это в разы ускоряет разработку, а процесс девелопинга превращается в наслаждение. Подробнее можно послушать в [этом подкасте](http://5minreact.ru/3-hot-module-replacement-or-react-hot-loader/), так же там есть ссылки на интересные ресурсы по данной теме.
Для этого нам понадобятся: [react-hot-loader](https://github.com/gaearon/react-hot-loader), [webpack-dev-middleware](https://github.com/webpack/webpack-dev-middleware) и [webpack-hot-middleware](https://github.com/glenjamin/webpack-hot-middleware) и, конечно же, сам сервер, будем использовать [express](http://expressjs.com/).
```
npm i --save express
```
```
npm i --save-dev react-hot-loader@next webpack-dev-middleware webpack-hot-middleware
```
*Note: Обратите внимание, что необходимо установить react-hot-loader [next](https://habrahabr.ru/users/next/) версии.*
Добавим в корень проекта файл
**server.js**
```
import express from 'express';
import path from 'path';
const PORT = 7700;
const PUBLIC_PATH = __dirname + '/public';
const app = express();
const isDevelopment = process.env.NODE_ENV === 'development';
if (isDevelopment) {
const webpack = require('webpack');
const webpackConfig = require('./webpack.config.babel').default;
const compiler = webpack(webpackConfig);
app.use(require('webpack-dev-middleware')(compiler, {
hot: true,
stats: {
colors: true
}
}));
app.use(require('webpack-hot-middleware')(compiler));
} else {
app.use(express.static(PUBLIC_PATH));
}
app.all("*", function(req, res) {
res.sendFile(path.resolve(PUBLIC_PATH, 'index.html'));
});
app.listen(PORT, function() {
console.log('Listening on port ' + PORT + '...');
});
```
Минимальный express сервер, единственный нюанс — это настройка [middleware](http://expressjs.com/ru/guide/using-middleware.html) для development сборки. Как видно данные для middleware берутся из webpack.config.babel
Следующим шагом добавляем в .babelrc секцию plugins
```
"plugins": [
"react-hot-loader/babel"
]
```
Конфигурационный файл для development теперь выглядит так:
**webpack.development.config.js**
```
import webpack from 'webpack';
import Config from 'webpack-config';
export default new Config().extend('conf/webpack.base.config.js').merge({
entry: [
'webpack-hot-middleware/client?reload=true',
'react-hot-loader/patch',
__dirname + '/../client/index.js'
],
devtool: 'inline-source-map',
output: {
filename: 'bundle.js'
},
plugins: [
new webpack.HotModuleReplacementPlugin()
]
});
```
Также изменения претерпел
**index.js**
```
import React from 'react';
import { AppContainer } from 'react-hot-loader';
import ReactDOM from 'react-dom';
import AppRouter from './routes';
const render = (Component) =>
ReactDOM.render(
,
document.getElementById('app')
);
render(AppRouter);
if (module.hot) {
module.hot.accept('./routes', () => {
require('./routes');
render(AppRouter);
});
}
```
И, наконец, скрипты в package.json должны выглядеть так
```
"scripts": {
"build-dev": "set NODE_ENV=development&& node server.js",
"build-prod": "set NODE_ENV=production&& webpack && node server.js"
},
```
*Note: если вы попробуете запустить скрипт, то опять увидите ошибку «SyntaxError: Unexpected token import». Потому что, server.js использует ES6 import-ы и пытается прочитать webpack.config.babel.js, в котором тоже используются import-ы. А поддержку обещают только в 8й версии. Потребуется babel для командной строки [babel-cli](https://babeljs.io/docs/usage/cli/):*
```
npm i --save-dev babel-cli
```
Будем использовать babel-node, вместо node, всё должно работать:
```
"scripts": {
"build-dev": "set NODE_ENV=development&& babel-node server.js",
"build-prod": "set NODE_ENV=production&& webpack && babel-node server.js"
},
```
Пробуем собрать обе сборки, при этом для production, соберется минимизированный bundle.min.js и запустится сервер на 7700 порте, а для development будет работать горячая перезагрузка, при этом вы не увидите никаких файлов в public директории, весь процесс будет проходить in memory. Для теста усложним код home.js
**home.js**
```
import React from 'react';
export default class Home extends React.Component {
constructor() {
super();
this.state = { name: "Kitty" };
this.clickHandler = this.clickHandler.bind(this);
}
clickHandler() {
this.setState({ name: "Bunny" });
}
render() {
return (
{`Hello ${this.state.name}!`}
===============================
);
}
}
```
Кстати, если вы запустили development сборку, то все изменения должны подтянуться сразу. Давайте кликнем по заголовку, тем самым изменим состояние name с «Kitty» на «Bunny», далее в коде заменим текст в заголовке с «Hello» на «Bye». Перейдем в браузер и увидим надпись «Bye Bunny», т.е. горячая перезагрузка сработала, при этом измененное состояние не сбросилось.
Сначала не хотел добавлять работу с CSS, но в процессе написания статьи понял, что все таки для полного комплекта нужно добавить процесс сборки стилей.
Наверно, у каждого был случай, когда правишь верстку в одном месте и незаметно для себя создаешь новую проблему в другом, стили перезатирают друг друга или используется одинаковые классы, которые были описаны выше. Мы будем писать react компоненты, так почему бы нам сразу и не использовать CSS для компонентов, а не глобально? Будем использовать [CSS модули](http://javascriptplayground.com/blog/2016/07/css-modules-webpack-react/)! Нам понадобится [post-css](https://github.com/postcss/postcss) и его [плагины](https://github.com/postcss/postcss/blob/master/docs/plugins.md). Для начала нам будут интересны [autoprefixer](https://github.com/postcss/autoprefixer) и [precss](https://github.com/jonathantneal/precss) для ускорения разработки, устанавливаем:
```
npm i --save-dev css-loader style-loader postcss-loader autoprefixer precss
```
Делаем изменения в конфигах
**webpack.base.config.js**
```
import webpack from 'webpack';
import Config from 'webpack-config';
import HtmlWebpackPlugin from 'html-webpack-plugin';
import autoprefixer from 'autoprefixer';
import precss from 'precss';
export default new Config().merge({
entry: './client/index.js',
output: {
path: __dirname + '/../public',
},
module: {
loaders: [
{
test: /.jsx?$/,
loader: 'babel-loader',
exclude: /node_modules/,
}
]
},
plugins: [
new HtmlWebpackPlugin({
template: './client/index.html',
inject: "body"
}),
new webpack.LoaderOptionsPlugin({ options: { postcss: [precss, autoprefixer] } })
]
});
```
**webpack.development.config.js**
```
import webpack from 'webpack';
import Config from 'webpack-config';
export default new Config().extend('conf/webpack.base.config.js').merge({
entry: [
'webpack-hot-middleware/client?reload=true',
'react-hot-loader/patch',
__dirname + '/../client/index.js'
],
devtool: 'inline-source-map',
output: {
filename: 'bundle.js'
},
module: {
loaders: [{
test: /\.css$/,
use: [
'style-loader',
{
loader: 'css-loader',
options: {
modules: true,
importLoaders: 1,
localIdentName: "[local]__[hash:base64:5]",
minimize: false
}
},
{ loader: 'postcss-loader' },
]
}]
},
plugins: [
new webpack.HotModuleReplacementPlugin()
]
});
```
**webpack.production.config.js**
```
import webpack from 'webpack';
import Config from 'webpack-config';
export default new Config().extend('conf/webpack.base.config.js').merge({
output: {
filename: 'bundle.min.js'
},
devtool: 'source-map',
module: {
loaders: [{
test: /\.css$/,
use: [
'style-loader',
{
loader: 'css-loader',
options: {
modules: true,
importLoaders: 1,
localIdentName: "[hash:base64:10]",
minimize: true
}
},
{ loader: 'postcss-loader' },
]
}]
},
plugins: [
new webpack.optimize.UglifyJsPlugin({
compress: {
warnings: true
}
})]
});
```
В базовый конфиг добавляем плагин, для остальных добавляем лоадеры, отличаются только настройки. Тут буден интересна localIdentName опция, она позволяет задавать имена CSS классам, для продукционной версии будем использовать хэш из 10 символов, для девелоп — названия классов + хэш из 5 символов. Это очень удобно, т.к при дебаге ты всегда знаешь какой класс тебе нужно поправить. Для примера давайте добавим Menu компонент:
**Структура проекта**
**menu/index.js**
```
import React from 'react';
import styles from './style.css';
const Menu = () => (
☰
);
export default Menu;
```
Обратите внимание, как используется css модуль. Это локальные стили, т.е для другого меню, мы так же можем использовать класс .menu с другими стилями, и они не пересекутся.
**menu/style.css**
```
.menu {
position: fixed;
top: 0;
left: 0;
bottom: 0;
width: 40px;
background-color: tomato;
& .toggle-btn {
position: absolute;
top: 5px;
right: 10px;
font-size: 26px;
font-weight: 500;
color: white;
cursor: pointer;
}
}
```
**app.js**
```
import React from 'react';
import Menu from '../components/menu';
// Global CSS styles
import './global.css';
const App = () => (
);
export default App;
```
Но мы так же можем использовать и «глобальные» стили, например, для html и body. Достаточно подключить их app.js.
**routes.js**
```
import React from 'react';
import {
Router,
Route,
browserHistory
} from 'react-router';
import App from './views/app';
import Home from './views/home';
export default () => (
);
```
Добавим немного вложенности, теперь у нас есть App контейнер со вложенной Home страницей.
Настройки webpack-а также позволят использовать горячую перезагрузку для стилей, просто попробуйте сделать некоторые изменения в стилях.
На этом первая часть закончилась. Я не претендую на самый-самый правильный вариант, но я прошёл этот путь и почерпнуть несколько интересных вещей, пока писал эту статью, надеюсь она окажется чем-то полезным и другим.
Ссылка на то, что получилось: [github.com/AlexeyRyashencev/react-hot-mobx-es6](https://github.com/AlexeyRyashencev/react-hot-mobx-es6) | https://habr.com/ru/post/324232/ | null | ru | null |
# Понятие песочницы при разработке расширений для браузера Google Chrome
За 5 лет разработки расширений для браузера Google Chrome накопился некоторый опыт, которым хотелось бы поделиться в цикле статей и, по возможности, пояснить некоторые тонкости, подводные камни, а также описать как были удачно применены современные фронтенд-технологии.
### Часть 1.
#### Введение
С расширениями для браузера Google Chrome я столкнулся в 2012-м году когда активно покупал товары с витрины Amazon и было там жутко неудобно искать продавцов, которые доставляли товар в РФ и у кого выгоднее всего покупать с учетом стоимости доставки. Вот тут я и решил облегчить жизнь себе, да и другим покупателям тоже, создав расширение «Amazon ships to you”, про которое была даже когда-то [статья на Хабре](https://habrahabr.ru/post/196484/). Со временем оно стало не актуально, т.к. на витрине Amazon сделали спустя пару лет нормальные фильтры и я его снял с публикации.
Далее наступило время пользования сервисом [Я.Музыка](https://music.yandex.ru) и [Я.Радио](https://radio.yandex.ru) и очень уж мне не хватало управления плеером на сайте Я.Музыки когда он играет в фоновой вкладке, ну хотя бы горячими клавишами. В результате, я, как человек опытный, не найдя аналогов, решил сделать для этого [расширение “Яндекс.Музыка — управление плеером»](https://chrome.google.com/webstore/detail/%D1%8F%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%D0%BC%D1%83%D0%B7%D1%8B%D0%BA%D0%B0-%D1%83%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5-%D0%BF/gcfheefljlblchcfjlknidfimnfillec), которое является моим хобби и по сей день, несмотря даже на выход [официального расширения от Яндекса](https://chrome.google.com/webstore/detail/%D1%8F%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%D0%BC%D1%83%D0%B7%D1%8B%D0%BA%D0%B0/kefiofndeiobnlbabkhfkfmgdhmhhfmc).
Предполагается, что читатель должен быть уже знаком с базовой структурой элементов расширения ([manifest.json](https://developer.chrome.com/extensions/manifest), [фоновая страница](https://developer.chrome.com/extensions/event_pages), [контент-скрипт](https://developer.chrome.com/extensions/content_scripts), [попап](https://developer.chrome.com/extensions/browserAction#popups)). Краткий ликбез под спойлером ниже.
**Ликбез по расширениям**Расширение — это программный пакет, расширяющий функционал браузера. Распространяется через официальный [Chrome Web Store](https://chrome.google.com/webstore/), также можно загрузить локальное расширение в режиме разработчика на странице [chrome://extensions/](http://chrome://extensions/), однако с ними Google борется всё больше закручивая гайки.
> Раньше можно было локальными расширениями пользоваться без проблем, затем браузер начал оповещать уведомлением о наличии таких расширений, теперь же подобные расширения по умолчанию отключаются при запуске браузера и их надо активировать вручную (что немало насолило разработчикам расширений при активной разработке).
>
>
Все метаданные расширения описываются в манифесте, но о нем нечего особо сказать, в [документации](https://developer.chrome.com/extensions/manifest) все описано.
[Расширение](https://developer.chrome.com/extensions) состоит из фоновой страницы ([background page](https://developer.chrome.com/extensions/background_pages) или [event page](https://developer.chrome.com/extensions/event_pages)), [всплывающего окна](https://developer.chrome.com/extensions/browserAction#popups), [страницы настроек](https://developer.chrome.com/extensions/options), внедряемого на целевой сайт [контент-скрипта](https://developer.chrome.com/extensions/content_scripts) и специфических [override pages](https://developer.chrome.com/extensions/override), которые переопределяют стандартные страницы браузера: менеджер истории, закладок, новая страница и т.п.
С точки зрения UI, расширение содержит элемент [browserAction](https://developer.chrome.com/extensions/browserAction) (или [pageAction](https://developer.chrome.com/extensions/pageAction)) — иконку на панели браузера справа от адресной строки, нажатие на которую может инициировать какое-либо действие или же открывает еще один UI элемент — [всплывающее окно](https://developer.chrome.com/extensions/browserAction#popups). Также на этой иконке можно выводить [badge](https://developer.chrome.com/extensions/browserAction#badge) — значок, например, с количеством непрочитанных писем.
Браузер предоставляет расширениям множественные [API](https://developer.chrome.com/extensions/api_index) для различных нужд, например через [chrome.tabs](https://developer.chrome.com/extensions/tabs) API можно получить доступ ко всем вкладкам, закрывать, открывать новые, видеть метаданные вкладок и т.п.
Плюс к этому, между различными страницами расширения есть определенные [механизмы передачи данных](https://developer.chrome.com/extensions/messaging).
#### Песочницы
Типовая задача расширения — расширение функционала некоторого сайта, для чего необходимо внедрить код на целевую страницу. Возьмем для примера Я.Музыку (здесь и далее): для управления плеером на сайте через всплывающее окно расширения (см. скриншот №1), нам необходимо отследить открытие страницы, затем внедрить в нее наш код, который в дальнейшем будет взаимодействовать с js-кодом и DOM витрины и передавать все изменения в расширение, чтобы при открытии всплывающего окна всегда отображать актуальное состояние плеера на витрине. Вот тут и появляется то важное, о чем я хотел бы для начала рассказать и о чем гласит название раздела: **песочницы**.
(скриншот №1)
Фоновая страница расширения, являясь основным контроллером расширения, при наличии должных расширений ([tabs, activeTab](https://developer.chrome.com/extensions/declare_permissions)) может отследить открытие страницы [music.yandex.ru](https://music.yandex.ru) используя [chrome.tabs.onUpdated](https://developer.chrome.com/extensions/tabs#event-onUpdated) и внедрить наш код (контент-скрипт) на витрину через [chrome.tabs.executeScript](https://developer.chrome.com/extensions/tabs#method-executeScript). Однако, внедренный код оказывается в своей песочнице (Б), из которой есть доступ к DOM-документу витрины, но не к js-коду витрины, который выполняется в своей песочнице (А). В теории можно было бы отслеживать изменения DOM-элементов на витрине чтобы транслировать текущее состояние в расширение (например, изменился трек — взять из DOM название трека, исполнителя), но это все работает не так как хотелось бы: с задержками на обновление витрины, не всегда присутствующими целевыми DOM-элементами в текущем отображении витрины и прочими вещами, которые в реальном использовании расширения дают рассинхронизацию данных между витриной и отображением в расширении. Как же нам получить доступ к js-коду витрины (песочнице А)?
Для внедрения js-кода в песочницу А из контент-скрипта нам может помочь следующий “хак” (здесь и далее нотация es6):
```
function injectCode(func, ...args) {
let script = document.createElement('script');
script.textContent = 'try {(' + func + ')(' + args + '); } catch(e) {console.error("injected error", e);};';
(document.head || document.documentElement).appendChild(script);
script.parentNode.removeChild(script);
}
```
В результате наш контент-скрипт может внедрить свой код в песочницу js-кода витрины для того, чтобы получить доступ к API витрины и на низком уровне иметь доступ к объектам и событиям плеера, плейлиста и прочих сущностей витрины. Но это еще не всё: доступ к API получен, к примеру, событие начала проигрывания трека наш внедренный код “поймал”, но как же его передать обратно в контент-скрипт, который, в свою очередь, имеет механизмы передачи данных на фоновую страницу расширения?
Увы, доступа из песочницы А в песочницу Б нет, во всяком случае, мне он неизвестен. Но это не страшно, потому что мы помним к чему имеет доступ контент-скрипт из своей песочницы Б: к DOM-документу витрины, отсюда выход: внедренный в песочницу А код может создавать произвольные события:
```
document.dispatchEvent(new CustomEvent(CUSTOM_EVENT_NAME, {detail: payload}));
```
А контент-скрипт может их ловить:
```
document.addEventListener(CUSTOM_EVENT_NAME, e => {
console.log(e.detail); //payload
});
```
Получается такая схема:
После этого, контент-скрипт передает это событие на фоновую страницу одним из механизмов: [chrome.runtime.sendMessage](https://developer.chrome.com/extensions/runtime#method-sendMessage) или [chrome.runtime.connect](https://developer.chrome.com/extensions/runtime#method-connect). Отличие их в том, что первый метод открывает канал, передает данные, закрывает канал, второй же создает постоянный канал, в рамках которого происходит передача данных. При проигрывании треков идет постоянная передача событий progress (текущее время проигрывания), посему для меня стал выбор очевиден: поднимать постоянный канал связи контент-скрипта с фоновой страницей, что дает еще один не очевидный бонус: контроль потери связи с витриной по различным причинам, от исключений в js-коде до закрытия вкладки (хотя именно закрытие вкладки легко отслеживается через [chrome.tabs.onRemoved](https://developer.chrome.com/extensions/tabs#event-onRemoved)).
С данными песочницами закончили, но это еще не всё: есть еще песочница (В) фоновой страницы и песочница (Г) всплывающего окна. Тут все немного проще, данные песочницы имеют доступ друг к другу через API:
* из всплывающего окна можно получить к фоновой странице доступ через [chrome.extension.getBackgroundPage()](https://developer.chrome.com/extensions/extension#method-getBackgroundPage)
* из фоновой страницу к всплывающему окну можно получить доступ через [chrome.extension.getViews({ type: 'popup' })](https://developer.chrome.com/extensions/extension#method-getViews)
Но тут есть подводный камень: всплывающее окно не может, например, добавить свой слушатель событий на фоновую страницу, но к объекту window друг друга вышеописанные методы доступ дают (т.к. они запущены в одном потоке). Для единообразия интеркоммуникаций и для принудительной изоляции кода фоновой страницы от кода всплывающего окна (иначе popup может модифицировать объекты bg, что нарушит однонаправленный поток данных из контент-скрипта на фоновую страницу для хранения актуального состояния и оттуда во всплывающее окно), я перешел к такому же поднятию канала как и между контент-скриптом и фоновой страницей.
Кода и примеров мало, т.к. всё есть в документации, на которую я максимально ссылаюсь при любых упоминаниях методов и API, в части кода мне добавить тут нечего, т.к. на статус туториала (когда можно скопипастить весь код и что-то заработает) — не претендую. А вот саму концепцию разжевать стоило, т.к. неоднократно коллегам по программистскому цеху объяснял оную. Резюмировать можно раздел следующей иллюстрацией:
В следующей части я планирую рассказать об истории перевода расширения [“Яндекс.Музыка — управление плеером"](https://chrome.google.com/webstore/detail/%D1%8F%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%D0%BC%D1%83%D0%B7%D1%8B%D0%BA%D0%B0-%D1%83%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5-%D0%BF/gcfheefljlblchcfjlknidfimnfillec) на нынче популярный React+Redux, который, как нельзя, кстати, подошел для отображения состояния плеера во всплывающем окне расширения. | https://habr.com/ru/post/312290/ | null | ru | null |
# Как установить Kubernetes на сервер Ubuntu без Docker
Kubernetes прекращает поддержку Docker. Теперь, вся тяжелая работа, которую вы вложили в изучение, сильно изменится. Даже с самого начала пути использование Kubernetes не будет прежним.
Я говорю о самой установке инструмента управления контейнерами. Вы, конечно, не можете развернуть Kubernetes так же, как когда-то — установив Docker в качестве среды выполнения.
Вместе мы сейчас попробуем установить Kubernetes на Ubuntu Server 20.04 без Docker-а.
Что вам понадобится
-------------------
* Пользователь с привилегиями sudo
* Экземпляр Ubuntu Server 20.04 (он будет служить Контроллером — вам понадобятся другие экземпляры для работы в качестве узлов, но я собираюсь продемонстрировать только на Контроллере, так как установка будет одинаковой на всех машинах)
Как установить среду выполнения containerd
------------------------------------------
Первое, что мы сделаем, это установим среду выполнения containerd, которая займет место Docker. Войдите в свой экземпляр Ubuntu Server и обязательно обновите apt с помощью команды:
```
sudo apt-get update
```
После этого вы должны запустить обновление с помощью команды:
```
sudo apt-get upgrade -y
```
Если ядро обновляется, вам нужно перезагрузить сервер (если у вас не установлен и не запущен Live Patch).
Установите containerd с помощью команды:
```
sudo apt-get install containerd -y
```
Настройте containerd и запустите службу с помощью команд:
```
sudo mkdir -p /etc/containerd
sudo su -
containerd config default /etc/containerd/config.toml
```
### Как установить Kubernetes
Далее мы установим Kubernetes. Сначала нужно добавить ключ GPG репозитория с помощью команды:
```
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add
```
Добавьте репозиторий Kubernetes с помощью команды:
```
sudo apt-add-repository "deb http://apt.kubernetes.io/ kubernetes-xenial main"
```
Теперь вы можете установить все необходимые компоненты Kubernetes с помощью команды:
```
sudo apt-get install kubeadm kubelet kubectl –y
```
### Как решить несколько проблем, возникших с containerd
Здесь все становится немного сложнее. В Docker было решено множество внутренних вещей. Когда вы переходите на containerd, вам нужно внести некоторые изменения в конфигурацию вручную.
Первое изменение — добавить строку в /etc/sysctl.conf. Откройте файл командой:
```
sudo nano /etc/sysctl.conf
```
Открыв этот файл, добавьте снизу следующее:
```
net.bridge.bridge-nf-call-iptables = 1
```
Сохраните и закройте файл.
Затем введите команды:
```
sudo -s
echo '1' > /proc/sys/net/ipv4/ip_forward
exit
```
Перезагрузите конфигурации с помощью команды:
```
sudo sysctl --system
```
Вам также потребуется загрузить пару необходимых модулей с помощью команд:
```
sudo modprobe overlay
sudo modprobe br_netfilter
```
Как только вы позаботитесь об этом, то сможете инициализировать Kubernetes.
#### Как завершить настройку
Вам нужно будет отобразить все ваши узлы в / etc / hosts. Убедитесь, что отображение имеет форму:
```
IP Address hostname
```
Следующим шагом является установка имени хоста вашего контроллера (убедитесь, что оно соответствует имени хоста, которое вы использовали в / etc / hosts) с помощью команды:
```
sudo hostnamectl set-hostname HOSTNAME
```
Где HOSTNAME — это имя хоста, которое вы хотите использовать.
Отключите свопинг, открыв файл fstab для редактирования командой:
```
sudo nano /etc/fstab
```
В этом файле закомментируйте (добавив символ # в начало строки) запись, которая начинается с:
```
/swap.img
```
Эта строка теперь будет начинаться с:
```
# / swap.img
```
Сохраните и закройте файл.
Отключите своп командой:
```
sudo swapoff -a
```
Вытащите необходимые контейнеры командой:
```
sudo kubeadm config images pull
```
На контроллере инициализируйте Kubernetes с помощью команды:
```
sudo kubeadm init --pod-network-cidr=IPADDRESS/24
```
Где IPADDRESS — это IP-адрес вашего контроллера.
В конечном итоге вы вернетесь к команде, которую нужно запустить на ваших узлах, чтобы они могли подключиться к кластеру. Скопируйте эту команду.
Прежде чем вы сможете присоединить узлы к кластеру, вам нужно позаботиться о еще нескольких битах в кластере.
На контроллере создайте каталог кластера с помощью команды:
```
mkdir -p $HOME / .kube
```
Скопируйте файл конфигурации в этот каталог с помощью команды:
```
sudo cp -i /etc/kubernetes/admin.conf $HOME / .kube / config
```
Дайте конфигурационному файлу соответствующие разрешения с помощью команды:
```
sudo chown $(id -u):$(id -g) $HOME/.kube/config
```
Разверните сеть контейнеров (в данном случае мы будем использовать weave-net) в кластере с помощью команды:
```
kubectl apply -f "https://cloud.weave.works/k8s/net?k8s-version=$(kubectl version | base64 | tr -d '\n')"
```
Теперь вы можете запустить команду соединения на каждом из узлов, чтобы завершить работу кластера.
Процесс не так прост, как раньше. Надеюсь, что в будущем развертывание кластера Kubernetes будет таким же простым, как и при использовании Docker. | https://habr.com/ru/post/542042/ | null | ru | null |
# Вторая жизнь старых стрелочных индикаторов
Как-то попались мне в руки старые стрелочные индикаторы уровня от старого магнитофона, и я решил вдохнуть в них новую жизнь, сделав из них «хардварные виджеты» для отображения загрузки процессора и оперативной памяти компьютера.
[](https://habrastorage.org/getpro/habr/post_images/281/897/831/28189783162b22d1937971ec66cb47d5.jpg)
Скажу сразу, что на оригинальность я не претендую, наверняка до меня уже делали подобное, просто хочется рассказать о своём опыте.
Первым делом я заменил оригинальные шкалы с децибелами на свои собственные, для этого пришлось ломать корпус.
Затем на скорую руку я развёл плату:
В центре микроконтроллер ATMEGA8, именно он управляет стрелками, используя аппаратный ШИМ. Чтобы индикатор зашкалило, достаточно вполне небольшого тока, поэтому включаем их через резистор в пару килоом. Встроенной подсветки у индикаторов нет, поэтому чтобы они смотрелись красиво, и их было видно и в темноте, на плате я разместил по три оранжевых светодиода на том месте, поверх которого я планировал их приклеить. При этом светодиоды можно включать программно, в теории можно даже менять их яркость, используя уже софтварный ШИМ.
Подключать устройство к компьютеру было решено через USB, для этого используется микросхема FT232. Да, можно обойтись и без неё, используя программный USB, но я ему не доверяю — работает весьма нестабильно на некоторых контроллерах. Через FT232 же устройство видится как виртуальный COM-порт, в который мы будем писать данные.
Первым делом в микроконтроллер был зашит бутлоадер, после чего программатор был убран в ящик — прошивку стало легко обновлять прямо по USB. Настал этот сладкий момент, когда устройство готово, и остаётся только написать софт.
Прошивка же предельно проста:
```
// Ноги, которые подключены к индикаторам, настраиваем на вывод
DDRB |= (1<<1) | (1<<2);
// Включаем таймер и ШИМ:
TCCR1A |= (1<
```
После этого просто пишем в регистры OCR1A и OCR1B значения, которые нужно показать, а именно — то, что получаем по USART. Опытным путём было установлено, что стрелка стоит на максимальном значении, когда в регистрах число более 90. Дальше дело было за простой математикой.
Приложение для PC тоже не отличается особой сложностью — нужно просто получать процент загрузки процессора с памятью и посылать эти данные в виртуальный COM порт.
Сначала я хотел встроить эти индикаторы прямо в пятидюймовый отсек на системном блоке, но он стоит под столом, поэтому устройство было вынесено отдельно.
Стрелочки очень красиво подёргиваются. Получилось весьма удобно.
upd:
Попытался снять небольшое видео. | https://habr.com/ru/post/206150/ | null | ru | null |
# Работа с графикой на языке Rust
Всем привет! Меня зовут Саша и я backend разработчик. Нет, не на rust. Но раст мой любимый язык и недавно я задался целью портировать движок онлайн игры, написанный на C++. Первый месяц ушел на то, чтобы разобраться с бинарными ассетами, их чтением и управлением. Но статья будет не об этом, а о *WGPU*.
Что такое WGPU?
---------------
[WGPU](https://github.com/gfx-rs/wgpu) это реализация спецификации *WebGPU* на языке *rust*, целью которой является предоставить более безопасный и удобный доступ к функционалу видео карты из браузера (замена *webgl*).Во многом, API перекликается с таковым у Vulkan API, предоставляя также возможность *трансляции* в другие backend-ы (*DirectX*, *Metal*, *Vulkan, OpenGL*).
Я решил разобраться в теме рендеринга 3D сцен, поэтому решил записать цикл уроков по этой теме. Во многом это будет перевод официального [туториала](https://sotrh.github.io/learn-wgpu/#what-is-wgpu) по *wgpu* + мои комментарии.
Приступим!
----------
Я поделил исходный материал на условные уроки и первым из них будет урок по созданию окна. Так как они не очень большие, в этой статье я объединил 3 урока.
Как правило, любая игра начинается с окна, именно в нем в дальнейшем можно отрисовывать результаты работы видеокарты.
Сделайте новый проект с помощью *cargo*:
```
cargo new rust_wgpu_tutorial --bin
```
Я буду использовать следующие зависимости:
```
[dependencies]
winit = "0.26"
env_logger = "0.9"
log = "0.4"
wgpu = "0.13"
```
Теперь сам код:
```
use winit::{
event::*,
event_loop::{ControlFlow, EventLoop},
window::WindowBuilder,
};
fn main() {
env_logger::init();
let event_loop = EventLoop::new();
let window = WindowBuilder::new().build(&event_loop).unwrap();
event_loop.run(move |event, _, control_flow| match event {
Event::WindowEvent {
ref event,
window_id,
} if window_id == window.id() => match event {
WindowEvent::CloseRequested | WindowEvent::KeyboardInput {
input:
KeyboardInput {
state: ElementState::Pressed,
virtual_keycode: Some(VirtualKeyCode::Escape),
..
},
..
} => *control_flow = ControlFlow::Exit,
_ => {}
},
_ => {}
});
}
```
Помимо самого окна я добавил еще логгер, чтобы в дальнейшем видеть детализацию ошибок *wgpu*, если они произойдут. Если вы работали с растом, то этот код не вызывает много вопросов, кроме разве что конструкции внутри `match`. Там говорится следующее: для всех событий в `event_loop`, отбери только те, которые относятся к текущему окну. Если событие `WindowEvent::CloseRequested`, либо `WindowEvent::KeyboardInput`, тогда происходит деструктуризация структуры `KeyboardInput`. Если поле `virtual_keycode` внутри равно `Some(VirtualKeyCode::Escape)`, тогда установи событие `ControlFlow::Exit` (закрой окно). Напоминает продвинутый pattern-matching в *haskell*. Вот за что я люблю *rust*.
Отлично, окно отображается! Сделаем небольшой рефакторинг, добавив файл `state.rs` в папку `src`, со следующим содержимым:
```
use winit::window::Window;
use winit::{
event::*,
};
pub struct State {
surface: wgpu::Surface,
device: wgpu::Device,
queue: wgpu::Queue,
config: wgpu::SurfaceConfiguration,
size: winit::dpi::PhysicalSize,
}
impl State {
pub async fn new(window: &Window) -> Self {
todo!()
}
pub fn resize(&mut self, new\_size: winit::dpi::PhysicalSize) {
todo!()
}
pub fn input(&mut self, event: &WindowEvent) -> bool {
todo!()
}
pub fn update(&mut self) {
todo!()
}
pub fn render(&mut self) -> Result<(), wgpu::SurfaceError> {
todo!()
}
}
```
Начнем реализацию с метода `new`:
```
async fn new(window: &Window) -> Self {
let size = window.inner_size();
// instance - объект для работы с wgpu
// Backends::all => OpenGL + Vulkan + Metal + DX12 + Browser WebGPU
let instance = wgpu::Instance::new(wgpu::Backends::all());
let surface = unsafe { instance.create_surface(window) };
let adapter = instance.request_adapter(
&wgpu::RequestAdapterOptions {
power_preference: wgpu::PowerPreference::LowPower,
compatible_surface: Some(&surface),
force_fallback_adapter: false,
},
).await.unwrap();
}
```
#### Instance и Adapter
Для работы с видеокартой нам понадобиться `Adapter` и `Surface`, которые можно создать через методы `instance`. Мне нравится, что прежде чем работать с видеокартой, нужно создать `instance`, а не работать с глобальным изменяемым состоянием, как это делается в *OpenGL*, например.
При выборе адаптера, мы руководствуемся следующими опциями:
* `power_preference` в этом свойстве можно задать приоритет выбора *GPU*. При выборе `LowPower`, *wgpu* выберет интегрированную видеокарту.
* `compatible_surface` проверяем совместимость адаптера с созданным окном.
* `force_fallback_adapter` если этот флаг установлен в `true`, *wgpu* выберет адаптер, который с больше долей вероятности будет работать на любом железе, предпочтение будет отдано интегрированной карте
#### Surface
`Surface` это область окна (как *canvas* в *html*), которая будет использоваться для отрисовки. Чтобы получить `surface`, окно должно реализовать `HasRawWindowHandle` из пакета [raw-window-handle](https://crates.io/crates/raw-window-handle). В нашем случае, `winit` подходит под эти требования.
#### Device & Queue
Как и в случае с `instance`, мы работаем не с глобальными объектами, а сами создаем нужные структуры. Чтобы создать `device` и `queue`, я добавил следующий код:
```
let (device, queue) = adapter.request_device(
&wgpu::DeviceDescriptor {
features: wgpu::Features::empty(),
limits: wgpu::Limits::default(),
label: None,
},
None, // Trace path
).await.unwrap();
```
Мы можем указать конкретные возможности видеокарты, которые хотим использовать в свойстве `features`. Чтобы задать пороговые значения для свойств, используется поле `limits`. Например, там есть свойства `max_vertex_attributes` или `max_vertex_buffer_array_stride`. Посмотреть список всех свойств можно [здесь](https://docs.rs/wgpu/latest/wgpu/struct.Limits.html).
Указание этих свойств может быть полезно, чтобы расширить спектр поддерживаемых GPU.
Последнее, что нужно добавить в метод `State::new` — это создание конфига:
```
let config = wgpu::SurfaceConfiguration {
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
format: surface.get_supported_formats(&adapter)[0],
width: size.width,
height: size.height,
present_mode: wgpu::PresentMode::Fifo,
};
surface.configure(&device, &config);
// Формируем структуру State
Self {
surface,
device,
queue,
config,
size
}
```
Посмотрим подробнее на поля конфига:
* `usage` показывает, в каком режиме должна работать видеокарта.
* `format` определяет, в каком формате будут храниться текстуры `SurfaceTextures`. У разных дисплеев могут быть свои требования, поэтому здесь выбирается первый подходящий формат.
* `present_mode` определяет, как будет синхронизироваться `Surface` с экраном. `wgpu::PresentMode::Fifo` означает `VSYNC`.
Осталось создать структуру `State` в методе `main`:
Создаем StateТк метод `State::new` асинхронный, вызвать его мало, нужно еще дождаться его выполнения, для чего используется `.await`. Чтобы этот код работал, нужен `Executor`. Я воспользуюсь `tokio`, указав его в зависимостях:
`tokio = { version = "1", features = ["full"] }`
Метод `main` тоже нужно сделать асинхронным и пометить аннотацией:
`#[tokio::main]`.
Теперь все работает!
### resize
Продолжим нашу работу, реализовав метод `resize`, который будет вызываться при изменении размеров окна.
```
fn resize(&mut self, new_size: winit::dpi::PhysicalSize) {
if new\_size.width > 0 && new\_size.height > 0 {
self.size = new\_size;
self.config.width = new\_size.width;
self.config.height = new\_size.height;
self.surface.configure(&self.device, &self.config);
}
}
```
main.rs:
Обработка события Resized & ScaleFactorChangedТак гораздо удобнее!
Мне сильно не хватает возможности перетаскивания окна, поэтому добавил обработку события `Moved`:
```
WindowEvent::Moved(_) => {
window.request_redraw();
}
```
### render
Сделаем заливку цветом. Для этого нужно добавить несколько строк в метод `State::render`.
```
let output = self.surface.get_current_texture()?;
```
Сначала мы получаем `SurfaceTexture` (результат работы строки выше, *фрейм*), чтобы потом отрисовывать туда наш фон.
```
let view = output.texture.create_view(&wgpu::TextureViewDescriptor::default());
```
`create_view` возвращает `TextureView`, то, куда будем рендерить.
```
let mut encoder = self.device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("Render Encoder"),
});
```
Нам также понадобиться `CommandEncoder`, чтобы подготовить команды, который будет выполнять *GPU*.
Теперь самый большой кусок:
```
encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Render Pass"),
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
view: &view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color {
r: 0.1,
g: 0.2,
b: 0.3,
a: 1.0,
}),
store: true,
},
})],
depth_stencil_attachment: None,
});
```
Подготавливаем `RenderPass`, который содержит в себе методы для рисования. В данном примере мы сделаем заливку экрана в синий цвет.
Поле `color_attachments.view` указывает, куда отрисовывать изображение (переменная `view`).
`color_attachments.ops.load` определяем, что делать с изображением из предыдущего кадра.
В данном примере мы очищаем экран и делаем заливку синим цветом.
И последние строки в методе `render`:
```
self.queue.submit(std::iter::once(encoder.finish()));
output.present();
Ok(())
```
Отправляем `RenderPass` на выполнение и отрисовываем результат на экран.
Здесь все, но нужно еще обработать два новых события в главном цикле:
Обработка событий RedrawRequested и MainEventsClearedВот, что должно получиться:
Синее окно#### Задание
Добавить в метод `input` обработчик событий движения мышки и менять цвет заливки в соответствии с полученными координатами. (Вам понадобится `WindowEvent::CursorMoved`)
Ссылка на [код](https://github.com/abritov/rust-wgpu-tutorial/tree/master/lesson1) урока
Урок 2
------
The Pipeline. Графический конвейер
----------------------------------
Если вы работали с *OpenGL*, то наверняка знаете про шейдеры. Конвейер объединяет все операции, которые видеокарта будет делать с входными данными (в том числе и шейдеры) в одном месте.
Шейдер - это мини программы, которые выполняются на видеокарте. Выделяют три типа шейдеров: вершинный, фрагментный и вычислительный. Есть и геометрические шейдеры, но их мы не будем рассматривать в этом уроке.
Vertex (вершина) — это точка в 3D пространстве (или 2D). Вершины объединяются в группы по 3 или 2, формируя треугольники или отрезки. С помощью треугольников можно сделать модель любой сложности, начиная от куба и заканчивая человеком.
Вершинный шейдер используется для управления вершинами, например сдвиг или масштабирование.
Затем вершины преобразуются во *фрагменты*. Каждый пиксель в итоговом изображении имеет *фрагмент*, для управления цветом.
### WGSL
Существует несколько языков для написания шейдеров: GLSL, HLSL, MSL, SPIR-V, которые используются соответственно в *OpenGL*, *DirectX*, *Metal*, *Vulkan*. Но в стандарте *WebGPU* определили новый язык ~~чтобы управлять ими всеми~~ для унификации. *WGSL* можно конвертировать во все описанные языки шейдеров.
Напишем наш первый шейдер!
```
// Вершинный шейдер
struct VertexOutput {
@builtin(position) clip_position: vec4, // 1
};
@vertex // 2
fn vs\_main(
@builtin(vertex\_index) in\_vertex\_index: u32, // 3
) -> VertexOutput {
var out: VertexOutput; // 4
let x = f32(1 - i32(in\_vertex\_index)) \* 0.5; // 5
let y = f32(i32(in\_vertex\_index & 1u) \* 2 - 1) \* 0.5;
out.clip\_position = vec4(x, y, 0.0, 1.0); // 6
return out;
}
```
Довольно сильно напоминает rust, не находите?
1. Структура `VertexOutput` определяет выходное значение шейдера. Пока что в нем будет только одно поле `clip_position`, помеченное аннотацией `@builtin(position)`. Тк шейдер имеет входные и выходные параметры (результат вычисления), мы должны указать явным образом, какое именно поле в структуре `VertexOutput` представляет итоговые координаты (position), с помощью аннотации. В *OpenGL* для этого используется `gl_Position`.
2. Точка входа в программу шейдеров *WGSL* помечена аннотацией `@vertex`. В *WGSL* вершинный и фрагментный шейдер могут находиться в одном файле, что является несомненным плюсом.
3. На входе в функцию задается один параметр `in_vertex_index`, который задается в конфигурации `pipeline`. Аннотация `@builtin(vertex_index)` задает назначение аргумента. Это демонстрационный пример, далее будет использоваться другая аннотация. В реальных шейдерах чаще задаются непосредственно вершины, но в данном примере мы будем их вычислять динамически, опираясь только на `in_vertex_index`.
4. Внутри мы видим объявление переменной с типом `VertexOutput`, которая будет возвращаться из функции.
5. При вычислении координат `x` и `y` используются функции `f32` & `i32`, они выполняют роль приведения (cast) типов. Так же, как и в расте, в *WGSL* есть изменяемый `var` переменные и не изменяемые `let`.
6. Присваивание полей структуры делается аналогичны, задаем значение `out.clip_position` и возвращаем `out`.
В данном примере мы можем задать выходное значение напрямую, без структуры `VertexOutput`:
```
@vertex
fn vs_main(
@builtin(vertex_index) in_vertex_index: u32
) -> @builtin(position) vec4 {
// ...
}
```
Пока что я оставлю эту структуру, тк позже добавлю туда еще полей.
#### Фрагметный шейдер
```
@fragment
fn fs_main(in: VertexOutput) -> @location(0) vec4 {
return vec4(0.3, 0.2, 0.1, 1.0);
}
```
Здесь мы задаем выходной цвет заливки пространства внутри вершин (треугольников) в коричневый. По аналогии с `VertexOutput`, `@location(0)` задает индекс выходного фрагментного буфера, только там использовалось именованное поле `position`, а здесь используются числовые индексы. Позже добавим структуру.
### Новый State
Настало время обновить структуру `State`!
Добавим `pipeline`:
```
pub struct State {
surface: wgpu::Surface,
device: wgpu::Device,
queue: wgpu::Queue,
mouse_x: Option,
mouse\_y: Option,
config: wgpu::SurfaceConfiguration,
pub(crate) size: winit::dpi::PhysicalSize,
// NEW!
render\_pipeline: wgpu::RenderPipeline,
}
```
Перейдем к методу `State::new`:
```
let shader = device.create_shader_module(wgpu::include_wgsl!("shader.wgsl"));
```
Макрос `include_wgsl!` читает указанный файл и преобразует его в `ShaderModuleDescriptor`.
Создадим `render_layout`:
```
let render_pipeline_layout =
device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some("Render Pipeline Layout"),
bind_group_layouts: &[],
push_constant_ranges: &[],
});
```
Пока что здесь ничего интересного, позже мы подробнее рассмотрим, что может быть внутри `bind_group_layouts`.
```
let render_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some("Render Pipeline"),
layout: Some(&render_pipeline_layout),
vertex: wgpu::VertexState { // 1
module: &shader,
entry_point: "vs_main", // 2.
buffers: &[], // 3.
},
fragment: Some(wgpu::FragmentState { // 4.
module: &shader,
entry_point: "fs_main", // 5
targets: &[Some(wgpu::ColorTargetState { // 6.
format: config.format,
blend: Some(wgpu::BlendState::REPLACE),
write_mask: wgpu::ColorWrites::ALL,
})],
}),
// ...
```
Ранее я говорил, что *WGSL* умеет хранить разные типы шейдеров в одном файле. Именно здесь задаются точки входа для вершинного и фрагментных шейдеров. Рассмотрим, что еще здесь происходит:
1. Структура вершинного шейдера
2. Точка входа вершинного шейдера
3. Буфер, который будет отправлен на обработку в вершинный шейдер. Обычно, здесь находяться вершины, но в данном примере вершины вычисляются прямо в шейдере (`x` и `y`), поэтому здесь буфер пустой.
4. Структура фрагментного шейдера
5. Точка входа фрагментного шейдера
6. `ColorTargetState` указывает, какой цветовой буфер использовать. Сейчас мы берем значение из `surface`. `ColorWrites::ALL` говорит использовать все цвета: красный, синий, зеленый и альфа канал. `BlendState::REPLACE` задает поведение при смешевании, мы указываем, что новый цвет должен перезаписать старый.
```
// ...
primitive: wgpu::PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleList, // 1.
strip_index_format: None,
front_face: wgpu::FrontFace::Ccw, // 2.
cull_mode: Some(wgpu::Face::Back),
polygon_mode: wgpu::PolygonMode::Fill,
unclipped_depth: false,
conservative: false,
},
// ...
```
Здесь мы задаем как преобразовывать входной буфер из вершин в треугольники.
```
depth_stencil: None, // 1.
multisample: wgpu::MultisampleState {
count: 1, // 2.
mask: !0, // 3.
alpha_to_coverage_enabled: false, // 4.
},
multiview: None, // 5.
});
```
1. Пока мы не будем использовать `depth_stencil`
2. Величина сглаживания
3. Определяет, какие выборки будут активны. Значение `!0` значит "все". Подробнее про сглаживания читайте [здесь](https://ru.wikipedia.org/wiki/%D0%9C%D0%BD%D0%BE%D0%B6%D0%B5%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B2%D1%8B%D0%B1%D0%BE%D1%80%D0%BA%D0%B0_%D1%81%D0%B3%D0%BB%D0%B0%D0%B6%D0%B8%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)
4. Пока что не будем это использовать
5. Это свойство используется для рендеринга в массивы текстур, не наш случай
```
Self {
surface,
device,
queue,
config,
size,
// NEW!
render_pipeline,
}
```
Теперь у нас есть пайплайн!
### Render
Если сейчас запустить программу, ничего не измениться, потому что рендеринг остался старый и в нем не используется новый пайплайн. Сейчас мы это исправим!
Добавьте следующий код в метод `State::render`:
```
// ...
{
// 1.
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Render Pass"),
color_attachments: &[
Some(wgpu::RenderPassColorAttachment {
view: &view,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(
wgpu::Color {
r: self.mouse_y.unwrap_or(0.1),
g: 0.2,
b: self.mouse_x.unwrap_or(0.3),
a: 1.0,
}
),
store: true,
}
})
],
depth_stencil_attachment: None,
});
// NEW!
render_pass.set_pipeline(&self.render_pipeline); // 2.
render_pass.draw(0..3, 0..1); // 3.
}
```
1. Сохраним результат вызова `begin_render_pass` в `render_pass`
2. Связываем `render_pass` и `render_pipeline`
3. Вызываем отрисовку
Обратите внимание, я обрамил код в еще одни фигурные скобки. Это нужно, чтобы обойти ограничение на наличие двух изменяемых ссылок в одной области видимости. Без них код не скомпилируется.
Должен получиться такой треугольник:
### Домашнее задание
Добавьте второй пайплайн, который будет вычислять цвет во фрагментном шейдере исходя из позиции в вершинном шейдере (`VertexOutput`). Сделайте переключение между пайплайнами по нажатии на кнопку space.
Ссылка на [код](https://github.com/abritov/rust-wgpu-tutorial/tree/master/lesson2) урока
Урок 3
------
Загрузка вершин в GPU
---------------------
В этом уроке мы будем работать с вершинным и индексным буфером.
#### Что такое буфер?
Под буфером имеется в виду любой **последовательный** массив данных, как например тип *Vec* в расте. Обычно в буфере храниться массив простых структур, но также там могут быть и сложные структуры данных (граф, например), при условии, что они будут иметь плоскую (последовательную) структуру. Мы будем часто использовать буферы. Начнем изучение с вершинного и индексного буфера.
### Вершинный буфер
В прошлом уроке мы динамически вычисляли вершины прямо в шейдере, поэтому обошлись без вершинного буфера. Но это не лучшая практика, тк теряется возможность переиспользования шейдера и установки других вершин без перезапуска программы. Сейчас мы перепишем код, чтобы вершинный буфер формировался на стороне программы и потом отправим его в шейдер.
Прежде всего, нужно объявить структуру в файле `state`, которая будет описывать вершины:
```
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct Vertex {
position: [f32; 3],
color: [f32; 3],
}
```
Эта структура описывать вершину в трехмерных координатах, ее положение (x, y, z) и цвет (red, green, blue). Обратите внимание на аннотацию `#[repr(C)]`, она говорит компилятору использовать правила выравнивания из языка С. Если ее убрать, будет достаточно трудно найти ошибку. Как правило, все структуры, которые будут отправляться в *GPU*, должны быть помечены `#[repr(C)]`.
Еще я добавил `bytemuck` в `Cargo.toml`:
```
bytemuck = { version = "1.4", features = ["derive"] }
```
Теперь можно сделать сами вершины:
```
const VERTICES: &[Vertex] = &[
Vertex { position: [0.0, 0.5, 0.0], color: [1.0, 0.0, 0.0] },
Vertex { position: [-0.5, -0.5, 0.0], color: [0.0, 1.0, 0.0] },
Vertex { position: [0.5, -0.5, 0.0], color: [0.0, 0.0, 1.0] },
];
```
Вершины здесь указаны против часовой стрелки: верхний угол, нижний левый и правый левый. В прошлом уроке мы указывали, что вершины должны располагаться в буфере именно в таком порядке, тогда они будут на переднем плане.
Указатель на буфер будет храниться в структуре `State`:
```
struct State {
// ...
render_pipeline: wgpu::RenderPipeline,
// NEW!
vertex_buffer: wgpu::Buffer,
// ...
}
```
Создаем буфер:
```
let vertex_buffer = device.create_buffer_init(
&wgpu::util::BufferInitDescriptor {
label: Some("Vertex Buffer"),
contents: bytemuck::cast_slice(VERTICES),
usage: wgpu::BufferUsages::VERTEX,
}
);
```
Чтобы у вас появился метод `create_buffer_init`, нужно импортировать трейт `use wgpu::util::DeviceExt`. Для `contents` я использую приведение типа через `bytemuck`, именно для этого `Vertex` был помечен `bytemuck::Pod` & `bytemuck::Zeroable`. Аннотация `Pod` это аббревиатура, которая расшифровывается "Plain Old Data", которая включает преобразование структуры в `&[u8]`. `Zeroable` значит, что мы можем безопасно использовать `std::mem::zeroed()` на структуре.
И в конце добавляем:
```
Self {
surface,
device,
queue,
config,
size,
render_pipeline,
// NEW!
vertex_buffer,
}
```
### Отправка буфера в GPU
Я сделал буфер, но пока что он не используется в `render_pipeline`. Чтобы его задействовать, нужно создать *разметку* данных (`VertexBufferLayout`), потому что данные в буфере передаются в *GPU* в сыром виде, без типизации. То-есть, мы не сможем понять, где в буфере будут находиться `position`, а где `color`.
`VertexBufferLayout` определяет представление (layout) данных буфера в памяти:
```
impl Vertex {
fn description<'a>() -> wgpu::VertexBufferLayout<'a> {
wgpu::VertexBufferLayout {
array_stride: std::mem::size_of::() as wgpu::BufferAddress, // 1
step\_mode: wgpu::VertexStepMode::Vertex, // 2
attributes: &[ // 3
wgpu::VertexAttribute {
offset: 0, // 4
shader\_location: 0, // 5
format: wgpu::VertexFormat::Float32x3, // 6
},
wgpu::VertexAttribute {
offset: std::mem::size\_of::<[f32; 3]>() as wgpu::BufferAddress,
shader\_location: 1,
format: wgpu::VertexFormat::Float32x3,
}
]
}
}
}
```
1. `array_stride` определяет размер структуры `Vertex` вместе с выравниванием. В нашем случае размер будет примерно 24 байта.
2. `step_mode` задает режим индексации. Помните входной аргумент в вершинном шейдере `@builtin(vertex_index) in_vertex_index: u32`? От заданного параметра `VertexStepMode` зависит, с какими индексами будет вызываться вершинный шейдер. `Vertex` режим работы по-умолчанию, кроме него есть еще `Instance`, мы рассмотрим, как с ним работать позже.
3. `attributes` нужен для описания полей структуры `Vertex`. В нашем случае структура имеет два поля: позицию и цвет. Соответственно, в `atrributes` мы имеем две записи для позиции и цвета.
4. `offset` задает смещение относительно `array_stride` для каждого поля в структуре `Vertex`. Первое поле — `position` имеет смещение 0 (тк перед ним ничего нет). Для вычисления смещения следующего поля, нужно прибавить к нулю размер `position`, то-есть `std::mem::sizeof::<[f32; 3]>()` или 4 \* 3 = 12 байт.
5. `shader_location` задает индекс для `location`, через который можно будет обращаться к полю `position`, например так `@location(0) position: vec3`.
6. `format` задает тип параметра (поля) структуры. В данном случае, `positon` имеет тип `[f32; 3]`, ему соответсвует тип `vec3` в шейдере, а в поле `format` мы указываем `VertexFormat::Float32x3`.
Вот так это выглядит (взял картинку из оригинальной статьи):
Теперь мы можем задать описание нашего буфера в `render_pipeline`:
```
let render_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
// ...
vertex: wgpu::VertexState {
// ...
buffers: &[
Vertex::description(),
],
},
// ...
});
```
И отправить буфер в `render_pass`:
```
render_pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
```
`set_vertex_buffer` принимает два аргумента, первый — это слот, в который попадет буфер, второй сам буфер. При необходимости, мы можем отправлять данные порционно, но в данном случае я отправляю весь буфер.
Мне нужно отрисовать сейчас три вершины, поэтому я вызываю:
```
render_pass.draw(0..3, 0..1);
```
Но для большей гибкости, здесь лучше использовать переменную величину, которая будет соответствовать реальному размеру текущего буфера:
```
render_pass.draw(0..VERTICES.len() as u32, 0..1);
```
Если сейчас запустить программу, ничего не измениться, потому что нужно обновить шейдеры:
```
// Вершинный шейдер
struct VertexInput {
@location(0) position: vec3,
@location(1) color: vec3,
};
struct VertexOutput {
@builtin(position) clip\_position: vec4,
@location(0) color: vec3,
};
@vertex
fn vs\_main(
model: VertexInput,
) -> VertexOutput {
var out: VertexOutput;
out.color = model.color;
out.clip\_position = vec4(model.position, 1.0);
return out;
}
// Фрагментный шейдер
@fragment
fn fs\_main(in: VertexOutput) -> @location(0) vec4 {
return vec4(in.color, 1.0);
}
```
Теперь готово:
### Индексный буфер
В них нет строгой необходимости, но они могут сократить количество используемое вершинным буфером памяти для больших моделей. Рассмотрим такую фигуру (картинка из оригинальной статьи):
В ней 5 вершин и три треугольника. Вершинный буфер для нее будет выглядеть следующим образом:
```
const VERTICES: &[Vertex] = &[
Vertex { position: [-0.0868241, 0.49240386, 0.0], color: [0.5, 0.0, 0.5] }, // A
Vertex { position: [-0.49513406, 0.06958647, 0.0], color: [0.5, 0.0, 0.5] }, // B
Vertex { position: [0.44147372, 0.2347359, 0.0], color: [0.5, 0.0, 0.5] }, // E
Vertex { position: [-0.49513406, 0.06958647, 0.0], color: [0.5, 0.0, 0.5] }, // B
Vertex { position: [-0.21918549, -0.44939706, 0.0], color: [0.5, 0.0, 0.5] }, // C
Vertex { position: [0.44147372, 0.2347359, 0.0], color: [0.5, 0.0, 0.5] }, // E
Vertex { position: [-0.21918549, -0.44939706, 0.0], color: [0.5, 0.0, 0.5] }, // C
Vertex { position: [0.35966998, -0.3473291, 0.0], color: [0.5, 0.0, 0.5] }, // D
Vertex { position: [0.44147372, 0.2347359, 0.0], color: [0.5, 0.0, 0.5] }, // E
];
```
Можно заметить, что вершины C и B повторяются дважды, а E трижды. Если взять размер каждой вершины в 24 байта, то из 216 байт, 96 будут повторяться. Было бы здорово, если мы могли бы перечислить каждую из вершин только один раз?
Здесь приходит на помощь индексный буфер!
```
const VERTICES: &[Vertex] = &[
Vertex { position: [-0.0868241, 0.49240386, 0.0], color: [0.5, 0.0, 0.5] }, // A
Vertex { position: [-0.49513406, 0.06958647, 0.0], color: [0.5, 0.0, 0.5] }, // B
Vertex { position: [-0.21918549, -0.44939706, 0.0], color: [0.5, 0.0, 0.5] }, // C
Vertex { position: [0.35966998, -0.3473291, 0.0], color: [0.5, 0.0, 0.5] }, // D
Vertex { position: [0.44147372, 0.2347359, 0.0], color: [0.5, 0.0, 0.5] }, // E
];
const INDICES: &[u16] = &[
0, 1, 4, // треугольник A, B, E
1, 2, 4, // треугольник B, C, E
2, 3, 4, // треугольник C, D, E
];
```
В таком сценарии `VERTICES` будет занимать всего 120 байт, а `INDICES` 18 байт + 2 на выравнивание. Мы сэкономили 76 байт! Это кажется мало, но для больших фигур разница будет больше.
Нужно внести несколько правок, прежде чем использовать индексный буфер.
```
struct State {
surface: wgpu::Surface,
device: wgpu::Device,
queue: wgpu::Queue,
config: wgpu::SurfaceConfiguration,
size: winit::dpi::PhysicalSize,
render\_pipeline: wgpu::RenderPipeline,
vertex\_buffer: wgpu::Buffer,
// NEW!
index\_buffer: wgpu::Buffer, // положим индексный буфер сюда
num\_indices: u32,
}
```
Начнем с создания нового буфера для индексов в методе `State::new`:
```
let index_buffer = device.create_buffer_init(
&wgpu::util::BufferInitDescriptor {
label: Some("Index Buffer"),
contents: bytemuck::cast_slice(INDICES),
usage: wgpu::BufferUsages::INDEX,
}
);
let num_indices = INDICES.len() as u32;
```
Еще я добавил переменную `num_indices`, которая также будет находиться в `State`:
```
Self {
surface,
device,
queue,
config,
size,
render_pipeline,
vertex_buffer,
// NEW!
index_buffer,
num_indices,
}
```
Теперь обновим метод `State::render`:
```
// render()
render_pass.set_pipeline(&self.render_pipeline);
render_pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
render_pass.set_index_buffer(self.index_buffer.slice(..), wgpu::IndexFormat::Uint16); // 1
render_pass.draw_indexed(0..self.num_indices, 0, 0..1); // 2
```
Несколько вещей, которые нужно отметить:
1. Единовременно вы можете использовать только один индексный буфер, о чем говорит название метода `set_index_buffer`
2. Когда вы используете индексный буфер, для отрисовки нужно вызывать `draw_indexed`. Также не забудьте, что `self.num_indices` равно количеству элементов в индексном буфере, но не количеству вершин. Ошибки в этом параметре приведут к неправильной отрисовке или экстренному завершению процесса.
3. Код шейдера не требуется менять для поддержки индексного буфера
Вот, что получилось:
### Цветовая коррекция
Если вы проверите цвет пентагона, то получите значение #BC00BC. Сконвертировав значение в RGB получаем (188, 0, 188). Разделив значения на 255, чтобы получить цвет в промежутке `[0, 1]`, получим значение (0.737254902, 0, 0.737254902), вместо указанного (0.5, 0.0, 0.5).
Мы можем вычислить аппроксимацию значения цвета по формуле `srgb_color = (rgb_color / 255) ^ 2.2`. Для цвета (188, 0, 188) мы получим значение (0.511397819, 0.0, 0.511397819), что уже гораздо ближе к исходному.
Кроме этого, можно использовать текстуры, тк в них цвета уже в нужном формате.
### Домашнее задание
Нарисуйте более сложную фигуру, с большим количеством треугольников, используя вершинный и индексный буфер. Сделайте смену фигур по кнопке space.
Ссылка на [код](https://github.com/abritov/rust-wgpu-tutorial/tree/master/lesson3) урока
Заключение
----------
Мы научились писать кроссплатформенный код и работать с графикой на базовом уровне, после чего можно двигаться дальше. В следующих статьях мы рассмотрим, как работать с текстурами, загружать модели и делать освещение. | https://habr.com/ru/post/690514/ | null | ru | null |
# Гравитационное поле на поверхности тел неправильной формы на примере кометы Чурюмова-Герасименко
Из закона всемирного тяготения известно, что на поверхности тел шарообразной формы ускорение свободного падения постоянно по модулю и направлено к центру шара. Для тел неправильной формы это правило, очевидно, не выполняется. В этой статье я покажу способ расчёта и визуализации ускорения свободного падения для таких тел. Расчёт будем производить на JavaScript, визуализировать — на WebGL с использованием библиотеки [three.js](http://threejs.org).
В итоге получим следующее (красным цветом отмечены области с большим ускорением свободного падения, синим — с малым):
**Гифка**
Ось вращения на гифке условная. Она не совпадает с осью вращения кометы.
Для расчетов гравитационного потенциала планет используется следующая [формула](https://ru.wikipedia.org/wiki/%D0%93%D1%80%D0%B0%D0%B2%D0%B8%D1%82%D0%B0%D1%86%D0%B8%D0%BE%D0%BD%D0%BD%D1%8B%D0%B9_%D0%BF%D0%BE%D1%82%D0%B5%D0%BD%D1%86%D0%B8%D0%B0%D0%BB#.D0.93.D1.80.D0.B0.D0.B2.D0.B8.D1.82.D0.B0.D1.86.D0.B8.D0.BE.D0.BD.D0.BD.D1.8B.D0.B9_.D0.BF.D0.BE.D1.82.D0.B5.D0.BD.D1.86.D0.B8.D0.B0.D0.BB_.D0.BF.D0.BB.D0.B0.D0.BD.D0.B5.D1.82):
Но, к сожалению, при малых r этот ряд сходится медленно, а при очень малых r вообще расходится. Поэтому для расчета гравитационного потенциала на поверхности небесных тел эта формула не годится. В общем случае, придется провести интегрирование по всему объёму тела.
Трёхмерное тело можно представить в виде наборов треугольных граней, с заданными координатами вершин. Далее будем предполагать, что плотность тела постоянна (для кометы это примерно соответствует истине). Гравитационный потенциал в заданной точке будет равен сумме потенциалов всех тетраэдров, с основанием в этих гранях и с вершиной в заданной точке (мы ищем не гравитационный потенциал, а ускорение свободного падения, которое есть градиент потенциала, но рассуждения остаются теми же).
Для начала нам нужно найти ускорение, которое производит масса тетраэдра на точку, находящуюся в его вершине. Для этого нужно произвести интегрирование по всему объёму тетраэдра. К сожалению данный интеграл не берётся в элементарных функциях, поэтому придётся пойти на хитрость.
Сила, действующая на точку в вершине тетраэдра приблизительно в три раза больше, чем сила, вызванная гравитацией шара, помещенного в середину основания тетраэдра (масса шара при этом равна массе тетраэдра). Т. е. F1≈3\*F2. Это равенство лучше выполняется при малом угле раствора тетраэдра. Для оценки величины отклонения равенства от строгого, я сгенерировал несколько тысяч рандомных тетраэдров и вычислил для них эту величину.
На графике по оси абсцисс показано отношение периметра треугольного основания к расстоянию от вершины до центра основания. По оси ординат — величина ошибки. Как видно, величину ошибки можно представить квадратичной функцией. За редким исключением все точки находятся ниже параболы (исключения нам погоду особо не испортят).
Величину гравитационного ускорения будем вычислять с заданной относительной погрешностью. Если ошибка вычисления превышает эту погрешность, то разбиваем наш тетраэдр на четыре части по основанию и вычисляем ускорение для этих частей по отдельности, затем суммируем.
Ускорение мы находим с точностью до некоторого постоянного, для данного тела, коэффициента, зависящего от массы (или плотности) тела, гравитационной постоянной и некоторых других параметров. Этот коэффициент мы учтём позже.
**Пришло время кода**
```
function force_pyramide(p1, p2, p3, rel) {
// начальная точка в (0, 0, 0)
// rel - относительная погрешность
var volume = (1/6) * triple_product(p1, p2, p3); // объём тетраэдра
if (volume == 0)
return new vector3(0, 0, 0);
if (!rel)
rel = 0.01;
var p0 = middleVector(p1, p2, p3); // вектор центра основания
var len = p0.length();
var per = perimeter(p1, p2, p3); // периметр основания
var tan_per = per / len;
var error = 0.015 * sqr(tan_per); // та самая эмпирическая квадратичная функция
if (error > rel) {
var p12 = middleVector(p1, p2);
var p13 = middleVector(p1, p3);
var p23 = middleVector(p2, p3);
return sumVector(
force_pyramide(p1, p12, p13, rel),
force_pyramide(p2, p23, p12, rel),
force_pyramide(p3, p13, p23, rel),
force_pyramide(p12, p23, p13, rel)
);
}
var ratio = 3 * volume * Math.pow(len, -3);
return new vector3(p0.x, p0.y, p0.z).multiplyScalar(ratio);
}
```
Вычисление ускорения от трёхмерного тела производим суммированием по всем тетраэдрам, образованным гранями тела и заданной точкой (о чём я писал ранее).
**Скрытый текст**
```
function force_object(p0, obj, rel) {
var result = new vector3(0, 0, 0);
for (var i = 0; i < obj.faces.length; i++) {
p1 = subVectors(obj.vertices[obj.faces[i][0] - 1], p0);
p2 = subVectors(obj.vertices[obj.faces[i][1] - 1], p0);
p3 = subVectors(obj.vertices[obj.faces[i][2] - 1], p0);
var f = force_pyramide(p1, p2, p3, rel);
result = addVectors(result, f);
}
return result;
}
```
Вычисляем гравитационное и центробежное ускорения на комете (вращение кометы вызывает ускорение порядка 25% от гравитационного, поэтому пренебрегать им нельзя). Относительную погрешность я выставил в 0,01. Казалось бы это много, но по факту при вычислении погрешность получается раза в три меньше и при визуализации разница абсолютно не заметна (т. к. минимальная разница в цвете пикселей составляет 1/256≈0,004). А если выставить погрешность меньше, то время расчёта увеличивается.
При погрешности, равной 0,01, расчёт выполняется 1-2 секунды, поэтому оформляем его через setInterval, во избежание подвисания браузера.
**Код**
```
var rel = 0.01;
// относительная погрешность
var scale = 1000;
// модель задана в километрах, переводим в метры
var grav_ratio = 6.672e-11 * 1.0e+13 / (sqr(scale) * volume);
// масса кометы 1е+13 кг
var omega2 = sqr(2 * Math.PI / (12.4 * 3600));
// период вращения кометы 12,4 часов
function computeGrav() {
info.innerHTML = 'Расчёт: ' + (100 * item / object3d.vertices.length).toFixed() + '%';
for (var i = 0; i < 50; i++) {
var p0 = object3d.vertices[item];
grav_force[item] = force_object(p0, object3d, rel).multiplyScalar(grav_ratio);
// гравитационное ускорение
circular_force[item] = new vector3(omega2 * p0.x * scale, omega2 * p0.y * scale, 0);
// центробежное ускорение, ось вращения совпадает с осью z
abs_grav_force[item] = grav_force[item].length();
abs_circular_force[item] = circular_force[item].length();
item++;
if (item >= object3d.vertices.length) {
console.timeEnd('gravity calculate');
clearInterval(timerId);
accelSelect();
init();
animate();
break;
}
}
}
var item = 0;
console.time('gravity calculate');
var timerId = setInterval(computeGrav, 1);
```
Теперь стоит рассказать о формате работы с 3D телом. Тут всё просто. Это объект, состоящий из трёх массивов: вершины, нормали и треугольные грани.
```
var obj = {
vertices: [],
normals: [],
faces: []
};
```
Массив вершин хранит объекты-векторы координат вершин. Массив нормалей — векторы нормалей вершин. Массив граней — массивы из трёх чисел, хранящие номера вершин.
Модель кометы Чурюмова-Герасименко я скачал с [сайта](http://blogs.esa.int/rosetta/2014/10/03/measuring-comet-67pc-g/) ESA и упростил её в 3Ds Max. В исходной модели было несколько десятков тысяч вершин и граней, но для нашей задачи это слишком много, т. к. вычислительная сложность алгоритма зависит от произведения количества вершин на количество граней. Модель сохранена в формате [obj](https://ru.wikipedia.org/wiki/Obj).
В библиотеке three.js есть функция OBJLoader для загрузки этого формата, но при загрузке остается только информация о вершинах, а информация о гранях теряется, что не подходит для нашей задачи. Поэтому я её несколько модифицировал.
**Код**
```
function objLoad(url) {
var result;
var xhr = new XMLHttpRequest();
xhr.open('GET', url, false);
xhr.onreadystatechange = function(){
if (xhr.readyState != 4) return;
if (xhr.status != 200) {
result = xhr.status + ': ' + xhr.statusText + ': ' + xhr.responseText;
}
else {
result = xhr;
}
}
xhr.send(null);
return result;
}
function objParse(url) {
var txt = objLoad(url).responseText;
var lines = txt.split('\n');
var result;
// v float float float
var vertex_pattern = /v( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)/;
// f vertex vertex vertex ...
var face_pattern1 = /f( +-?\d+)( +-?\d+)( +-?\d+)( +-?\d+)?/;
// f vertex/uv vertex/uv vertex/uv ...
var face_pattern2 = /f( +(-?\d+)\/(-?\d+))( +(-?\d+)\/(-?\d+))( +(-?\d+)\/(-?\d+))( +(-?\d+)\/(-?\d+))?/;
// f vertex/uv/normal vertex/uv/normal vertex/uv/normal ...
var face_pattern3 = /f( +(-?\d+)\/(-?\d+)\/(-?\d+))( +(-?\d+)\/(-?\d+)\/(-?\d+))( +(-?\d+)\/(-?\d+)\/(-?\d+))( +(-?\d+)\/(-?\d+)\/(-?\d+))?/;
// f vertex//normal vertex//normal vertex//normal ...
var face_pattern4 = /f( +(-?\d+)\/\/(-?\d+))( +(-?\d+)\/\/(-?\d+))( +(-?\d+)\/\/(-?\d+))( +(-?\d+)\/\/(-?\d+))?/;
var obj = {
vertices: [],
normals: [],
faces: []
};
for (var i = 0; i < lines.length; i++) {
var line = lines[i].trim();
if ((result = vertex_pattern.exec(line)) !== null) {
obj.vertices.push(new vector3(
parseFloat(result[1]),
parseFloat(result[2]),
parseFloat(result[3])
));
}else if ((result = face_pattern1.exec(line)) !== null) {
obj.faces.push([
parseInt(result[1]),
parseInt(result[2]),
parseInt(result[3])
]);
if (result[4])
obj.faces.push([
parseInt(result[1]),
parseInt(result[3]),
parseInt(result[4])
]);
}else if ((result = face_pattern2.exec(line)) !== null) {
obj.faces.push([
parseInt(result[2]),
parseInt(result[5]),
parseInt(result[8])
]);
if (result[11])
obj.faces.push([
parseInt(result[2]),
parseInt(result[8]),
parseInt(result[11])
]);
}else if ((result = face_pattern3.exec(line)) !== null) {
obj.faces.push([
parseInt(result[2]),
parseInt(result[6]),
parseInt(result[10])
]);
if (result[14])
obj.faces.push([
parseInt(result[2]),
parseInt(result[10]),
parseInt(result[14])
]);
}else if ((result = face_pattern4.exec(line)) !== null) {
obj.faces.push([
parseInt(result[2]),
parseInt(result[5]),
parseInt(result[8])
]);
if (result[11])
obj.faces.push([
parseInt(result[2]),
parseInt(result[8]),
parseInt(result[11])
]);
}
}
obj.normals = computeNormalizeNormals(obj);
return obj;
}
```
Итак, объект из файла мы загрузили, затем вычислили вектор ускорения в каждой его вершине, теперь необходимо его визуализировать. Для этого нужно создать сцену, настроить камеру и свет, добавить и раскрасить нашу модель.
Сцена создаётся просто.
```
scene = new THREE.Scene();
```
С камерой тоже никаких проблем.
```
var fieldWidth = 500; // размеры холста в пикселях
var fieldHeight = 500;
camera = new THREE.PerspectiveCamera(50, fieldWidth / fieldHeight, 0.01, 10000);
scene.add(camera);
cameraZ = 3 * boundingSphereRadius;
// boundingSphereRadius - радиус сферы, описанной вокруг нашего тела
camera.position.x = 0;
camera.position.y = 0;
camera.position.z = cameraZ;
camera.lookAt(new THREE.Vector3(0, 0, 0)); // камера смотрит в начало координат
```
Для создания камеры мы использовали функцию THREE.PerspectiveCamera(fov, aspect, near, far), где:
fov — высота поля зрения камеры в градусах;
aspect — отношение горизонтального угла зрения камеры к вертикальному;
near — расстояние до ближнего плана (то, что находится ближе, не будет рендериться);
far — расстояние до дальнего плана.
Ставим свет.
```
var ambientLight = new THREE.AmbientLight(0xffffff);
scene.add(ambientLight);
```
Создаём визуализатор.
```
renderer = new THREE.WebGLRenderer({antialias: true});
renderer.setClearColor(0xffffff); // цвет фона
renderer.setPixelRatio(window.devicePixelRatio);
renderer.setSize(fieldWidth, fieldHeight); // задаём размер холста
container.appendChild(renderer.domElement); // привязываемся к холсту
```
**Всё вместе**
```
var container;
var camera, scene, renderer;
var axis;
var mesh;
var boundingSphereRadius, cameraZ;
var lines = [];
var angleGeneral = 0;
function init() {
container = document.getElementById('container');
scene = new THREE.Scene();
var fieldWidth = 500;
var fieldHeight = 500;
camera = new THREE.PerspectiveCamera(50, fieldWidth / fieldHeight, 0.01, 10000);
scene.add(camera);
var ambientLight = new THREE.AmbientLight(0xffffff);
scene.add(ambientLight);
loadModel();
cameraZ = 3 * boundingSphereRadius;
camera.position.x = 0;
camera.position.y = 0;
camera.position.z = cameraZ;
camera.lookAt(new THREE.Vector3(0, 0, 0));
axis = new THREE.Vector3(0.6, 0.8, 0); //
renderer = new THREE.WebGLRenderer({antialias: true});
renderer.setClearColor(0xffffff);
renderer.setPixelRatio(window.devicePixelRatio);
renderer.setSize(fieldWidth, fieldHeight);
container.appendChild(renderer.domElement);
}
```
Для работы с моделями в three.js удобно использовать класс BufferGeometry.
```
var geometry = new THREE.BufferGeometry();
```
Задаём материал.
```
var material = new THREE.MeshLambertMaterial( {
side: THREE.FrontSide, // отображаться будет только передняя сторона грани
vertexColors: THREE.VertexColors // грани окрашиваются градиентом по цветам их вершин
});
```
Загружаем координаты вершин.
```
var vertices = new Float32Array(9 * object3d.faces.length);
for (var i = 0; i < object3d.faces.length; i++) {
for (var j = 0; j < 3; j++) {
vertices[9*i + 3*j ] = object3d.vertices[object3d.faces[i][j] - 1].x;
vertices[9*i + 3*j + 1] = object3d.vertices[object3d.faces[i][j] - 1].y;
vertices[9*i + 3*j + 2] = object3d.vertices[object3d.faces[i][j] - 1].z;
}
}
geometry.addAttribute('position', new THREE.BufferAttribute(vertices, 3));
```
Вычисляем цвет вершин.
```
var colors = addColor();
geometry.addAttribute('color', new THREE.BufferAttribute(colors, 3));
function addColor() {
var colorMin = [0.0, 0.6, 1.0]; // цвет точек с минимальным ускорением
var colorMax = [1.0, 0.0, 0.0]; // то же с максимальным
var colors = new Float32Array(9 * object3d.faces.length);
for (var i = 0; i < object3d.faces.length; i++) {
for (var j = 0; j < 3; j++) {
var intensity = (abs_force[object3d.faces[i][j] - 1] - forceMin) / (forceMax - forceMin);
colors[9*i + 3*j ] = colorMin[0] + (colorMax[0] - colorMin[0]) * intensity;
colors[9*i + 3*j + 1] = colorMin[1] + (colorMax[1] - colorMin[1]) * intensity;
colors[9*i + 3*j + 2] = colorMin[2] + (colorMax[2] - colorMin[2]) * intensity;
}
}
return colors;
}
```
Также нам понадобится отобразить направления ускорения свободного падения в каждой вершине.
**Код**
```
var lines;
function addLines() {
lines = new Array();
for (var i = 0; i < object3d.vertices.length; i++) {
var color;
var ratio;
if (angle_force[i] < 90) {
color = 0x000000; // Вектор ускорения направлен в сторону тела
ratio = -0.2 * boundingSphereRadius / forceMax;
}
else {
color = 0xdddddd; // Вектор ускорения направлен наружу
ratio = 0.2 * boundingSphereRadius / forceMax;
}
var material = new THREE.LineBasicMaterial({
color: color
});
var geometry = new THREE.Geometry();
var point1 = object3d.vertices[i];
var point2 = new THREE.Vector3();
point2.copy(force[i]);
point2.addVectors(point1, point2.multiplyScalar(ratio));
geometry.vertices.push(
new THREE.Vector3(point1.x, point1.y, point1.z),
new THREE.Vector3(point2.x, point2.y, point2.z)
);
var line = new THREE.Line(geometry, material);
rotateAroundWorldAxis(line, axis, angleGeneral);
if (hair.checked)
scene.add(line);
lines.push(line);
}
}
```
С визуализацией закончили. Смотрим, что получилось.
[Демо 1](http://www.anthelion.ru/gravitybodies/comet.html).
Как видим, ускорение свободного падения на комете от 40 до 80 тысяч раз меньше, чем на Земле. Максимальное отклонение вектора ускорения от нормали составляет порядка 60-70 градусов. Мелкие и крупные камни на этих участках вероятно не задерживаются и потихоньку скатываются в области, где угол не такой большой.
Можно поиграться с телами другой формы. [Демо 2](http://www.anthelion.ru/gravitybodies/bodies.html).
Видим, что для куба максимальное ускорение (в центре грани) составляет 1,002 ускорения для шара такой же массы, но на самом деле эта величина чуть меньше единицы (сыграло роль то, что мы считали с относительной погрешностью 0,01). Для куба, в отличие от тетраэдра, существуют точные формулы расчёта ускорений и точное значение для центра грани составляет (для куба со стороной, равной 1):
Для шара того же объёма:
Их отношение составляет 0.999376 и лишь слегка не дотягивает до единицы.
В заключение вопрос. Существуют ли тела, у которых хотя бы в одной точке отношение абсолютной величины гравитационного ускорения к ускорению на поверхности шара той же массы и объёма больше единицы? Если да, то для какого тела это отношение максимально? Во сколько раз это отношение больше единицы, в разы или на доли процентов? | https://habr.com/ru/post/271451/ | null | ru | null |
# Как за месяц сильно прокачаться в Data Science
Привет, хабр!
Меня зовут [Глеб](https://ru.linkedin.com/in/morozovgleb), я долгое время работаю в ритейловой аналитике и сейчас занимаюсь применением машинного обучения в данной области. Не так давно я познакомился с ребятами из [MLClass.ru](http://dscourse.mlclass.ru), которые за очень короткий срок довольно сильно прокачали меня в области **Data Science**. Благодаря им, буквально за месяц я стал активно сабмитить на kaggle. Поэтому данная серия публикаций будет описывать мой опыт изучения Data Science: все ошибки, которые были допущены, а также ценные советы, которые мне передали ребята. Сегодня я расскажу об опыте участия в соревновании [The Analytics Edge (Spring 2015)](https://inclass.kaggle.com/c/15-071x-the-analytics-edge-summer-2015). Это моя первая статья — не судите строго.
Описываемое соревнование проводилось в рамках курса **«The Analytics Edge» от «Massachusetts Institute of Technology»**. Ниже я буду приводить код на языке **R**, который целиком можно найти [тут](https://github.com/MorozovG/Kaggle_Comp_Analytics_Edge/blob/master/Kaggle_Comp.md).
### Описание задачи
Любой продавец хотел бы знать какие характеристики товара повышают вероятность продажи товара. В данном соревновании предлагалось исследовать модели, которые предсказывали бы вероятность продажи **Apple iPad** на базе данных, полученных с сайта **eBay**.
### Данные
Данные предлагаемые для изучения состояли из двух файлов:
* **eBayiPadTrain.csv** — набор данных для создания модели. Содержит **1861** товар.
* **eBayiPadTest.csv** — данные для оценки модели
Для начала подключим библиотеки, применяемые в работе.
```
library(dplyr) # Для удобной работы с данными
library(readr) # Для загрузки данных в удобном формате
```
Теперь загрузим данные.
```
eBayTrain <- read_csv("eBayiPadTrain.csv")
eBayTest <- read_csv("eBayiPadTest.csv")
```
Посмотрим на структуру данных.
```
summary(eBayTrain)
## description biddable startprice condition
## Length:1861 Min. :0.0000 Min. : 0.01 Length:1861
## Class :character 1st Qu.:0.0000 1st Qu.: 80.00 Class :character
## Mode :character Median :0.0000 Median :179.99 Mode :character
## Mean :0.4498 Mean :211.18
## 3rd Qu.:1.0000 3rd Qu.:300.00
## Max. :1.0000 Max. :999.00
## cellular carrier color
## Length:1861 Length:1861 Length:1861
## Class :character Class :character Class :character
## Mode :character Mode :character Mode :character
##
##
##
## storage productline sold UniqueID
## Length:1861 Length:1861 Min. :0.0000 Min. :10001
## Class :character Class :character 1st Qu.:0.0000 1st Qu.:10466
## Mode :character Mode :character Median :0.0000 Median :10931
## Mean :0.4621 Mean :10931
## 3rd Qu.:1.0000 3rd Qu.:11396
## Max. :1.0000 Max. :11861
str(eBayTrain)
## Classes 'tbl_df', 'tbl' and 'data.frame': 1861 obs. of 11 variables:
## $ description: chr "iPad is in 8.5+ out of 10 cosmetic condition!" "Previously used, please read description. May show signs of use such as scratches to the screen and " "" "" ...
## $ biddable : int 0 1 0 0 0 1 1 0 1 1 ...
## $ startprice : num 159.99 0.99 199.99 235 199.99 ...
## $ condition : chr "Used" "Used" "Used" "New other (see details)" ...
## $ cellular : chr "0" "1" "0" "0" ...
## $ carrier : chr "None" "Verizon" "None" "None" ...
## $ color : chr "Black" "Unknown" "White" "Unknown" ...
## $ storage : chr "16" "16" "16" "16" ...
## $ productline: chr "iPad 2" "iPad 2" "iPad 4" "iPad mini 2" ...
## $ sold : int 0 1 1 0 0 1 1 0 1 1 ...
## $ UniqueID : int 10001 10002 10003 10004 10005 10006 10007 10008 10009 10010 ...
```
Набор данных состоит из **11** переменных:
* **description** — текстовое описание товара, предоставляемое продавцом
* **biddable** — товар выставлен на аукционе (= 1) или с фиксированной ценой (= 0)
* **startprice** — стартовая цена для аукциона (если **biddable** = 1) или цена продажи (если **biddable** = 0)
* **condition** — состояние товара (новый, б/у и т.д.)
* **cellular** — товар с мобильной связью (= 1) или нет (= 0)
* **carrier** — оператор связи (если **cellular** = 1)
* **color** — цвет
* **storage** — размер памяти
* **productline** — название модели товара
* **sold** — был ли товар продан (= 1) или нет (=0). Это будет зависимая переменная.
* **UniqueID** — уникальные порядковый номер
Таким образом у нас есть три типа переменных: текстовая **description**, численная **startprice** и все остальные — факторные.
### Создание дополнительных переменных
Посмотрим у какой части из товаров есть описание
```
table(eBayTrain$description == "")
##
## FALSE TRUE
## 790 1071
```
Так как далеко не все товары имеют описание, то я предположил, что этот параметр может влиять на вероятность продажи. Чтобы это учесть создадим переменную, которая будет принимать значение **1**, если описание есть, и **0**, в обратном случае.
```
eBayTrain$is_descr = as.factor(eBayTrain$description == "")
table(eBayTrain$description == "", eBayTrain$is_descr)
##
## FALSE TRUE
## FALSE 790 0
## TRUE 0 1071
```
### Создание переменных для модели из текстового описания
На базе текстового описания создадим переменные для модели путём выделения часто встречающихся слов. Для этого используем библиотеку **tm**.
```
library(tm) ## Загружаем библиотеку
## Loading required package: NLP
## Создаём корпус из текста, необходимый для работы библиотеки
CorpusDescription <- Corpus(VectorSource(c(eBayTrain$description, eBayTest$description)))
## Приводим текст к строчным буквам
CorpusDescription <- tm_map(CorpusDescription, content_transformer(tolower))
CorpusDescription <- tm_map(CorpusDescription, PlainTextDocument)
## Удаляем знаки препинания
CorpusDescription <- tm_map(CorpusDescription, removePunctuation)
## Удаляем так называемые стоп-слова, т.е. слова, не несущие смысловой нагрузки
CorpusDescription <- tm_map(CorpusDescription, removeWords, stopwords("english"))
## Производим стемминг, т.е. приводим слова к смысловым основам
CorpusDescription <- tm_map(CorpusDescription, stemDocument)
## Создаём частотную матрицу
dtm <- DocumentTermMatrix(CorpusDescription)
## Удаляем редкочастотные слова
sparse <- removeSparseTerms(dtm, 0.97)
## Преобразуем частотную матрицу в data.frame и разделим тестовую и тренировочную выборку
DescriptionWords = as.data.frame(as.matrix(sparse))
colnames(DescriptionWords) = make.names(colnames(DescriptionWords))
DescriptionWordsTrain = head(DescriptionWords, nrow(eBayTrain))
DescriptionWordsTest = tail(DescriptionWords, nrow(eBayTest))
```
Теперь приведём оставшиеся текстовые переменные к типу данных **factor**, чтобы предотвратить их обработку моделью как текст. И объединим их с переменными, полученными из описания товара. Для этого используем очень удобную библиотеку **magnittr**
```
library(magrittr)
eBayTrain %<>% mutate(condition = as.factor(condition), cellular = as.factor(cellular),
carrier = as.factor(carrier), color = as.factor(color),
storage = as.factor(storage), productline = as.factor(productline), sold = as.factor(sold)) %>%
select(-description, -UniqueID ) %>% cbind(., DescriptionWordsTrain)
```
Посмотрим на полученный набор переменных.
```
str(eBayTrain)
## 'data.frame': 1861 obs. of 30 variables:
## $ biddable : int 0 1 0 0 0 1 1 0 1 1 ...
## $ startprice : num 159.99 0.99 199.99 235 199.99 ...
## $ condition : Factor w/ 6 levels "For parts or not working",..: 6 6 6 4 5 6 3 3 6 6 ...
## $ cellular : Factor w/ 3 levels "0","1","Unknown": 1 2 1 1 3 2 1 1 2 1 ...
## $ carrier : Factor w/ 7 levels "AT&T","None",..: 2 7 2 2 6 1 2 2 6 2 ...
## $ color : Factor w/ 5 levels "Black","Gold",..: 1 4 5 4 4 3 3 5 5 5 ...
## $ storage : Factor w/ 5 levels "128","16","32",..: 2 2 2 2 5 3 2 2 4 3 ...
## $ productline: Factor w/ 12 levels "iPad 1","iPad 2",..: 2 2 4 9 12 9 8 10 1 4 ...
## $ sold : Factor w/ 2 levels "0","1": 1 2 2 1 1 2 2 1 2 2 ...
## $ is_descr : Factor w/ 2 levels "FALSE","TRUE": 1 1 2 2 1 2 2 2 2 2 ...
## $ box : num 0 0 0 0 0 0 0 0 0 0 ...
## $ condit : num 1 0 0 0 0 0 0 0 0 0 ...
## $ cosmet : num 1 0 0 0 0 0 0 0 0 0 ...
## $ devic : num 0 0 0 0 0 0 0 0 0 0 ...
## $ excel : num 0 0 0 0 0 0 0 0 0 0 ...
## $ fulli : num 0 0 0 0 0 0 0 0 0 0 ...
## $ function. : num 0 0 0 0 0 0 0 0 0 0 ...
## $ good : num 0 0 0 0 0 0 0 0 0 0 ...
## $ great : num 0 0 0 0 0 0 0 0 0 0 ...
## $ includ : num 0 0 0 0 0 0 0 0 0 0 ...
## $ ipad : num 1 0 0 0 0 0 0 0 0 0 ...
## $ item : num 0 0 0 0 0 0 0 0 0 0 ...
## $ light : num 0 0 0 0 0 0 0 0 0 0 ...
## $ minor : num 0 0 0 0 0 0 0 0 0 0 ...
## $ new : num 0 0 0 0 0 0 0 0 0 0 ...
## $ scratch : num 0 1 0 0 0 0 0 0 0 0 ...
## $ screen : num 0 1 0 0 0 0 0 0 0 0 ...
## $ use : num 0 2 0 0 0 0 0 0 0 0 ...
## $ wear : num 0 0 0 0 0 0 0 0 0 0 ...
## $ work : num 0 0 0 0 0 0 0 0 0 0 ...
```
Произведём нормализацию переменной **startprice**, для того, чтобы данная переменная не оказывала чрезмерного влияния на результаты моделей, в связи с её гораздо более широким, по сравнению с другими переменными, диапазоном значении.
```
eBayTrain$startprice <- (eBayTrain$startprice - mean(eBayTrain$startprice))/sd(eBayTrain$startprice)
```
### Модели
С полученным набором данных будем создавать модели. Для оценки точности оценки моделей будем применять ту же оценку, которая была выбрана в соревновании. Это **AUC**. Данный параметр часто применяется для оценки моделей классификации. Он отражает вероятность с которой модель правилно определит зависимую переменную из случайного набора данных. Идеальная модель покажет значение **AUC** равное 1.0, а модель с равновероятным случайным угадыванием — **0.5**.
Так как формат соревнования предполагает ограниченное количество раз в сутки, которое можно будет проверять полученную модель путем загрузки полученных результатов на сайт, то для оценки моделей выделим из тренировчного набора данных собственную тестовую выборку. Для получения сбалансировонной выборки используем библиотеку **caTools**.
```
set.seed(1000) ## Для воспроизводимости исследования
library(caTools)
split <- sample.split(eBayTrain$sold, SplitRatio = 0.7)
train <- filter(eBayTrain, split == T)
test <- filter(eBayTrain, split == F)
```
### Логистическая классификация
Создадим модель логистической регрессии
```
model_glm1 <- glm(sold ~ ., data = train, family = binomial)
```
Посмотрим на значимость переменных для модели
```
summary(model_glm1)
##
## Call:
## glm(formula = sold ~ ., family = binomial, data = train)
##
## Deviance Residuals:
## Min 1Q Median 3Q Max
## -2.6620 -0.7308 -0.2450 0.6229 3.5600
##
## Coefficients:
## Estimate Std. Error z value Pr(>|z|)
## (Intercept) 11.91318 619.41930 0.019 0.984655
## biddable 1.52257 0.16942 8.987 < 2e-16
## startprice -1.96460 0.19122 -10.274 < 2e-16
## conditionManufacturer refurbished 0.92765 0.59405 1.562 0.118394
## conditionNew 0.64792 0.38449 1.685 0.091964
## conditionNew other (see details) 0.98380 0.50308 1.956 0.050517
## conditionSeller refurbished -0.03144 0.40675 -0.077 0.938388
## conditionUsed 0.43817 0.27167 1.613 0.106767
## cellular1 -13.13755 619.41893 -0.021 0.983079
## cellularUnknown -13.50679 619.41886 -0.022 0.982603
## carrierNone -13.25989 619.41897 -0.021 0.982921
## carrierOther 12.51777 622.28887 0.020 0.983951
## carrierSprint 0.88998 0.69925 1.273 0.203098
## carrierT-Mobile 0.02578 0.89321 0.029 0.976973
## carrierUnknown -0.43898 0.41684 -1.053 0.292296
## carrierVerizon 0.15653 0.36337 0.431 0.666625
## colorGold 0.10763 0.53565 0.201 0.840755
## colorSpace Gray -0.13043 0.30662 -0.425 0.670564
## colorUnknown -0.14471 0.20833 -0.695 0.487307
## colorWhite -0.03924 0.22997 -0.171 0.864523
## storage16 -1.09720 0.50539 -2.171 0.029933
## storage32 -1.14454 0.51860 -2.207 0.027315
## storage64 -0.50647 0.50351 -1.006 0.314474
## storageUnknown -0.29305 0.63389 -0.462 0.643867
## productlineiPad 2 0.33364 0.28457 1.172 0.241026
## productlineiPad 3 0.71895 0.34595 2.078 0.037694
## productlineiPad 4 0.81952 0.36513 2.244 0.024801
## productlineiPad 5 2.89336 1080.03688 0.003 0.997863
## productlineiPad Air 2.15206 0.40290 5.341 9.22e-08
## productlineiPad Air 2 3.05284 0.50834 6.005 1.91e-09
## productlineiPad mini 0.40681 0.30583 1.330 0.183456
## productlineiPad mini 2 1.59080 0.41737 3.811 0.000138
## productlineiPad mini 3 2.19095 0.53456 4.099 4.16e-05
## productlineiPad mini Retina 3.22474 1.12022 2.879 0.003993
## productlineUnknown 0.38217 0.39224 0.974 0.329891
## is_descrTRUE 0.17209 0.25616 0.672 0.501722
## box -0.78668 0.48127 -1.635 0.102134
## condit -0.48478 0.29141 -1.664 0.096198
## cosmet 0.14377 0.44095 0.326 0.744385
## devic -0.24391 0.41011 -0.595 0.552027
## excel 0.83784 0.47101 1.779 0.075268
## fulli -0.58407 0.66039 -0.884 0.376464
## function. -0.30290 0.59145 -0.512 0.608555
## good 0.78695 0.33903 2.321 0.020275
## great 0.46251 0.38946 1.188 0.235003
## includ 0.41626 0.42947 0.969 0.332421
## ipad -0.31983 0.24420 -1.310 0.190295
## item -0.08037 0.35025 -0.229 0.818501
## light 0.32901 0.40187 0.819 0.412963
## minor -0.27938 0.37600 -0.743 0.457462
## new 0.08576 0.38444 0.223 0.823479
## scratch 0.02037 0.26487 0.077 0.938712
## screen 0.14372 0.28159 0.510 0.609773
## use 0.14769 0.21807 0.677 0.498243
## wear -0.05187 0.40931 -0.127 0.899154
## work -0.25657 0.29441 -0.871 0.383509
##
## (Intercept)
## biddable ***
## startprice ***
## conditionManufacturer refurbished
## conditionNew .
## conditionNew other (see details) .
## conditionSeller refurbished
## conditionUsed
## cellular1
## cellularUnknown
## carrierNone
## carrierOther
## carrierSprint
## carrierT-Mobile
## carrierUnknown
## carrierVerizon
## colorGold
## colorSpace Gray
## colorUnknown
## colorWhite
## storage16 *
## storage32 *
## storage64
## storageUnknown
## productlineiPad 2
## productlineiPad 3 *
## productlineiPad 4 *
## productlineiPad 5
## productlineiPad Air ***
## productlineiPad Air 2 ***
## productlineiPad mini
## productlineiPad mini 2 ***
## productlineiPad mini 3 ***
## productlineiPad mini Retina **
## productlineUnknown
## is_descrTRUE
## box
## condit .
## cosmet
## devic
## excel .
## fulli
## function.
## good *
## great
## includ
## ipad
## item
## light
## minor
## new
## scratch
## screen
## use
## wear
## work
## ---
## Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
##
## (Dispersion parameter for binomial family taken to be 1)
##
## Null deviance: 1798.8 on 1302 degrees of freedom
## Residual deviance: 1168.8 on 1247 degrees of freedom
## AIC: 1280.8
##
## Number of Fisher Scoring iterations: 13
```
Видно, что для простой логистической модели значимых переменных в данных немного
Оценим **AUC** на тестовых данных. Для этого используем библиотеку **ROCR**
```
library(ROCR)
## Loading required package: gplots
##
## Attaching package: 'gplots'
##
## The following object is masked from 'package:stats':
##
## lowess
predict_glm <- predict(model_glm1, newdata = test, type = "response" )
ROCRpred = prediction(predict_glm, test$sold)
as.numeric(performance(ROCRpred, "auc")@y.values)
## [1] 0.8592183
```
Результат, полученный с помощью данной модели уже очень неплох, но необходимо сравнить его оценками других моделей.
### Деревья классификации (CART model)
Теперь посмотрим на результаты полученные с помощью **CART** модели
```
library(rpart)
library(rpart.plot)
model_cart1 <- rpart(sold ~ ., data = train, method = "class")
prp(model_cart1)
```
```
predict_cart <- predict(model_cart1, newdata = test, type = "prob")[,2]
ROCRpred = prediction(predict_cart, test$sold)
as.numeric(performance(ROCRpred, "auc")@y.values)
## [1] 0.8222028
```
Модель производит оценку хуже чем предыдущая. Попробуем улучшить результаты с помощью подбора параметров путём **cross-validation**. Будем подбирать параметр **cp**, который определяет сложность модели
```
library(caret)
## Loading required package: lattice
## Loading required package: ggplot2
##
## Attaching package: 'ggplot2'
##
## The following object is masked from 'package:NLP':
##
## annotate
library(e1071)
tr.control = trainControl(method = "cv", number = 10)
cpGrid = expand.grid( .cp = seq(0.0001,0.01,0.001))
train(sold ~ ., data = train, method = "rpart", trControl = tr.control, tuneGrid = cpGrid )
## CART
##
## 1303 samples
## 29 predictor
## 2 classes: '0', '1'
##
## No pre-processing
## Resampling: Cross-Validated (10 fold)
##
## Summary of sample sizes: 1173, 1172, 1172, 1173, 1173, 1173, ...
##
## Resampling results across tuning parameters:
##
## cp Accuracy Kappa Accuracy SD Kappa SD
## 0.0001 0.7674163 0.5293876 0.02132149 0.04497423
## 0.0011 0.7743335 0.5430455 0.01594698 0.03388680
## 0.0021 0.7896359 0.5714294 0.03938328 0.08143665
## 0.0031 0.7957780 0.5831451 0.04394428 0.09055433
## 0.0041 0.7919612 0.5748735 0.03867687 0.07958997
## 0.0051 0.7934997 0.5775611 0.03727279 0.07705049
## 0.0061 0.7888843 0.5678360 0.03868024 0.08040614
## 0.0071 0.7881210 0.5662543 0.03710725 0.07714919
## 0.0081 0.7888902 0.5678010 0.03657083 0.07592070
## 0.0091 0.7888902 0.5678010 0.03657083 0.07592070
##
## Accuracy was used to select the optimal model using the largest value.
## The final value used for the model was cp = 0.0031.
```
Вставим предложенное значение и оценим полученную модель
```
bestcp <- train(sold ~ ., data = train, method = "rpart", trControl = tr.control, tuneGrid = cpGrid )$bestTune
model_cart2 <- rpart(sold ~ ., data = train, method = "class", cp = bestcp)
predict_cart <- predict(model_cart2, newdata = test, type = "prob")[,2]
ROCRpred = prediction(predict_cart, test$sold)
as.numeric(performance(ROCRpred, "auc")@y.values)
## [1] 0.8021447
```
### Random Forest
Посмотрим на результаты наиболее сложной в теории модели, но очень простой в применении — **Random Forest**
```
library(randomForest)
## randomForest 4.6-10
## Type rfNews() to see new features/changes/bug fixes.
##
## Attaching package: 'randomForest'
##
## The following object is masked from 'package:dplyr':
##
## combine
set.seed(1000)
model_rf <- randomForest(sold ~ ., data = train, importance = T)
predict_rf <- predict(model_rf, newdata = test, type = "prob")[,2]
ROCRpred = prediction(predict_rf, test$sold)
as.numeric(performance(ROCRpred, "auc")@y.values)
## [1] 0.8576486
```
Как видим, модель уже показывает наилучшие результаты из всех использованных. Попробуем улучшить её путём отсеивания лишних переменных. В этом нам поможет наличие встроенной в модель оценки важности переменных.
```
varImpPlot(model_rf)
```
По левому графику мы видим, что присутствует признак, который не улучшает качество модели. Уберём её и произведём оценку полученной модели.
```
set.seed(1000)
model_rf2 <- randomForest(sold ~ .-excel, data = train, importance = T)
predict_rf <- predict(model_rf2, newdata = test, type = "prob")[,2]
ROCRpred = prediction(predict_rf, test$sold)
as.numeric(performance(ROCRpred, "auc")@y.values)
## [1] 0.8566796
```
Оценка показала, что улучшения модели не произошло, но, исходя из здравого смысла, я считаю, что наличие слова **excel** в описании товара, маловероятно, что может влиять на продажи, а упрощение модели (без существенного ущерба качеству) улучшает её интерпретацию.
Таким образом, наилучшие результаты из всех исследованных моделей показала логистическая регрессия. В результате на Public Board (оценка на 50% от всех доступных тестовых данных) модель с результатом 0.84724 заняла 211 место из 1884, но в итоговом протоколе опустилась на 1291.
В следующий раз я планирую рассказать о том, как на качество модели влияет размер обучающей выборки на примере задачи [Digit Recognizer](https://www.kaggle.com/c/digit-recognizer), о применении метода главных компонент в этой же задаче. После я расскажу про опыт участия в соревновании [Bag of Words Meets Bags of Popcorn](https://www.kaggle.com/c/word2vec-nlp-tutorial), а также длинное исследование в известной задаче [Titanic: Machine Learning from Disaster](https://www.kaggle.com/c/titanic), в котором расскажу о том, как знания о самом Титанике и катастрофе помогают решить задачу.
Ну и напоследок порекомендую записываться к ребятам на [курс по анализу данных](http://dscourse.mlclass.ru). По-моему опыту:
* Даются только полезные практические методы
* Упор делается на результат, который нужно достигать в задачах, а не просто решение
* Реально мотивирует и заставляет много работать
До встречи! | https://habr.com/ru/post/266421/ | null | ru | null |
# АНБ, Ghidra и единороги
На этот раз взгляд команды PVS-Studio привлекла Ghidra — большой и злой фреймворк для реверс-инжиниринга, с помощью которого можно анализировать различные бинарные файлы и делать с ними всякие страшные вещи. Наиболее интересно в нём даже не то, что он бесплатен для использования или отлично расширяется плагинами, а то, что написали его в АНБ и выложили исходники на GitHub для всех желающих. С одной стороны, кажется, что у АНБ-то точно достаточно ресурсов для поддержания кодовой базы в чистоте. А с другой, не очень знакомые с ней новые контрибьюторы могли за прошедшее время случайно добавить незамеченных багов. Поэтому, вооружившись статическим анализом, мы решили поискать слабые места в этом проекте.
Прелюдия
--------
Всего статический анализатор PVS-Studio выдал 651 high, 904 medium и 909 low предупреждений в Java-части проекта Ghidra ([релиз 9.1.2, коммит 687ce7f](https://github.com/NationalSecurityAgency/ghidra/releases/tag/Ghidra_9.1.2_build)). Среди них около половины high и medium срабатываний были вызваны диагностикой "[V6022](https://www.viva64.com/ru/w/v6022/) Parameter is not used inside method's body", которые обычно появляются после рефакторинга, когда какой-то параметр оказался больше не нужен или некий функционал был временно отключен комментариями. Беглый взгляд по этим предупреждениям (очень уж их много, чтобы просматривать каждое в роли стороннего наблюдателя) в данном проекте не выявил ничего явно подозрительного. Вероятно, для данного проекта допустимо временно отключить эту диагностику в настройках анализатора, чтобы на неё не отвлекаться. На практике часто можно встретить опечатки в названии параметра сеттера или конструктора и, вообще говоря, ей не следует пренебрегать. Уверен, большинство читателей хотя бы однажды встречали подобный неприятный паттерн:
```
public class A {
private String value;
public A(String val) { // V6022
this.value = value;
}
public int hashCode() {
return value.hashCode(); // NullPointerException
}
}
```
Более половины low-предупреждений произвела диагностика "[V6008](https://www.viva64.com/ru/w/v6008/) Potential null dereference of 'variable'" — например, часто используется значение *File.getParentFile()* без проверки на *null*. В случае, если объект файла, на котором был вызван этот метод, был сконструирован без абсолютного пути, вернётся *null* и отсутствие проверки может уронить приложение.
По традиции будем разбирать только предупреждения уровней high и medium, поскольку основная часть реальных ошибок содержится именно в них. При работе с отчётами анализатора мы всегда рекомендуем разбирать предупреждения в порядке убывания их достоверности.
Далее рассмотрим несколько фрагментов, указанных анализатором, которые показались мне подозрительными или интересными. Кодовая база у проекта оказалась внушительных размеров, и вручную такие места найти практически невозможно.
Фрагмент 1: сломанная валидация
-------------------------------
```
private boolean parseDataTypeTextEntry()
throws InvalidDataTypeException {
...
try {
newDataType = parser.parse(selectionField.getText(),
getDataTypeRootForCurrentText());
}
catch (CancelledException e) {
return false;
}
if (newDataType != null) {
if (maxSize >= 0
&& newDataType.getLength() > newDataType.getLength()) { // <=
throw new InvalidDataTypeException("data-type larger than "
+ maxSize + " bytes");
}
selectionField.setSelectedValue(newDataType);
return true;
}
return false;
}
```
Предупреждение PVS-Studio: [V6001](https://www.viva64.com/ru/w/v6001/) There are identical sub-expressions 'newDataType.getLength()' to the left and to the right of the '>' operator. DataTypeSelectionEditor.java:366
Данный класс предоставляет графический компонент для выбора типа данных с поддержкой автодополнения. Разработчик, пользующийся этим компонентом, может задать максимально допустимый размер выбираемого типа данных (через поле *maxSize*) или сделать его неограниченным, задав отрицательное значение. Предполагалось, что при валидации введённых данных превышение лимита бросает исключение, которое затем отлавливается выше по стеку вызовов и пользователю показывается соответствующее сообщение.
Похоже, что автора компонента отвлекли прямо во время написания этой проверки, или, может, он задумался над смыслом жизни, но в итоге валидация просто не выполняется, так как число никогда не может быть больше самого себя и, соответственно, получаем игнорирование этого условия. А это значит, что данный компонент может предоставить невалидные данные.
Другая похожая ошибка нашлась в ещё двух классах: *GuidUtil* и *NewGuid*.
```
public class GuidUtil {
...
public static GuidInfo parseLine(...) {
...
long[] data = new long[4];
...
if (isOK(data)) {
if (!hasVersion) {
return new GuidInfo(guidString, name, guidType);
}
return new VersionedGuidInfo(guidString, version, name, guidType);
}
return null;
}
...
private static boolean isOK(long[] data) {
for (int i = 0; i < data.length; i++) {
if ((data[i] != 0) || (data[i] != 0xFFFFFFFFL)) { // <=
return true;
}
}
return false;
}
...
}
```
Предупреждение PVS-Studio: [V6007](https://www.viva64.com/ru/w/v6007/) Expression 'data[i] != 0xFFFFFFFFL' is always true. GuidUtil.java:200
В цикле *for* метода *isOK* проверяется, что одно и то же значение не равно одновременно двум разным числам. Если это так, то GUID сразу же признаётся валидным. То есть, GUID будет признан невалидным только в случае, когда массив *data* пуст, а это не происходит никогда, поскольку значение соответствующей переменной присваивается только один раз — в начале метода *parseLine*.
Тело метода *isOK* в обоих классах полностью совпадает, что наталкивает на мысль об очередной копипасте некорректного кода. Что именно автор хотел проверить, я не уверен, но могу предположить, что этот метод следует исправить следующим образом:
```
private static boolean isOK(long[] data) {
for (int i = 0; i < data.length; i++) {
if ((data[i] == 0) || (data[i] == 0xFFFFFFFFL)) {
return false;
}
}
return true;
}
```
Фрагмент 2: прячем исключения
-----------------------------
```
public void putByte(long offsetInMemBlock, byte b)
throws MemoryAccessException, IOException {
long offsetInSubBlock = offsetInMemBlock - subBlockOffset;
try {
if (ioPending) {
new MemoryAccessException("Cyclic Access"); // <=
}
ioPending = true;
doPutByte(mappedAddress.addNoWrap(offsetInSubBlock / 8),
(int) (offsetInSubBlock % 8), b);
}
catch (AddressOverflowException e) {
new MemoryAccessException("No memory at address"); // <=
}
finally {
ioPending = false;
}
}
```
Предупреждение PVS-Studio: [V6006](https://www.viva64.com/ru/w/v6006/) The object was created but it is not being used. The 'throw' keyword could be missing: 'new MemoryAccessException(«Cyclic Access»)'. BitMappedSubMemoryBlock.java:99
Сами по себе объекты исключений, как известно, ничего не делают (или, по крайней мере, не должны ничего делать). Практически всегда их новые экземпляры выбрасываются через *throw*, в отдельных редких случаях — передаются куда-либо или, может быть, помещаются в коллекцию.
Класс, содержащий данный метод, представляет из себя обёртку над блоком памяти, позволяющую считывать и записывать данные. Здесь из-за того, что исключения не выбрасываются, может нарушиться накладываемое ограничение доступа к текущему блоку памяти с помощью флага *ioPending* и, кроме того, игнорируется *AddressOverflowException*. Таким образом данные могут быть молча испорчены, а вместо явного указания на случившуюся ошибку в конкретном месте разработчик получит странные артефакты, которые придётся анализировать отладчиком.
Всего таких потерявшихся исключений нашлось восемь:
* BitMappedSubMemoryBlock.java: строки 77, 99, 106, 122
* ByteMappedSubMemoryBlock.java: строки 52, 73, 92, 114
Характерно, что в этих же файлах есть крайне похожие методы, в которых *throw* присутствует. Скорее всего, изначально был написан один метод аналогично приведённому фрагменту, после чего его несколько раз скопипастили, каким-то образом обнаружили ошибку и исправили её в тех местах, о которых смогли вспомнить.
Фрагмент 3: минное поле
-----------------------
```
private void processSelection(OptionsTreeNode selectedNode) {
if (selectedNode == null) {
setViewPanel(defaultPanel, selectedNode); // <=
return;
}
...
}
private void setViewPanel(JComponent component, OptionsTreeNode selectedNode) {
...
setHelpLocation(component, selectedNode);
...
}
private void setHelpLocation(JComponent component, OptionsTreeNode node) {
Options options = node.getOptions();
...
}
```
Предупреждение PVS-Studio: [V6008](https://www.viva64.com/ru/w/v6008/) Null dereference of 'selectedNode' in function 'setViewPanel'. OptionsPanel.java:266
Анализатор немного соврал — на данный момент вызов метода *processSelection* не приводит к *NullPointerException*, так как этот метод вызывается всего два раза, причём перед его вызовом *selectedNode* явно проверяется на *null*. Так делать не следует, поскольку другой разработчик может увидеть, что метод явно обрабатывает случай *selectedNode == null*, и решить, что это валидное значение, что потом выльется в падение приложения. Особо опасны такие неожиданности как раз в открытых проектах, так как в них участвуют люди, которые не досконально знают кодовую базу.
Вообще, должен сказать, что весь метод *processSelection* выглядит достаточно странно. Вполне вероятно, что это ошибка копипасты, так как в этом же методе далее ещё дважды встречается if-блок с таким же телом, хотя и с другими условиями. Однако, к этому моменту *selectedNode* уже не будет *null*, и цепочка вызовов *setViewPanel-setHelpLocation* не приведёт к *NullPointerException*.
Фрагмент 4: автодополнение во зло
---------------------------------
```
public static final int[] UNSUPPORTED_OPCODES_LIST = { ... };
public static final Set UNSUPPORTED\_OPCODES = new HashSet<>();
static {
for (int opcode : UNSUPPORTED\_OPCODES) {
UNSUPPORTED\_OPCODES.add(opcode);
}
}
```
Предупреждение PVS-Studio: [V6053](https://www.viva64.com/ru/w/v6053/) The collection is modified while the iteration is in progress. ConcurrentModificationException may occur. DWARFExpressionOpCodes.java:205
В данном случае анализатор опять немного наврал — исключение не будет выброшено, поскольку коллекция *UNSUPPORTED\_OPCODES* всегда пуста и цикл просто не выполнится. К тому же, так совпало, что коллекция — множество, и добавление уже присутствующего элемента её не изменит. Скорее всего, автор вписал в *for-each* название коллекции через автодополнение и не заметил, что было предложено не то поле. Модификация коллекции при итерировании по ней невозможна, но при удачных обстоятельствах, как и в данном случае, приложение может не упасть. Здесь эта опечатка имеет косвенное влияние: автомат, разбирающий DWARF-файлы, полагается на эту коллекцию для остановки анализа при нахождении неподдерживаемых опкодов.
Начиная с Java 9 для коллекций-констант стоит использовать методы-фабрики стандартной библиотеки: например, *Set.of(T… elements)* не только сильно удобнее, но и сразу делает созданную коллекцию иммутабельной, что повышает надёжность кода.
Фрагмент 5: найдётся всё
------------------------
```
public void setValueAt(Object aValue, int row, int column) {
...
int index = indexOf(newName);
if (index >= 0) { // <=
Window window = tool.getActiveWindow();
Msg.showInfo(getClass(), window, "Duplicate Name",
"Name already exists: " + newName);
return;
}
ExternalPath path = paths.get(row); // <=
...
}
private int indexOf(String name) {
for (int i = 0; i < paths.size(); i++) {
ExternalPath path = paths.get(i);
if (path.getName().equals(name)) {
return i;
}
}
return 0;
}
```
Предупреждения PVS-Studio:
* [V6007](https://www.viva64.com/ru/w/v6007/) Expression 'index >= 0' is always true. ExternalNamesTableModel.java:105
* [V6019](https://www.viva64.com/ru/w/v6019/) Unreachable code detected. It is possible that an error is present. ExternalNamesTableModel.java:109
Автор задумался и в методе *indexOf* вместо «индекса» -1 для ненайденного значения возвращает 0 — индекс первого элемента коллекции *paths*. Даже если коллекция пустая. Или, может быть, сгенерировал метод, но забыл поменять возвращаемое значение по умолчанию. В итоге метод *setValueAt* отбросит любое значение, переданное ему, и отобразит пользователю ошибку «Имя уже существует», даже если нет ни одного существующего имени.
Кстати, *indexOf* больше нигде не используется, да и его значение нужно только для того, чтобы определить, существует ли искомый элемент. Возможно, следовало вместо отдельного метода написать *for-each* прямо в *setValueAt* и сделать *return* на совпадающем элементе вместо игр с индексами.
Примечание: воспроизвести предположенную ошибку у меня не удалось. Вероятно, метод *setValueAt* больше не используется или вызывается только при определённых условиях.
Фрагмент 6: соблюдайте тишину
-----------------------------
```
final static Map DELIMITER\_NAME\_MAP = new HashMap<>(20);
// Any non-alphanumeric char can be used as a delimiter.
static {
DELIMITER\_NAME\_MAP.put(' ', "Space");
DELIMITER\_NAME\_MAP.put('~', "Tilde");
DELIMITER\_NAME\_MAP.put('`', "Back quote");
DELIMITER\_NAME\_MAP.put('@', "Exclamation point");
DELIMITER\_NAME\_MAP.put('@', "At sign");
DELIMITER\_NAME\_MAP.put('#', "Pound sign");
DELIMITER\_NAME\_MAP.put('$', "Dollar sign");
DELIMITER\_NAME\_MAP.put('%', "Percent sign");
...
}
```
Предупреждение PVS-Studio: [V6033](https://www.viva64.com/ru/w/v6033/) An item with the same key '@' has already been added. FilterOptions.java:45
Ghidra поддерживает фильтрацию данных в различном контексте: например, можно отфильтровать список файлов проекта по названию. Кроме того, реализована фильтрация сразу по нескольким ключевым словам: '.java,.c' при включенном режиме 'OR' выведет все файлы, в названии которых есть либо '.java', либо '.c'. Подразумевается, что в качестве разделителя слов можно использовать любой специальный символ (конкретный разделитель выбирается в настройках фильтра), но в реальности восклицательный знак оказался недоступен.
В подобных простынях инициализации очень просто опечататься, так как они часто пишутся с помощью копипасты, а при просмотре такого кода взгляд быстро замыливается. А если опечатка оказалась не на двух соседних строках, то вручную её почти наверняка никто не увидит.
Фрагмент 7: остаток от деления всегда 0
---------------------------------------
```
void setFactorys(FieldFactory[] fieldFactorys,
DataFormatModel dataModel, int margin) {
factorys = new FieldFactory[fieldFactorys.length];
int x = margin;
int defaultGroupSizeSpace = 1;
for (int i = 0; i < factorys.length; i++) {
factorys[i] = fieldFactorys[i];
factorys[i].setStartX(x);
x += factorys[i].getWidth();
// add in space between groups
if (((i + 1) % defaultGroupSizeSpace) == 0) { // <=
x += margin * dataModel.getUnitDelimiterSize();
}
}
width = x - margin * dataModel.getUnitDelimiterSize() + margin;
layoutChanged();
}
```
Предупреждения PVS-Studio:
* [V6007](https://www.viva64.com/ru/w/v6007/) Expression '((i + 1) % defaultGroupSizeSpace) == 0' is always true. ByteViewerLayoutModel.java:66
* [V6048](https://www.viva64.com/ru/w/v6048/) This expression can be simplified. Operand 'defaultGroupSizeSpace' in the operation equals 1. ByteViewerLayoutModel.java:66
Просмотрщик байтов в шестнадцатеричном режиме поддерживает выбор размера отображаемых групп: например, можно настроить вывод данных в формате 'ffff ffff' или 'ff ff ff ff'. За расположение этих групп в пользовательском интерфейсе отвечает метод *setFactorys*. Несмотря на то, что кастомизация и отображение работают правильно, цикл в этом методе выглядит крайне подозрительно: остаток от деления на единицу всегда равен нулю, а значит и координата *x* будет увеличиваться на каждой итерации. Подозрений добавляет и наличие свойства *groupSize* у параметра *dataModel*.
Оставшийся мусор после рефакторинга? Или, может быть, потерялись вычисления переменной *defaultGroupSizeSpace*? В любом случае, попытка замены её значения на *dataModel.getGroupSize()* сломала вёрстку, и однозначный ответ может дать, пожалуй, только автор этого кода.
Фрагмент 8: сломанная валидация, часть 2
----------------------------------------
```
private String parseArrayDimensions(String datatype,
List arrayDimensions) {
String dataTypeName = datatype;
boolean zeroLengthArray = false;
while (dataTypeName.endsWith("]")) {
if (zeroLengthArray) { // <=
return null; // only last dimension may be 0
}
int rBracketPos = dataTypeName.lastIndexOf(']');
int lBracketPos = dataTypeName.lastIndexOf('[');
if (lBracketPos < 0) {
return null;
}
int dimension;
try {
dimension = Integer.parseInt(dataTypeName.substring(lBracketPos + 1,
rBracketPos));
if (dimension < 0) {
return null; // invalid dimension
}
}
catch (NumberFormatException e) {
return null;
}
dataTypeName = dataTypeName.substring(0, lBracketPos).trim();
arrayDimensions.add(dimension);
}
return dataTypeName;
}
```
Предупреждение PVS-Studio: [V6007](https://www.viva64.com/ru/w/v6007/) Expression 'zeroLengthArray' is always false. PdbDataTypeParser.java:278
Данный метод парсит размерность многомерного массива и возвращает либо оставшийся после разбора текст, либо *null* для невалидных данных. Комментарий возле одной из проверок валидности гласит, что нулевым может быть только последний считанный размер. Разбор идёт справа налево, поэтому подразумевается, что '[0][1][2]' — валидный входной текст, а '[2][1][0]' — нет.
Но, беда: проверку, что очередной размер равен нулю, в цикл никто не добавил, и парсер без лишних вопросов съедает невалидные данные. Вероятно, следует исправить try-блок следующим образом:
```
try {
dimension = Integer.parseInt(dataTypeName.substring(lBracketPos + 1,
rBracketPos));
if (dimension < 0) {
return null; // invalid dimension
} else if (dimension == 0) {
zeroLengthArray = true;
}
}
catch (NumberFormatException e) {
return null;
}
```
Естественно, существует возможность, что данный критерий валидности со временем оказался ненужным, или комментарий автора несёт в себе другой смысл и нужно проверять первую прочитанную размерность. В любом случае, валидация данных — критическая часть любого приложения, к которой надо относиться со всей ответственностью. Ошибки в ней могут привести как к достаточно безобидным падениям приложения, так и дырам в безопасности, утечке данных, их порче или потере (например, если пропустить SQL-инъекцию при валидации запроса).
Немного об остальных предупреждениях
------------------------------------
Читатель может заметить, что предупреждений было выдано много, а рассмотрено мало. Не очень аккуратно настроенный cloc насчитал в проекте около 1.25 млн. строк Java-кода (не пустых и не комментариев). Дело в том, что почти все предупреждения крайне однотипные: здесь забыли проверить на *null*, там не удалили неиспользуемый легаси-код. Утомлять читателя перечислением одного и того же не очень хочется, а часть подобных случаев я упоминал в начале статьи.
Ещё, как пример, можно отметить полсотни предупреждений "[V6009](https://www.viva64.com/ru/w/v6009/) Function receives an odd argument" в контексте неаккуратного использования метода *substring* (CParserUtils.java:280, ComplexName.java:48 и прочие) для получения остатка строки после какого-либо разделителя. Разработчики часто надеются, что этот разделитель в строке будет присутствовать и забывают, что в ином случае *indexOf* вернёт -1, который является некорректным значением для *substring*. Естественно, если данные были провалидированы или получены не «извне», то вероятность падения приложения значительно уменьшается. Однако, в общем случае это потенциально опасные места, от которых мы хотим помочь избавиться.
Заключение
----------
В общем и целом, Ghidra порадовала качеством кода — никаких особенных кошмаров в глаза не бросается. Код неплохо отформатирован и имеет вполне консистентый стиль: переменным, методам и всему прочему в большинстве случаев даны понятные названия, встречаются разъяснительные комментарии, присутствует огромное количество тестов.
Не обошлось, естественно, и без проблем, среди которых:
* Мёртвый код, который, скорее всего, остался после многочисленных рефакторингов;
* Множество javadoc-ов безнадёжно устарели и, например, указывают на несуществующие параметры;
* Отсутствует возможность удобной разработки [при использовании IntelliJ IDEA](https://github.com/NationalSecurityAgency/ghidra/issues/450);
* Модульная система, построенная вокруг рефлексии, делает навигацию по проекту и поиск зависимостей между компонентами в разы сложнее.
Пожалуйста, не пренебрегайте инструментами для разработчиков. Статический анализ, как и ремни безопасности, не панацея, но он поможет предотвратить часть катастроф ещё до релиза. А забагованным софтом пользоваться не нравится никому.
Про другие проверенные проекты можно почитать в [нашем блоге](https://www.viva64.com/ru/b/). А ещё у нас есть [триальная лицензия](https://www.viva64.com/ru/pvs-studio-download/) и различные [варианты](https://www.viva64.com/ru/b/0614/) использования анализатора без необходимости за него платить.
[](https://habr.com/en/company/pvs-studio/blog/504778/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Nikita Lazeba. [NSA, Ghidra, and Unicorns](https://habr.com/en/company/pvs-studio/blog/504778/). | https://habr.com/ru/post/504780/ | null | ru | null |
# 1000-мерный куб: можно ли сегодня создать вычислительную модель человеческой памяти?
Сегодня утром на пути к кампусу Беркли я провёл пальцами по листьям ароматного куста, а затем вдохнул знакомый запах. Я делаю так каждый день, и каждый день первое слово, которое всплывает в голове и приветственно машет рукой — это *шалфей (sage)*. Но я знаю, что это растение — не шалфей, а розмарин, поэтому я приказываю *шалфею* успокоиться. Но слишком поздно. После *rosemary* и *sage* я не могу помешать появлению на сцене *петрушки (parsley)* и *чабреца (thyme)*, после чего в голове возникают первые ноты мелодии и лица на обложке альбома, и вот я уже снова оказался в середине 1960-х, одетый в рубашку с огурцами. Тем временем *розмарин (rosemary)* вызывает в памяти Роуз Мэри Вудс (Rosemary Woods) и 13-минутный пробел (хотя *теперь*, проконсультировавшись с коллективной памятью, я знаю, что это должны быть Роуз Мэри Вудс и [пробел в 18 с половиной минут](https://en.wikipedia.org/wiki/Nixon_White_House_tapes)). От Уотергейта я перепрыгиваю к историям на главной странице. Потом я замечаю в ухоженном саду ещё одно растение с пушистыми серо-зелёными листями. Это тоже не шалфей, а чистец (lamb’s ear). Тем не менее, *sage* наконец получает свою минуту славы. От трав я переношусь к математическому ПО [Sage](http://www.sagemath.org/), а потом к системе противовоздушной обороны 1950-х под названием [SAGE](https://www.ll.mit.edu/about/History/SAGEairdefensesystem.html), Semi-Automatic Ground Environment, которой управлял самый крупный из когда-либо построенных компьютеров.
В психологии и литературе подобные мыслительные блуждания называются *потоком сознания* (автор этой метафоры — Уильям Джеймс). Но я бы выбрал другую метафору. Моё сознание, насколько я ощущаю, не течёт плавно от одной темы к другой, а скорее порхает по ландшафту мыслей, больше похожее на бабочку, чем на реку, иногда прибиваясь к одному цветку, а затем к другому, иногда уносимая порывами ветка, иногда посещающая одно и то же место снова и снова.
Чтобы исследовать архитектуру собственной памяти я попытался провести более неспешный эксперимент со свободными ассоциациями. Я начал с того же флорального рецепта — петрушка, шалфей, розмарин и чабрец — но для этого упражнения не прогуливался по садам холмов Беркли; я сидел за столом и делал заметки. Показанная ниже схема представляет собой наилучшую попытку реконструкции полного хода моих размышлений.
parsley, sage, rosemary, thyme — четыре травы, а также строчка из песни Simon and Garfunkel.
Simon and Garfunkel — Пол Саймон и Арт Гарфанкел, дуэт певцов в жанре фолк-рока 1960-х и 70-х.
Mrs. Robinson — песня Simon and Garfunkel, а также персонаж из фильма Майка Николса «The Graduate».
«Where have you gone, Joe DiMaggio?» — вопрос, задаваемый в «Mrs. Robinson».
Simon and Schuster — издательский дом, основанный в 1924 году Ричардом Саймоном и Максом Шустером (изначально для публикации кроссвордов).
Джеки Робинсон — легендарный игрок Brooklyn Dodgers.
Робинзон Крузо — роман Даниэля Дефо о потерпевшем кораблекрушение (1719 год).
Швейцарская семья Робинзонов — роман Йохана Дэвида Уайсса о потерпевших кораблекрушение (1812 год).
herbs (травы) — ароматные растения
Mr. Wizard — субботнее научное шоу 1950-х для детей, ведущий Дон Херберт.
Alpert — трубач Герб Алперт.
«Plastics» — совет по карьерному росту, предложенный в «The Graduate».
coo-coo-ca-choo — строчка из «Mrs. Robinson».
Фрэнк Робинсон — аутфилдер Baltimore Orioles в 1970-х.
Грэйг Неттлз — третий бейсмен New York Yankees в 1970-х.
Дастин Хоффман — актёр, игравший в «The Graduate».
Эбби Хоффман — «Yipee!»
Леоминстер — город в Массачусетсе, ставший колыбелью производства пластмасс в США.
Брукс Робинсон — третий бейсмен Baltimore Orioles в 1970-х.
Papillon («Мотылёк») — фильм 1973 года, в которой Дастин Хоффман исполнял второстепенную роль; «papillon» по-французски «бабочка».
Nabokov — Владимир Набоков, родившийся в России писатель и изучающий бабочек энтомолог.
butterfly, Schmetterling, mariposa, farfalla — «бабочка» на английском, немецком, испанском и итальянском; похоже, что все они (и французское слово тоже) имеют независимое происхождение.
Как по-русски называется бабочка — я не знаю. Или не знал, когда возник этот вопрос.
«I am the Walrus» — песня Beatles 1967 года, в которой тоже есть фраза «coo-coo-ca-choo».
Карли Саймон — певица. Никакой связи с Полом Саймоном, но является дочерью Ричарда Саймона.
«You’re so vain» — песня Карли Саймон.
График сверху вниз представляет собой темы в том порядке, котором они всплывали в мозгу, но связи между узлами не создают единую линейную последовательность. Структура напоминает дерево с короткими цепочками последовательных ассоциаций, заканчивающиеся резким возвратом к более раннему узлу, как будто меня утащило обратно растянувшейся резиновой лентой. Такие прерывания помечены на графике зелёными стрелками; красный крестик внизу — это место, на котором я решил завершить эксперимент.
Прощу прощения у тех, кто родился позже 1990 года, многие из упомянутых тем могут показаться вам устаревшими или загадочными. Под графиком представлены объяснения, однако не думаю, что они сделают ассоциации более понятными. В конце концов, воспоминания персональны, они живут внутри головы. Если вы хотите собрать коллекцию идей, соответствующих вашему собственному опыту, вам достаточно создать собственный график свободных ассоциаций. Крайне рекомендую сделать это: вы можете обнаружить что вы не знали, что знаете какие-то вещи.
---
Целью моей ежедневной прогулки вниз по холму в Беркли является Институт Саймонса и курс теории вычислений, в котором я участвую в длящейся один семестр программе, посвящённой мозгу и вычислениям. Такое окружение вызывает мысли о мыслях. Я начал размышлять: каким образом можно построить вычислительную модель процесса свободных ассоциаций? Среди различных задач, предлагаемых для решения искусственным интеллектом, эта выглядит довольно просто. Здесь нет необходимости в глубокой рационализации; всё, что нам нужно симулировать — это просто грёзы и витание в облаках — именно этим занимается мозг, когда он не нагружен. Похоже, что такую задачу решить легко, не правда ли?
Первая идея, которая приходит в голову (по крайней мере, в *мою* голову), относительно архитектуры такой вычислительной модели — это случайное движение по математическому графу или сети. Узлы сети — это хранящиеся в памяти элементы — идеи, факты, события — а связи — это различные виды ассоциаций между ними. Например, узел *«бабочка»* может быть связан с *«мотыльком», «гусеницей», «монархом»* и *«перламутровкой»,* а ещё с переходами, упомянутыми в моём графике, и, возможно, иметь и менее очевидные связи, например *«Australian crawl», «креветка», «Мохаммед Али», «пеллагра», «дроссель»* и *«страх сцены»*. Структура данных узла сети будет содержат список указателей на все эти связанные узлы. Указатели могут быть пронумерованы от 1 до n; программа будет генерировать псевдослучайное число в этом интервале и переходить к соответствующему узлу, в котором вся процедура будет начинаться заново.
Этот алгоритм отражает некоторые основные характеристики свободных ассоциаций, но многие из них не учитывает. Модель предполагает, что все целевые узлы равновероятны, что выглядит неправдоподобно. Чтобы учесть разницу вероятностей, мы можем задать каждому ребру  вес , а затем сделать вероятности пропорциональными весам.
Ещё больше усложняет всё тот факт, что веса зависят от контекста — от недавней истории умственной активности человека. Если бы у меня не было сочетания Mrs. Robinson и Джеки Робинсона, то подумал ли бы я о Джо Ди Маджо? А сейчас, когда я пишу это, Joltin' Joe (прозвище Ди Маджо) вызывает в памяти Мэрилин Монро, а затем Артура Миллера, и я снова не могу остановить ход размышлений. Для воспроизведения этого эффекта в компьютерной модели потребуется некий механизм динамической регуляции вероятностей целых категорий узлов в зависимости от того, какие другие узлы были посещены недавно.
Также следует учесть эффекты новизны другого вида. В модели должна найти место резиновая лента, постоянно притягивающая меня обратно к Simon and Garfunkel и Mrs. Robinson. Вероятно, каждый недавно посещённый узел необходимо добавить в список вариантов целей, даже если он никак не связан с текущим узлом. С другой стороны, привыкание — это тоже вероятность: слишком часто вспоминаемые мысли становятся скучными, поэтому должны подавляться в модели.
Ещё одно, последнее испытание: некоторые воспоминания являются не изолированными фактами или идеями, а частями истории. У них есть нарративная структура с событиями, разворачивающимися в хронологическом порядке. Для узлов таких эпизодических воспроминаний требуется ребро *next*, а возможно и *previous*. Такая цепочка рёбер объединяет всю нашу жизнь, включая в себя всё, что вы помните.
---
Может ли подобная вычислительная модель воспроизвести мои умственные блуждания? Сбор данных для такой модели окажется довольно долгим процессом, и это неудивительно, ведь мне понадобилась вся жизнь, чтобы заполнить свой череп переплетением трав, Гербов, Саймонов, Робинсонов и Хоффманов. Гораздо больше, чем объём данных, меня волнует кропотливость алгоритма обхода графа. Очень легко сказать: «выбери узел согласо множеству взвешенных вероятностей», но когда я смотрю на грязные подробности реализации этого действия, то с трудом могу представить, что нечто подобное происходит в мозге.
Вот простейший из известных мне алгоритм для случайного взвешенного выбора. (Это не самый эффективный из таких алгоритмов, но методы получше ещё более хаотичны. Кит Шварц написал отличный [туториал и обзор](http://www.keithschwarz.com/darts-dice-coins/) по этой теме.) Предположим, что структура данных, имитирующая узел сети, включает в себя список связей с другими узлами и соответствующий список весов. Как показано на рисунке ниже, программа генерирует ряд накапливаемых сумм весов: . Следующий шаг заключается в нормализации этого ряда делением каждого числа на общую сумму весов. Теперь у нас есть ряд чисел , монотонно возрастающий от нуля до единицы. Далее программа выбирает случайное вещественное число  из интервала ;  должно находиться в одном из нормализованных интервалов , а это значение  определяет следующий выбираемый узел.
В коде на [языке программирования Julia](https://julialang.org/) процедура выбора узла выглядит так:
```
function select_next(links, weights)
total = sum(weights)
cum_weights = cumsum(weights)
probabilities = cum_weights / total
x = rand()
for i in 1:length(probabilities)
if probabilities[i] >= x
return i
end
end
end
```
Я так медленно описываю эти скучные подробности накапливаемых сумм и псевдослучайных чисел, чтобы подчеркнуть таким образом, что этот алгоритм обхода графа не так прост, как выглядит на первый взгляд. И мы всё ещё пока не рассмотрели тему изменения вероятностей на лету, хотя наше внимание плавает от темы к теме.
Ещё сложнее постичь процесс обучения — добавления в сеть новых узлов и рёбер. Я закончил мой сеанс свободных ассоциаций, когда пришёл к вопросу, на который не мог ответить: как по-русски называется бабочка? Но *теперь* я могу на него ответить. В следующий раз, когда я буду играть в эту игру, я добавлю в список слово *babochka*. В вычислительной модели вставка узла для слова *babochka* — это довольно простая задача, но наш новый узел также должен быть связан со всеми уже существующими узлами о бабочках. Более того, *babochka* сама по себе добавляет новые рёбра. Она фонетически близка к *babushka* (бабушка) — одному из нескольких русских слов в моём словаре. Суффикс *-ochka* уменьшительный, поэтому его нужно ассоциировать с французским *-ette* и итальянским *-ini*. Буквальное значение слова *babochka* — «маленькая душа», что предполагает ещё большее количество ассоциаций. В конце концов, изучение единственного нового слова может потребовать полной переиндексации всего дерева знаний.
---
Давайте попробуем другой метод. Забудем о случайном обходе сети с её спагетти из указателей на узлы. Вместо этого давайте просто хранить все схожие вещи по соседству. С точки зрения банков памяти цифрового компьютера это значит, что схожие вещи будут храниться по соседним адресам. Вот гипотетический сегмент памяти, центрированный на концепции *dog*. Соседние места заняты другими словами, понятиями и категориями, которые скорее всего будут вызваны мыслью о собаке (*dog*): очевидные *cat* (кошка) и *puppy* (щенок), различные породы собак и несколько конкретных собак (Скиппи — это наш семейный пёс, который был у меня в детстве), а также, возможно, более сложные ассоциации. У каждого элемента есть цифровой адрес. Адрес не имеет какого-то глубинного значения, но важно то, что все ячейки памяти пронумерованы по порядку.
| адрес | содержимое |
| --- | --- |
| 19216805 | god |
| 19216806 | the dog that didn’t bark in the night |
| 19216807 | Skippy |
| 19216808 | Lassie |
| 19216809 | canine |
| 19216810 | cat |
| 19216811 | dog |
| 19216812 | puppy |
| 19216813 | wolf |
| 19216814 | cave canem |
| 19216815 | Basset Hound |
| 19216816 | Weimaraner |
| 19216817 | dogmatic |
Задача неторопливого блуждания по этому массиву в памяти может быть довольно простой. Она может выполнять случайный обход адресов памяти, но преимущество будет отдаваться небольшим шагам. Например, следующий посещаемый адрес может определяться сэмплированием из нормального распределения, центрированного относительно текущего места. Вот код на Julia. (Функция `randn()` возвращает случайное вещественное число, полученное из нормального распределения со средним значением  и стандартным отклонением .)
```
function gaussian_ramble(addr, sigma)
r = randn() * sigma
return addr + round(Int, r)
end
```
У такой схемы есть привлекательные черты. Нет необходимости сводить в таблицу все возможные целевые узлы, прежде чем выбирать один из них. Вероятности не хранятся как числа, а закодированы позицией в массиве, а также модулированы параметром , который определяет, насколько далеко процедура хочет перемещаться в массиве. Хотя программа всё равно выполняет арифметические действия для сэмлирования из нормального распределения, такая функция, вероятно, будет более простым решением.
Но всё-таки у этой процедуры есть ужасающий изъян. Окружив *dog* всеми его непосредственными ассоциациями, мы не оставили места для *их* ассоциаций. Собачьи термины хороши в своём собственном контексте, но как насчёт *cat* из списка? Куда нам поместить *kitten*, *tiger*, *nine lives* и *Felix*? В одномерном массиве нет никакой возможности встроить каждый элемент памяти в подходящее окружение.
Так что давайте перейдём в два измерения! Разделив адреса на два компонента, мы задаём две ортогональные оси. Первая половина каждого адреса становится координатой , а вторая — координатой . Теперь *dog* и *cat* по-прежнему остаются близкими соседями, но также у них появляются личные пространства, в которых они могут играть с собственными «друзьями».
Однако двух измерений тоже недостаточно. Если мы попытаемся заполнить все элементы, связанные с *The Cat in the Hat*, они неизбежно начнут сталкиваться и конфликтовать с близкими элементами *the dog that didn’t bark in the night*. Очевидно, нам нужно больше измерений — намного больше.
---
Сейчас подходящий момент для того, чтобы признаться — я не первый, кто думал о том, как могут быть упорядочены воспоминания в памяти. Список моих предшественников можно начать с Платона, который сравнивал память с птицей; мы распознаём воспоминания по их оперению, но иногда нам трудно достать их, если они начинают порхать в клетке нашего черепа. Иезуит 16-го века Маттео Риччи писал о «дворце памяти», в котором мы блуждаем по различным комнатам и коридорам в поисках сокровищ прошлого. Современные теории памяти обычно менее образны, однако более подробны и нацелены на переход от метафоры к механизму. Лично мне больше всего нравится математическая модель, полученная в 1980-х [Пентти Канерва](https://redwood.berkeley.edu/people/pentti-kanerva/), который сейчас работает в Редвудском центре теоретических нейронаук здесь, в Беркли. Он придумал идею [разреженной распределённой памяти](https://mitpress.mit.edu/books/sparse-distributed-memory) (sparse distributed memory), которую я буду называть SDM. В ней удачно применяется удивительная геометрия пространств высокой размерности.
Представьте куб в трёх измерениях. Если принять, что длина стороны равна единице измерения, то восемь векторов можно обозначить векторами из трёх двоичных цифр, начиная с  и заканчивая . В любой из вершин изменение единственного бита вектора приводит нас к вершине, являющейся ближайшим соседом. Изменение двух битов перемещает нас к следующему по близости соседу, а замена всех трёх битов приводит к противоположному углу куба — к самой отдалённой вершине.
Четырёхмерный куб работает аналогичным образом —  вершин обозначены векторами, содержащими все сочетания двоичных цифр, начиная  и заканчивая . Это описание на самом деле обобщается до  измерений, где каждая вершина имеет -битный вектор координат. Если мы будем измерять расстояние по манхэттанской метрике — всегда перемещаясь вдоль рёбер куба и никогда не срезая по диагонали — то расстояние между любыми двумя векторами будет количеством позиций, в которых отличаются два вектора координат (оно также известно как расстояние Хэмминга). (Для исключающего ИЛИ обычно используют символ ⊕, иногда называемый *булочкой (bun)*. Он отображает операцию XOR как двоичное сложение по модулю 2. Канерва предпочитает ∗ или ⊗ на том основании, что роль XOR в высокоразмерных вычислениях больше похожа на умножение, чем на сложение. Я решил устраниться от этого противоречия, воспользовавшись символом ⊻ — альтернативным способом записи XOR, привычным в среде логиков. Это модификация ∨ — символа включающего ИЛИ. Удобно, что он также является символом XOR в программах на Julia.) Таким образом, единицей измерения расстояния является один бит, а вычисление расстояния — это задача для оператора двоичного исключающего ИЛИ (XOR, ⊻), который даёт нам для отличающихся битов значение , а для одинаковых пар — значение :
```
0 ⊻ 0 = 0
0 ⊻ 1 = 1
1 ⊻ 0 = 1
1 ⊻ 1 = 0
```
Функция на Julia для измерения расстояния между вершинами применяет функцию XOR к двум векторам координат и возвращает в качестве результата количество .
```
function distance(u, v)
w = u ⊻ v
return count_ones(w)
end
```
Когда  становится достаточно большим, проявляются некоторые любопытные свойства -куба. Рассмотрим -мерный куб, имеющий  вершин. Если случайным образом выбрать две его вершины, то каким будет ожидаемое расстояние между ними? Хотя это и вопрос о расстоянии, но мы можем ответить на него, не углубляясь в геометрию — это всего лишь задача подсчёта позиций, в которых различаются два двоичных вектора. Для случайных векторов каждый бит может быть с равной вероятностью быть равным  или , поэтому ожидается, что векторы будут различаться в половине битовых позиций. В случае -битного вектора стандартное расстояние равно  битам. Такой результат нас не удивляет. Однако *стоит* заметить то, что все расстояния между векторами тесно скапливаются вокруг среднего значения в 500.
В случае -битных векторов почти все случайно выбранные пары находятся на расстоянии от  до  бит. В выборке из ста миллионов случайных пар *(см. график выше)* ни одна из них не ближе, чем  бит или дальше, чем  бит. Ничто в нашей жизни в пространстве низкого разрешения не готовило нас к такому скоплению вероятностей в среднем расстоянии. Здесь, на Земле, мы можем найти место, в котором будем совсем одни, когда почти все находятся в нескольких тысячах километров от нас; однако нет никакого способа перераспределить население планеты таким образом, чтобы *каждый* одновременно находится в таком состоянии. Но в -мерном пространстве ситуация именно такова.
Не стоит и говорить, что сложно представить себе -мерный куб, но мы можем приобрести небольшое интуитивное понимание геометрии хотя бы на примере пяти измерений. Ниже представлена таблица всех координат вершин в пятимерном кубе единичной размерности, выстроенных в соответствии с расстоянием Хэмминга от исходной точки . Большинство вершин (20 из 32) находится на средних расстояниях — два или три бита. Таблица имела бы одинаковую форму при любой другой вершине, взятой в качестве исходной точки.
Серьёзное возражение всем этим обсуждениям -мерных кубов заключается в том, что мы никогда не сможем построить нечто подобное; во Вселенной недостаточно атомов для структуры из  частей. Но Канерва указывает на то, что нам нужны пространства для хранения только тех элементов, которые мы хотим хранить. Мы можем сконструировать оборудование для случайной выборки, например  вершин (каждая из которых имеет -битный адрес) и оставить остальную часть куба призрачной, недостроенной инфраструктурой. Канерва называет такое подмножество вершин, существующее в «железе», *твёрдыми ячейками (hard locations)*. Множество из  случайных твёрдых ячеек всё равно будет демонстрировать то же сжатое распределение расстояний, что и полный куб; именно это и показано на графике выше.
Относительная изоляция каждой вершины в высокоразмером кубе даёт нам намёк на одно возможное преимущество разряжённой распределённой памяти: у хранящегося элемента есть достаточно простора и он может распределяться по обширной области, не мешая своим соседям. Это действительно выдающаяся характеристика SDM, но есть и кое-что ещё.
---
В традиционной компьютерной памяти адреса и хранимые элементы данных сопоставляются один к одному. Адреса — это порядковые целые числа фиксированного диапазона, допустим . Каждое целое число в этом диапазоне определяет единственное отдельное место в памяти, и каждое место связано ровно с одним адресом. Кроме того, в каждом месте одновременно хранится только одно значение; при записи нового значения старое переписывается.
SDM нарушает все эти правила. Она обладает огромным адресным пространством — не менее  — но только крошечная, случайная доля этих мест существует как физические сущности; именно поэтому память называется *разреженной*. Отдельный элемент информации не хранится всего в одном месте памяти; множество копий распределено по области — поэтому она *распределённая*. Более того, в каждом отдельном адресе может одновременно храниться несколько элементов данных. То есть информация и размазана по широкой области, и втиснута в одну точку. Такая архитектура также размывает различия между адресами памяти и содержимым памяти; во многих случаях сохраняемый битовый паттерн используется в качестве собственного адреса. Наконец, память может отзываться на частичный или приблизительный адрес и с высокой вероятностью находить правильный элемент. В то время как традиционная память является «механизмом точного совпадения», SDM — это «механизм наилучшего совпадения», возвращающий элемент, наиболее схожий с запрошенным.
В своей книги 1988 года Канерва даёт подробный количественный анализ разреженной распределённой памяти с  измерениями и  твёрдых ячеек. Твёрдые ячейки выбираются случайным образом из всего пространства  возможных векторов адресов. Каждая твёрдая ячейка имеет пространство для хранения множества -битных векторов. Память в целом рассчитана на хранение не менее  уникальных паттернов. Ниже я буду рассматривать эту память как каноническую SDM-модель, несмотря на то, что по стандартам млекопитающих она маловата, и в более новой своей работе Канерва сделал упор на векторы не менее чем с  измерений.
Вот как работает память в простой компьютерной реализации. Команда `store(X)` записывает в память вектор , считая его одновременно и адресом, и содержимым. Значение  сохраняется во все твёрдые ячейки, находящиеся в пределах определённого расстояния до . В канонической модели это расстояние равно 451 битам. Оно задаёт «круг доступа», предназначенного для объединения в себе примерно  твёрдых ячеек; иными словами, каждый вектор хранится примерно в -ной из миллиона твёрдых ячеек.
Важно также заметить, что хранимый элемент  не обязательно выбирать из  двоичных векторов, являющихся адресами твёрдых ячеек. Напротив.  может быть любым из  возможных двоичных паттернов.
Предположим, что в SDM уже записана тысяча копий , после чего поступает новый элемент , который тоже нужно сохранить в собственном множестве из тысячи твёрдых ячеек. Между двумя этими множествами может быть пересечение — места, в которых хранятся и , и . Новое значение не перезаписывает и не заменяет предыдущее; оба значения сохраняются. Когда память заполняется до своей ёмкости в , каждый из них сохранён  раз, а в типичной твёрдой ячейке будут храниться копии  уникальных паттернов.
Теперь вопрос заключается в следующем: как же нам воспользоваться этой перемешанной памятью? В частности, как нам получить правильное значение , не влияя на  и на все остальные элементы, накопившиеся в одном месте хранения?
В алгоритме считывания будет использоваться свойство любопытного распределения расстояний в высокоразмерном пространстве. Даже если  и  являются ближайшими соседями из  хранящихся паттернов, они скорее всего будут отличаться на 420 или 430 бит; поэтому количество твёрдых ячеек, в которых хранятся оба значения, достаточно мало — обычно четыре, пять или шесть. То же самое относится и ко всем другим паттернам, пересекающимся с . Их тысячи, но ни один из влияющих паттернов не присутствует более чем в нескольких копиях внутри круга доступа .
Команда `fetch(X)` должна возвращать значение, ранее записанное командой `store(X)`. Первый этап в воссоздании значения — это сбор всей информации, хранящейся внутри 451-битного круга доступа, центрированного на . Поскольку  ранее был записан во все эти места, мы можем быть уверены, что получим  его копий. Мы также получим около  копий *других* векторов, хранящихся в местах, в которых круги доступа пересекаются с с кругами . Но поскольку пересечения малы, каждый из этих векторов присутствует только в нескольких копиях. Тогда в целом каждый из их  бит равновероятно может быть  или . Если мы применим функцию принципа большинства ко всем данным, собранным в каждой битовой позиции, то в полученном результате будут доминировать  копий . Вероятность получения отличающегося от  результата примерно равна .
Процедура принципа большинства подробнее показана ниже на небольшом примере из пяти векторов данных по 20 битов каждый. Выходными данными будет являться другой вектор, каждый бит которого отражает большинство соответствующих битов в векторах данных. (Если количество векторов данных чётное, то «ничьи» разрешаются случайным выбором  или .) Альтернативная схема записи и чтения, показанная ниже, отказывается от хранения всех паттернов по отдельности. Вместо этого она хранит итоговое количество битов  и  в каждой позиции. Твёрдая ячейка имеет -битный счётчик, инициализируемый всеми нулями. При записи паттерна в место каждый битовый счётчик увеличивается для  или уменьшается для . Алгоритм считывания просто смотрит на знак каждого битового счётчика, возвращая  для положительного значения,  для отрицательного и случайное значение, когда бит счётчика равен .
Две эти схемы хранения дают идентичные результаты.
---
С точки зрения вычислительной техники эта версия разреженной распределённой памяти выглядит как тщательно продуманная шутка. Для запоминания  элементов нам понадобится миллион твёрдых ячеек, в которых мы будем хранить тысячу избыточных копий каждого паттерна. Для извлечения всего одного элемента из памяти мы собираем данные по  сохранённым паттернам и применяем для их распутывания механизм принципа большинства. И всё это выполняется с помощью кучи акробатических маневров только для получения вектора, который у нас и так уже есть. Традиционная память работает гораздо менее хаотично: и запись, и считывание получают доступ к одному месту.
Но SDM может делать то, на что неспособна традиционная память. В частности, она может извлекать информацию на основе частичных или приблизительных данных. Допустим, вектор  является повреждённой версией , в котором изменились  из  векторов. Поскольку два вектора схожи, команда `fetch(Z)` посетит множество из тех же мест, в которых хранится . При расстоянии Хэмминга в 100 можно ожидать, что у  и  будут общими примерно 300 твёрдых ячеек. Благодаря этому большому пересечению вектор, возвращаемый `fetch(Z)` (назовём его ) будет ближе к , чем является . Теперь мы можем повторить этот процесс с командой `fetch(Z′)`, который вернёт результат , ещё более близкий к . Всего через несколько итераций процедура достигнет самого .
Канерва показал, что сходящаяся последовательность рекурсивных операций считывания приведёт к успеху с почти полной уверенностью, если начальный паттерн не слишком далёк от целевого. Другими словами, существует критический радиус: любая проверка памяти, начиная с места внутри критического круга почти совершенно точно сойдётся к центру, и сделает это довольно быстро. Попытка восстановления элемента, хранящегося за пределами критического круга, закончится неудачей, поскольку рекурсивный процесс вспоминания будет отдаляться на среднее расстояние. В анализе Канерва показано, что для канонической SDM критический радиус равен 209 битам. Другими словами, если мы знаем приблизительно 80 процентов битов, то сможем воссоздать весь паттерн.
На иллюстрации ниже отслеживается эволюция последовательностей рекурсивных воспоминаний с помощью исходных сигналов, отличающихся от целевого  на . В этом эксперименте все последовательности, начинающиеся с расстояния  или менее, сходятся к  за  или менее итераций *(синие следы)*. Все последовательности, начинающиеся при бОльшем исходном расстоянии, бесцельно блуждают по огромным пустым пространствам -мерного куба, оставаясь примерно в 500 битах от любого места.
Переход от сходящихся к расходящимся траекториями не идеально чёток, и это заметно на показанном ниже растрёпанном графике. Здесь мы увеличили масштаб, чтобы посмотреть на судьбу траекторий, начинающихся со смещений в  бит. Все начальные точки, находящиеся в пределах 209 бит от цели, обозначены синим; начинающиеся с бОльшего расстояния — оранжевые. Большинство из синих траекторий сходится, быстро переходя к нулевому расстоянию, а большинство оранжевых — нет. Однако вблизи от критического расстояния есть множество исключений.
На показанном ниже графике изображён ещё один взгляд на то, как исходное расстояние от цели влияет на вероятность схождения к верному адресу памяти. При расстоянии в  бит успехом оканчиваются почти все попытки; при  почти все неудачны. Похоже, что точка пересечения (в которой успех и неудача равновероятны) лежит примерно в  битах, немного ниже результата Канерва, равного . (В этом расхождении нет ничего загадочного. В вычислениях Канерва предполагается круг доступа ограничивающий ровно  твёрдых ячеек. В мои эксперименты включены все твёрдые ячейки в пределах расстояния ; в среднем существует  таких мест.)
---
Способность воссоздания воспоминаний из частичной информации — знакомый всем элемент человеческой жизни. Вы замечаете актёра в телешоу, и понимаете, что видели его раньше, но не помните, где. Через несколько минут до вас доходит: это мистер Бейтс из *«Аббатства Даунтон»*, но без костюма дворецкого. Встреча выпускников старшей школы: глядя плотного лысеющего джентльмена на другом конце комнаты, сможете ли вы узнать в нём друга, которого знали только как подростка в спортивных шортах? Иногда на заполнение пробелов требуются длительные усилия. Я уже [писал](http://bit-player.org/2013/the-wisterium-of-memory) о собственном необъяснимом «слепом пятне» в памяти о выращивании глициний, которые я смог назвать только после терпеливого перелистывания каталога поддельных запахов: гортензии, вербены, форзиции.
Может ли наше умение восстанавливать воспоминания из неполных или зашумлённых входных данных работать подобно рекурсивному процессу вспоминания высокоразмерных векторов? Это было бы привлекательной гипотезой, однако есть причины относиться к ней настороженно. Например, мозг, похоже, способен извлекать смысл из гораздо более скудных сигналов. Мне не нужно прослушивать четыре пятых «Пятой симфонии», чтобы опознать её, достаточно первых четырёх нот. Мелькнувший в деревьях цвет мгновенно заставляет вспомнить соответствующие виды птиц — кардинала, голубую сойку, щегла. Малейшее дуновение с запахом меловой пыли переносит меня обратно в усыпляющий душный класс, в котором я полдня рисовал за партой. Такие воспоминания вызываются крошечными долями представляющей их информации, гораздо меньшими, чем 80 процентов.
Канерва упоминает ещё одну особенность человеческой памяти, которую можно смоделировать при помощи SDM: феномен «вертится на кончике языка», суть которого в том, что вы знаете, что что-то знаете, хотя и не можете сразу же назвать это. Это ощущение довольно загадочно: если вы не можете найти то, что искали, как можно знать, что оно всё такие хранится в мозгу? Рекурсивный процесс вспоминания из SDM предлагает нам возможный ответ. Когда последовательные паттерны, извлекаемые из памяти, становится постоянно ближе друг к другу, мы резонно можем быть уверены в том, что они сойдутся к цели ещё до того, как они до неё добрались.
В попытках извлечения упорного факта из памяти многие люди обнаруживают, что постоянно стучать в одну и ту же дверь — не самая мудрая стратегия. Вместо того, чтобы требовать немедленных ответов — командовать своим мозгом — часто лучше отложить задачу в сторону, прогуляться, возможно, вздремнуть; ответ может прийти, как будто он был незванным. Можно ли объяснить это наблюдение SDM-моделью? Возможно, по крайней мере, частично. Если последовательность вспоминаемых паттернов не сходится, то дальнейшее её исследование может оказаться бесплодным. Если начать заново с соседней точки в пространстве памяти, то можно прийти к более хорошему результату. Но тут есть загадка: как найти новую отправную точку с более хорошими перспективами? Можно подумать, что достаточно просто случайным образом заменить несколько битов во входном паттерне и надеяться, что в результате он окажется ближе к цели, но вероятность этого мала. Если вектор находится в  битах от цели, то  битов уже верны (но мы не знаем, *какие* из  бит); при любом случайном изменении мы имеем вероятность в  не приблизиться, а уйти ещё дальше. Чтобы добиться прогресса, нужно знать, в каком направлении двигаться, а в -мерном пространстве это сложный вопрос.
Один из аспектов архитектуры SDM заключается в том, что она, похоже, соответствует эффекту повторения или повторного прослушивания для памяти. Если несколько раз повторить стихотворение или практиковаться в исполнении музыкального произведения, то можно ожидать, что в будущем вы запомните его легче. Вычислительная модель должна демонстрировать аналогичный эффект тренировки. Но в традиционной компьютерной памяти это невозможно: нет никаких преимуществ в перезаписи одного и того же значения несколько раз по одному и тому же адресу. В SDM же, напротив, каждое повторение паттерна добавляет ещё одну копию ко всем твёрдым ячейкам в пределах круга доступа паттерна. В результате возникает меньше влияния от пересекающихся паттернов, а критический радиус вспоминания увеличивается. Эффект оказывает значительное влияние: при записи в память единственной копии паттерна критический радиус увеличивается с примерно  бит до более чем .
Аналогично, воспроизведение одного паттерна может усложнить восстановление остальных. Это напоминает забывание, когда активно запечатляемый паттерн заполняет своих соседей и захватывает часть их территории. Этот эффект тоже значительно влияет на SDM, настолько, что это даже кажется нереальным. Похоже, что вектор, сохранённый восемь или десять раз, монополизирует бОльшую часть памяти; он становится одержимостью, ответом на все вопросы.
Важное преимуещство разреженной распределённой памяти заключается в её устойчивости к аппаратным сбоям или ошибкам. Я был бы расстроен, если бы утеря единственного нейрона в моём мозгу оставляла дыру в памяти, и я не мог бы распознать букву *g* или вспомнить, как завязывать шнурки. SDM не страдает от подобной хрупкости. Когда у каждого хранящегося паттерна есть тысяча копий, ни одно место не является принципиальным. И в самом деле, можно стереть всю информацию, хранящуюся в 60 процентах твёрдых ячеек, и всё равно иметь идеальное вспоминание , если считать, что мы передаём в качестве сигнала абсолютно точный адрес. При частичных сигналах критический радиус сжимается при увеличении потерянных мест. После уничтожения 60 процентов мест критический радиус сжимается с  бит до примерно  бит. После уничтожения 80 процентов мест память оказывается серьёзно повреждена, но не уничтожена.
А как насчёт витания в облаках? Можем ли мы праздно блуждать по лугам разреженной распределённой памяти, по счастливой случайности перепрыгивая от одного хранимого паттерна к другому? Я вернусь к этому вопросу.
---
БОльшая часть изложенного выше написана несколько недель назад. В то время я читал о различных конкурирующих теориях памяти и обсуждал их достоинства с коллегами из Института Саймонса. Я записал свои мысли на эту тему, но отложил их публикацию из-за неотступных сомнений: правильно ли я понял математику разреженной распределённой памяти? Теперь я рад, что не торопился.
Программа «Мозг и вычисления» завершилась в мае. Её участники разъехались: я вернулся в Новую Англию, где шалфей и розмарин — это небольшие горшечные растения, а не нависающие над дорожками пышные кусты. Мои утренние прогулки к кампусу в Беркли, ежедневные возможности поразмыслить о природе памяти и обучения, стали «энграммами», хранящимися где-то в моей голове (однако я всё ещё не знаю, где их искать).
Однако я не отказался от своих поисков. После отъезда из Беркли я продолжил читать о теориях памяти. Также я писал программы для изучения разреженной распределённой памяти Пентти Канерва и его более пространных идей «гиперпространственных вычислений». Даже если этому проекту не удастся открыть мне секреты человеческой памяти, он определённо научит меня чему-то о математическом и вычислительном искусстве навигации в высокоразмерных пространствах.
На схеме ниже показан «правильный» способ реализации SDM, насколько я её понимаю. Основной элемент — это перекрёстная матрица, в которой строки соответствуют твёрдым ячейкам памяти, а столбцы переносят сигналы, имитирующие отдельные биты входного вектора. В канонической памяти миллион строк, каждой из которых случайным образом назначен -битный адрес, и  столбцов; эта демонстрационная версия состоит из 20 строк и 8 столбцов.
Проиллюстрированный на схеме процесс заключается в сохранении одного входного вектора в пустую память. Восемь входных битов одновременно сравниваются со всеми 20 адресами твёрдых ячеек. Когда входной бит и бит адреса совпадают — ноль с нулём или единица с единицей — мы ставим на пересечении столбца и строки точку. Затем мы считаем количество точек в каждой строке, и если количество равно или превышает пороговое значение, то мы записываем входной вектор в регистр, связанный с этой строкой *(синие поля)*. В нашем примере пороговое значение равно 5, и в 8 из 20 адресов есть не менее 5 совпадений. В -битной памяти пороговое значение будет равно , а выбраны окажутся всего около одной тысячной всех регистров.
Волшебство этой архитектуры в том, что все сравнения битов — а в канонической модели их миллиард — происходят одновременно. Поэтому время доступа для чтения и записи не зависит от количества твёрдых ячеек и может быть очень малым. Такая компоновка общего типа, известная как ассоциативная память или память с адресацией по содержимому, используется в некоторых вычислительных областях, таких как включение детекторов частиц в Большом адронном коллайдере и передача пакетов через маршрутизаторы в Интернете. И схему цепи можно связать с определёнными структурами мозга. Канерва указывает на то, что на такую матрицу очень похож мозжечок. Строки — это плоские, веерообразные клетки Пуркинье, собранные наподобие страниц книги; столбцы — это параллельные волокна, протянувшиеся по всем клеткам Пуркинье. (Однако мозжечок — это не область мозга млекопитающих, где, как считается, находится когнитивная память.)
Было бы здорово построить SDM-симуляцию на основе этой перекрёстной архитектуры; к сожалению, я не знаю, как реализовать её на имеющемся в моём распоряжении компьютерном оборудовании. В традиционном процессоре нет способов для одновременного сравнения всех входных битов с битами твёрдых ячеек. Вместо этого мне приходится последовательно проходить по миллиону твёрдых ячеек, и в каждом месте сравнивать тысячи пар битов. Это составляет миллион сравнений битов для каждого элемента, сохраняемого или извлекаемого из памяти. Добавьте к этому время на запись или чтение миллиона бит (тысячи копий -битного вектора), и у вас получится довольно медленный процесс. Вот код для сохранения вектора:
```
function store(v::BitVector)
for loc in SDM
if hamming_distance(v, loc.address) <= r
write_to_register!(loc.register, v)
end
end
end
```
Этой реализации требуется около часа на инвентаризацию памяти с  запомненными паттернами. (Полная программа в виде Jupyter notebook выложена [на GitHub](https://github.com/bit-player/sdm-julia).)
Существует ли более хороший алгоритм для симуляции SDM на обычном «железе»? Одна из возможных стратегий позволяет избежать повторяющегося поиска набора твёрдых ячеек в пределах круга доступа заданного вектора; вместо этого, когда вектор впервые записывается в память, программа сохраняет указатель на каждое из тысячи или около того мест, в которых он хранится. В дальнейшем при любой ссылке на тот же вектор программа может проследовать по  сохранённых указателей, а не сканировать весь массив из миллиона твёрдых ячеек. Цена этой схемы с кэшированием заключается в необходимости хранения всех этих указателей — в канонической SDM их  миллионов. Это вполне реально, и может стоить того, если вы хотите хранить и извлекать только точные, известные значения. Но подумайте, что произойдёт в ответ на приблизительный запрос памяти с рекурсивным вспоминанием  и  и , и так далее. Ни одно из этих промежуточных значений не будет найдено в кэше, поэтому всё равно потребуется полное сканирование всех твёрдых ячеек.
Возможно, здесь есть и более хитрая возможность срезать путь. В недавней обзорной статье "[Approximate Nearest Neighbor Search in High Dimensions](https://arxiv.org/abs/1806.09823)" Александра Андони, Петра Индыка и Ильи Разенштейна упоминается интригующая техника под названием locality sensitive hashing (хэширование с учётом локальности), но пока я не совсем понимаю, как адаптировать её под задачу SDM.
---
Способность восстанавливать воспоминания по частичным сигналам — это до боли человеческая особенность вычислительной модели. Возможно, её можно расширить для получения правдоподобного механизма праздного блуждания по чертогам разума, при котором одна мысль приводит к следующей.
Сначала я думал, что знаю, как это может работать. Хранящийся в SDM паттерн  создаёт вокруг себя область притяжения, в которой любое рекурсивное исследование памяти начиная с критического радиуса сойдётся к . При  таких аттракторах я могу представить, как они разбивают пространство памяти на матрицу отдельных модулей наподобие высокоразмерной пены из мыльных пузырей. Область для каждого хранящегося элемента занимает отдельный объём, окружённый со всех сторон другими областями и упирающийся в них, с чёткими границами между соседними доменами. В поддержку такого суждения я могу заметить, что средний радиус области притяжения при добавлении в память нового содержимого сжимается, как если бы пузыри сжимались из-за скученности.
Такое видение процессов внутри SDM предполагает наличие простого способа перемещения от одного домена в другой: нужно случайным образом переключить достаточное количество бит вектора, чтобы переместить его из пределов текущей области притяжения в соседнюю, а затем применить алгоритм рекурсивного вспоминания. Повторение этой процедуры сгенерирует случайный обход множества тем, хранящихся в памяти.
Единственная проблема в том, что такой подход не работает. Если проверить его, то он и в самом деле будет бесцельно блуждать по  мерной решётке, но мы никогда не найдём ничего, хранящегося там. Весь план основан на ошибочном интуитивном понимании геометрии SDM. Хранящиеся векторы с их областями притяжения *не* упакованы плотно подобно мыльным пузырям; напротив, они являются изолированными галактиками, висящими в обширной и свободной вселенной, разделённые огромными участками пустого пространства между ними. Краткие вычисления показывают нам истинную природу ситуации. В канонической модели определяющий область притяжения критический радиус приблизительно равен . Объём отдельной области, измеренный как количество находящихся внутри векторов, равен
что примерно равно . Поэтому все  областей занимают объём . Это большое число, но оно всё равно является крошечной долей -мерного куба. Среди всех вершин куба только  из  лежит в пределах 200 бит сохранённого паттерна. Можно вечно блуждать, так и не наткнувшись ни на одну из этих областей.
(Вечно? Ох, ну да, может быть и не вечно. Поскольку гиперкуб — это конечная структура, любой путь через него рано или поздно обязан стать периодичным, или попав в фиксированную точку, из которой никогда никогда не выйдет, или заблудившись в повторяющемся цикле. Хранящиеся векторы являются фиксированными точками, кроме того, существует множество других фиксированных точек, не соответствующих никакому значимому паттерну. Как бы то ни было, во всех моих экспериментах с программами SDM мне ни разу не удавалось «случайно» попасть в сохранённый паттерн.)
Пытаясь спасти эту неудачную идею, я провёл ещё несколько экспериментов. В одном случае я произвольно сохранял несколько связанных концепций в соседние адреса («соседние», то есть
в пределах 200 или 300 бит). Возможно, в пределах этого кластера я смогу беззаботно перескакивать из точки в точку. Но на самом деле весь кластер сгущается в одну большую область притяжения для центрального паттерна, который становится чёрной дырой, всасывающей в себя всех своих компаньонов. Также я попробовал поиграться со значением  (радиусом круга доступа для всех операций считывания и записи). В канонической модели . Я подумал, что запись в чуть меньший круг или считывание из чуть большего круга оставит достаточно пространства для случайности в результатах, но эта надежда тоже не оправдалась.
Все эти попытки основывались на неправильном понимании высокоразмерных пространств векторов. Попытка нахождения кластеров соседних значений в гиперкубе безнадёжна; хранимые паттерны слишком разнесены по объёму. Произвольное создание плотных кластеров тоже бессмысленно, потому что это разрушает само то свойство, делающее систему интересной — способность сходиться к хранящемуся элементу из любой точки окружающей его области притяжения. Если мы хотим создать алгоритм витания в облаках для SDM, то необходимо придумать какой-то другой способ.
---
В поисках альтернативного механизма потока сознания можно попробовать добавить в мир разреженной распределённой памяти немного теории графов. Тогда мы сможем сделать шаг назад, обратно к исходной идее умственных блужданий в виде случайного обхода графа или сети. Ключевой элемент для встраивания таких графов в SDM оказывается знакомым нам инструментом: оператором исключающего ИЛИ.
Как сказано выше, расстояние Хэмминга между двумя векторами вычисляется взятием их побитового XOR и подсчётом в получившемся результате единиц. Но операция XOR даёт не просто расстояние между двумя векторами, но и другую информацию; она также определяет ориентацию или направление соединяющей их линии. В частности, операция  даёт вектор, перечисляющий биты, которые нужно изменить для преобразования  в  и наоборот. Также можно воспринимать  и  в векторе XOR как последовательность направлений, по которым нужно следовать для отслеживания пути от  до .
XOR всегда была моей самой любимой из всех булевых функций. Это разностный оператор, но в отличие от вычитания, XOR симметричен: . Более того, XOR является своей собственной обратной функцией. Эту концепцию легко понять при помощи функций с единственным аргументом:  является собственной обратной функцией, если , то есть после применения функции дважды мы можем вернуться к тому, с чего начали. Для функции с двумя аргументами, таких как XOR, ситуация сложнее, но по-прежнему истинно то, что выполнение одинакового действия дважды восстанавливает исходное состояние. В частности, если , то  и . Три вектора — ,  и  — создают крошечную замкнутую вселенную. К любой паре из них можно применить оператор XOR и получить третий элемент множества. Ниже показана моя попытка проиллюстрировать эту идею. Каждый квадрат имитирует -битный вектор, выстроенных как таблица 100 x 100 из светлых и тёмных пикселей. Три паттерна кажутся случайными и независимыми, но на самом деле каждая панель является XOR двух других. Например, в самом левом квадрате каждый красный пиксель соответствует или зелёному, или синему, но никогда обоим.
Свойство самоинвертируемости подсказывает нам новый способ упорядочивания информации в SDM. Допустим, слово *butterfly* и его французский аналог *papillon* хранятся в произвольных, случайных векторах. Они не будут близки друг к другу; расстояние между ними с большой вероятностью примерно равна 500 битам. Теперь мы вычисляем XOR этих векторов *butterfly*  *papillon*; результатом является ещё один вектор, который также можно сохранить в SDM. Этот новый вектор кодирует связь *английский-французский*. Теперь у нас есть инструмент для перевода. Имея вектор для *butterfly*, мы выполняем для него XOR с вектором *английский-французский* и получаем *papillon*. Тот же трюк работает и в обратном направлении.
Эта пара слов и связь между ними формируют ядро семантической сети. Давайте немного увеличим её. Мы можем сохранить в произвольном адресе слово *caterpillar*, а затем вычислить *butterfly*  *caterpillar* и назвать эту новую связь *взрослый-юный*. Как по-французски называется *caterpillar*? Гусеница по-французски — это *chenille*. Мы добавляем этот факт в сеть, сохраняя *chenille* по адресу *caterpillar*  *English-French*. Теперь настало время волшебства: если мы возьмём *papillon*  *chenille*, то узнаем, что эти слова связаны соотношением *взрослый-юный*, даже несмотря на то, что явным образом этого не указывали. Это ограничение накладывается самой геометрией конструкции.
Граф можно расширять и дальше, добавляя больше англо-французских родственных слов (*dog-chien, horse-cheval*) или больше пар «взрослый-юный»: (*dog-puppy, tree-sapling*). Можно также исследовать множество других связей: синонимы, антонимы, сиблинги, причина-следствие, хищник-жертва и так далее. Существует также отличный способ соединения множества событий в хронологическую последовательность простым выполнением XOR для адресов предшественника и последователя узла.
Способ соединения концепций через XOR — это гибрид геометрии и теории графов. В математической теории обычных графов расстояния и направления несущественны; единственное, что важно — наличие или отсутствие соединяющих рёбер между узлами. С другой стороны, в SDM представляющее связь между узлами ребро является вектором конечной длины и направленности в -мерном пространстве. При заданном узле и связи операция XOR «привязывает» этот узел к конкретной позиции где-то в другом месте гиперкуба. Получающаяся структура абсолютно жёсткая — мы не можем переместить узел, не изменив все связи, в которых он участвует. В случае с бабочками и гусеницами конфигурация из четырёх узлов неизбежно оказывается параллелограммом, где пары на противоположных сторонах имеют одинаковую длину и направленность.
Ещё одной уникальной характеристикой связанного операцией XOR графа является то, что узлы и рёбра имеют абсолютно одинаковое представление. В большинстве компьютерных реализаций идей из теории графов, эти две сущности очень отличаются; узел может быть списком атрибутов, а ребро — парой указателей на соединяемые им узлы. В SDM и узлы, и рёбра являются просто высокоразмерными векторами, которые можно хранить в одинаковом формате.
При использовании в качестве модели человеческой памяти XOR-привязки даёт нам возможность соединения любых двух концепций через любую связь, которую мы можем придумать. Множество связей в реальном мире несимметрично; они не имеют свойства самоинвертируемости, которое есть у XOR. Вектор XOR может объявлять, что Эдвард и Виктория являются родителем и ребёнком, но не сообщает, кто из них кто. Хуже того, вектор XOR соединяет ровно два узла и никогда больше, поэтому родитель нескольких детей ставит нас в неприятное положение. Ещё одна сложность заключается в сохранении целостности всех ветвей большого графа друг с другом. Мы не можем просто произвольно добавлять узлы и рёбра; их необходимо присоединить к графу в правильном порядке. Вставка стадии куколки между бабочкой и гусеницей потребует переписывания большей части схемы; придётся переместить несколько узлов в новые места внутри гиперкуба и пересчитать соединяющие их векторы связей, при этом сделав так, чтобы каждое изменение на стороне английского языка правильно отразилось и на французской.
Некоторые из этих проблем решаются в другой технике на основе XOR, которую Канерва называет бандлингом (bundling). Идея заключается в создании некой базы данных для хранения пар «атрибут-значение». Запись для книги может иметь такие атрибуты, как *author*, *title* и *publisher*, каждое из которых спарено с соответствующим значением. Первый этап бандлинга данных заключается отдельном XOR каждой пары «атрибут-значение». Затем векторы, полученные из этих операций, комбинируются для создания единого суммарного вектора с помощью того же алгоритма, описанного выше для хранения нескольких векторов в твёрдой ячейке SDM. Выполняя XOR имени атрибута с этим комбинированным вектором, мы получаем аппроксимацию соответствующего значения, достаточно близкое для того, чтобы определить его методом рекурсивного вспоминания. В экспериментах с канонической моделью я выяснил, что -битный вектор может хранить шесть или семь пар «атрибут-значение» без особого риска путаницы.
Привязка и бандлинг не упоминаются в книге Канерва 1988 года, но он подробно рассказывает о них в более новых статьях. (См. ниже раздел «Дополнительное чтение».) Он указывает на то, что с этими двумя операторами множество высокоразмерных векторов приобретает структуру алгебраического поля, или, по крайней мере, приближения к полю. Канонический пример поля — это множество вещественных чисел вместо с операциями сложения и умножения, а также их обратных операторов. Вещественные числа создают под этими операциями замкнутое множество: сложение, вычитание, умножение или деление любых двух вещественных чисел даёт ещё одно вещественное число (за исключением деления на ноль, которое всегда является джокером в колоде). Аналогично, множество двоичных векторов является замкнутым для связывания и бандлинга, за исключением того, что иногда для восстановления члена множества результат, извлечённых из бандлинг-вектора нужно «очистить» процессом рекурсивного вспоминания.
---
Могут ли связывание и бандлинг помочь нам в получении алгоритма витания в облаках? Они дают нам базовые инструменты для навигации по семантическому графу, в том числе возможность выполнения случайного обхода. Начиная с любого узла в связанном XOR графе, алгоритм случайного обхода выбирает среди всех связей, имеющихся в этом ужле. Случайный выбор вектора связи и выполнение XOR этого вектора с адресом узла приводит нас к другому узлу, где процедуру можно повторить. Аналогичным образом, в парах «атрибут-значение» бандлинга случайно выбранный атрибут вызывает соответствующее значение, которое становится следующим исследуемым узлом.
Но как алгоритм узнаёт, какие связи или какие алгоритмы доступны для выбора? Связи и атрибуты представлены в форме векторов и хранятся в памяти как и любые другие объекты, поэтому не существует очевидных способов получения этих векторов, если только не знать, какие они на самом деле. Мы не можем сказать памяти «покажи мне все связи». Мы можем только показать паттерн и спросить «есть ли такой вектор? видела ли ты что-то подобное?»
В традиционной компьютерной памяти мы можем получить дамп памяти: пройтись по всем адресам и вывести значение, найденное в каждом месте. Но для распределённой памяти такой процедуры нет. Мне этот удручающий факт дался с трудом. При построении вычислительной модели SDM мне удалось добиться достаточно хорошей работы, чтобы получить возможность хранить в памяти несколько тысяч случайно сгенерированных паттернов. Но я не мог извлекать их, потому что не знал, что запрашивать. Решение заключалось в создании отдельного списка за пределами самой SDM, в который бы записывалось всё, что я сохраняю. Но предположение о том, что мозг хранил бы и память, и индекс этой памяти, кажется надуманным. Почему не использовать просто индекс, ведь это намного проще?
Ввиду этого ограничения похоже, что разреженная распределённая память оборудована для обслуживания чувств, но не воображения. Она может распознавать знакомые паттерны и сохранять новые, которые будут распознаваться при следующих встречах даже из частичных или повреждённых сигналов. Благодаря связыванию или бандлингу память также может отслеживать связи между парами сохранённых элементов. Но всё, что записывается в память, может быть извлечено только при передаче подходящего сигнала.
Когда я смотрю на постер *«Выпускника»*, то вижу Дастина Хоффмана, смотрящего на ногу Энн Бэнкрофт в чулке. Этот визуальный стимул возбуждает подмножества нейронов в коре головного мозга, соответствующие моим воспоминаниям об актёрах, персонажах, сюжете, саундтреке и 1967 годе. Всю эту активность мозга можно объяснить архитектурой памяти SDM, если мы допустим, что подмножества нейронов можно представить в некой абстрактной форме как длинные случайные двоичные векторы. Но нельзя так же просто объяснить то, что я могу вызвать в мозгу все те же ощущения, не видя этой картинки. Как я извлекаю конкретно эти длинные случайные последовательности из огромного переплетения векторов, не зная точно, где они находятся?
---
На этом моё долгое путешествие заканчивается — нотой сомнения и разочарования. Вряд ли вас удивляет, что мне не удалось добраться до самой сути. Это очень сложная тема.
В самый первый день программы «Мозг и вычисления» в Институте Саймонса Джефф Лихтман, работающий над трассировкой схемы коммутаций в мозгу мышей, задал вопрос: достигли ли уже нейронауки момента Уотсона-Крика? В молекулярной генетике мы достигли точки, в которой смогли излечь из живой клетки цепь ДНК и считать многие из сообщений в ней. Мы даже можем записывать собственные сообщения и вставлять их обратно в организм. Аналогичной способностью в нейронауках было бы исследование ткани мозга и считывание хранящейся в ней информации — знаний, воспоминаний, взглядов на мир. Возможно, мы могли бы даже записывать информацию непосредственно в мозг.
Наука даже близко не подошла к достижению этой цели, к радости многих. В том числе и меня: я не хочу, чтобы мои мысли были высосаны из головы через электроды или пипетки и заменены на #fakenews. Однако, мне *на самом деле* хочется знать, как работает мозг.
Программа Института Саймонса ослепила меня недавними успехами нейронаук, но также дала мне понять, что один из самых серьёзных вопросов остаётся неотвеченным. Проекты Лихтманна и других по коннектомике создают подробную карту из миллионов нейронов и их связей. Новые техники записи позволяют нам слушать сигналы, испускаемые отдельными нейроцитами и следовать за волнами возбуждения по широким областям мозга. У нас есть достаточно всеобъемлющий каталог типов нейронов и мы многое знаем об их физиологии и биохимии. Всё это впечатляет, но загадки всё ещё есть. Мы можем записывать нейросигналы, но по большей части мы не знаем, что они означают. Мы не знаем, как кодируется и хранится информация в мозгу. Это похоже на попытки понять принципиальную схему цифрового компьютера без знания двоичной арифметики и булевой логики.
Модель разреженной распределённой памяти Пентти Канерва — одна из попыток заполнения некоторых таких пробелов. Это не единственная такая попытка. Более известной альтернативой является подход Джона Хопфилда — концепция нейронной сети как динамической системы, принимающей форму минимизирующего энергию аттрактора. У этих двух идей есть общие базовые принципы: информация рассеяна по огромному количеству нейронов и закодирована в форме, неочевидной для внешнего наблюдателя, даже он получит доступ ко всем нейронам и проходящим по ним сигналам. Подобные схемы, по сути являющиеся математическими и вычислительными, концептуально находятся посередине между высокоуровневой психологией и низкоуровневой нейронной инженерией. В этом слое располагается значение.
**Дополнительное чтение**Hopfield, J. J. (1982). Neural networks and physical systems with emergent collective computational abilities. *Proceedings of the National Academy of Sciences* 79(8):2554–2558.
Kanerva, Pentti. 1988. *Sparse Distributed Memory*. Cambridge, Mass.: MIT Press.
Kanerva, Pentti. 1996. Binary spatter-coding of ordered *K*-tuples. In C. von der Malsburg, W. von Seelen, J. C. Vorbruggen and B. Sendhoff, eds. *Artificial Neural Networks—ICANN 96 Proceedings*, pp. 869–873. Berlin: Springer.
Kanerva, Pentti. 2000. Large patterns make great symbols: An example of learning from example. In S. Wermter and R. Sun, eds. *Hybrid Neural Systems*, pp. 194–203. Heidelberg: Springer. [PDF](https://pdfs.semanticscholar.org/620c/408dad8e3a7c66ade7027f964e6f01997b90.pdf)
Kanerva, Pentti. 2009. Hyperdimensional computing: An introduction to computing in distributed representation with high-dimensional random vectors. *Cognitive Computation* 1(2):139–159. [PDF](http://redwood.berkeley.edu/pkanerva/papers/kanerva09-hyperdimensional.pdf)
Kanerva, Pentti. 2010. What we mean when we say “What’s the Dollar of Mexico?”: Prototypes and mapping in concept space. Report FS-10-08-006, AAAI Fall Symposium on Quantum Informatics for Cognitive, Social, and Semantic Processes. [PDF](https://pdfs.semanticscholar.org/f477/232c0a0835dcbc4fc6b6283db484695482f9.pdf)
Kanerva, Pentti. 2014. Computing with 10,000-bit words. Fifty-second Annual Allerton Conference, University of Illinois at Urbana-Champagne, October 2014. [PDF](http://www.rctn.org/vs265/Kanerva-allerton2014.pdf)
Plate, Tony. 1995. Holographic reduced representations. IEEE Transactions on Neural Networks 6(3):623–641. [PDF](http://www2.fiit.stuba.sk/~kvasnicka/CognitiveScience/6.prednaska/plate.ieee95.pdf)
Plate, Tony A. 2003. *Holographic Reduced Representation: Distributed Representation of Cognitive Structure*. Stanford, CA: CSLI Publications. | https://habr.com/ru/post/419147/ | null | ru | null |
# yUML — средство для генерации UML диаграмм для веба
Обнаружил забавное средство для быстрой генерации UML-диаграм для вставки в блоги, статьи и прочее. Интересность в том, что для того, чтобы вставить диаграмму в статью, нужно просто указать ссылку на изображение, в которой и описываются сами классы, с помощью специального языка.
Например, такая ссылка:
``
Выглядит так:
Пока поддерживается только диаграммы классов и use-case'ов, а так же «неряшливый» режим рисования блоков. :) [Сайт проекта](http://yuml.me/).
Для больших диаграмм, конечно, не слишком удобно писать всё в одну строчку. Для решения проблемы можно, например, использовать простой препроцессор на JavaScript, объединяющий строки и вырезающий лишние пробелы. Вот пример, с использованием jQuery: [ссылка](http://www.tobinharris.com/past/2009/5/2/yuml-and-jquery-for-large-diagrams/). | https://habr.com/ru/post/59190/ | null | ru | null |
# Как применять Branch by Abstraction в проекте на примере Android-разработки
Представим простую историю. Вы заканчиваете делать рефакторинг, которым занимались последние 2 недели. Вы хорошо над ним поработали, сделали несколько ключевых изменений в проекте. Делаете долгожданный pull request и ... 12 конфликтов.
Или другой вариант. Вы работали и постоянно подливали себе основную ветку, чтобы код сильно не расходился. Делаете pull request, он висит несколько дней, после этого вы получаете approve и ... 15 конфликтов. Кто-то слил свой большой pull request раньше.
Но ведь вы всё делали правильно. Работали над рефакторингом в отдельной ветке. Почему вам надо разрешать эти конфликты и можно ли как-то попроще? Можно ли работать в какой-то *особой* ветке, которую потом легко сливать в главную ветку без конфликтов? Оказывается, можно.
В этой статье мы поговорим про технику Branch by Abstraction. Как она может помочь не копить большие изменения в нашей ветке, избегать merge hell и прокачать ваш CI.
Я буду описывать примеры из Android-разработки, но они также справедливы для большинства типов проектов и платформ.
А какой ещё branch может быть?
------------------------------
Итак, *Branch by Abstraction*. Давайте начнём с первого слова — *branch*. Обычно оно у нас чётко ассоциируется с веткой в репозитории. Начиная делать новую задачу, мы машинально пишем:
```
git checkout -b feature/new-acquiring
```
и мысленно понимаем, что создали новую ветку, новый *branch*.
Давайте считать отсюда и далее по тексту, что *branch* — это действительно ветвь, но не обязательно в репозитории. Давайте будем под этим словом понимать что-то более общее типа *абстрактной* ветви кода.
Как мы можем сделать *абстрактную* ветвь? Разными способами.
1. Можем просто скопировать файл. Есть файл New File.txt, мы делаем копию Copy of New File.txt. Появится новая версия кода, *новая ветвь*.
2. Можем в коде написать условный оператор `if` и сделать немного «копипаста». Появится новая версия кода.
3. Можно написать конфигурацию make-файлов таким образом, чтобы у нас были разные версии кода.
4. Можно продолжать фантазировать и придумывать другие способы.
Примеры выше — максимально банальные, но они хорошо показывают, как можно представить в голове абстрактную ветвь кода.
Как вы уже догадались, *Branch by Abstraction* — это техника, при которой мы создаём ветвь кода через абстракцию в нём.
А мне это точно надо?
---------------------
Когда нужно применять *Branch by Abstraction*? Для каждой фичи, или как?
С точки зрения процесса разработки, Branch by Abstraction — это инструмент. В одном случае он принесёт пользу, в другом — нет.
Скорее всего, он не нужен, когда:
* задача мелкая, мало изменений, небольшой pull request. Поэтому вряд ли будут проблемы слить изменения в develop;
* если делаем приложение в одиночку, то, скорее всего, делаем задачи последовательно. Вряд ли мы будем самостоятельно создавать ситуацию, где в разных ветках меняем один и тот же код;
* если проект хорошо разделён на изолированные модули и созданы условия, в которых мы работаем изолированно над своим модулем.
Но вот ситуации, когда Branch by Abstraction может сильно помочь:
* делаем большой долгий рефакторинг или фичу в общем коде;
* когда наша ветка в репозитории может устареть. Например, мы часто отвлекаемся на другие задачи и временно откладываем наполовину сделанную задачу.
Что же такое Branch by Abstraction?
-----------------------------------
Одним из главных евангелистов по теме *Branch by Abstraction* принято считать Пола Хамманта ([одна из первых статей на тему)](https://paulhammant.com/blog/branch_by_abstraction.html). В интернете можно найти много материалов от него. Также можно прочитать более компактную версию у [Мартина Фаулера](https://martinfowler.com/bliki/BranchByAbstraction.html).
Лично мне нравится описание, которое дал Мартин:
> “Branch by Abstraction” is a technique for making a large-scale change to a software system in gradual way that allows you to release the system regularly while the change is still in-progress.
>
>
Если говорить простым языком, то Branch by Abstraction — это такая техника разработки, при которой вы делаете задачу постепенно и одновременно релизите приложение.
Так как Branch by Abstraction — это техника, то она должна состоять из набора правил и инструкций. Так оно и есть. Обычно выделяют 4-5 шагов, которые нужно сделать, чтобы следовать этой технике. Их мы и рассмотрим в этой части.
Я буду использовать общепринятые в Android-разработке наименования классов. Но в целом это никак не привязано к платформе и может применяться где угодно.
Итак, предположим, у нас есть класс `MenuRepository` и он использует источник данных `MenuDataSource` как зависимость. Супер-стандартная ситуация. Выглядит примерно так:
Наша задача — отрефакторить `MenuDataSource` или перейти на новую реализацию источника данных.
Шаг 1: введение абстракции
--------------------------
Первым делом вводим абстракцию. Например, вводим интерфейс `MenuDataSource`, а реализацию уносим в `MenuDataSourceImpl`.
> В общем случае абстракция может быть введена любым способом: через композицию, наследование или функциональную абстракцию. В примерах я буду использовать композицию как самую распространённую.
>
>
Такое изменение сразу можно и нужно сливать в основную ветку, оно безопасное и никак не влияет на работу и код `MenuRepository`.
Шаг 2: создаём новую реализацию
-------------------------------
Её можно сделать для начала no-op или копию существующей. На схеме я её назвал `NewMenuDataSourceImpl`.
Это тоже можно сразу сливать в основную ветку. Единственное, что надо учесть: если вы делаете копию существующей реализации, то вместе с этим лучше скопировать и все тесты. Да, здесь будет дублироваться код, но это временное решение, на период работы над новой реализацией. Тесты в процессе будут тоже редактироваться и обновляться.
Шаг 3: включить для себя, выключить для всех остальных
------------------------------------------------------
Теперь нужно удостовериться, что можем работать над новой реализацией, тогда как для остальных разработчиков будет по умолчанию работать старая. В вашем проекте уже может быть рабочий механизм тогглов/флагов, тогда лучше делать через него. Если нет, то можно сделать это любым удобным способом. Главное, удостовериться, что абстракция будет выключена и не существует возможности её включить в рантайме. Например, если есть механизм тогглов, который присылает ваш бэкенд, то нужно иметь гарантии, что он не сможет включить вашу абстракцию на проде.
На схеме я добавил фабрику `MenuDataSourceFactory`, которая умеет производить нужный `DataSource`. Логика тогглов или другой механизм выбора нужной реализации пусть будет инкапсулирован там. Также на схеме добавил связь с DI в качестве одного из примеров, как `MenuRepository` может получить нужную версию `DataSource`.
Сливаем изменения в основную ветку. Поздравляю! С этого момента можно считать, что мы создали абстрактную ветку, ту самую Branch by Abstraction.
Шаг 4: итеративно делаем новую реализацию
-----------------------------------------
На [выступлении 2020 года](https://www.youtube.com/watch?v=fyVoTBV7DLM) Пол Хаммант приводит круговую диаграмму работы по Branch by Abstraction.
Из неё следует, что после того, как вы ввели абстракцию, можно работать в абстрактной ветке мелкими итеративными шагами: делать новую реализацию, рефакторить, писать тесты. Главное, за чем вы должны следить, — чтобы проект собирался и тесты проходили, т.е. чтобы был зеленый пайплайн в вашем CI.
Интегрируя изменения маленькими частями и часто, вы будете избегать больших мержей и вдобавок ваши коллеги быстрее будут видеть изменения в коде. Если вдруг их задача находится где-то рядом, они быстрее увидят, что у вас происходит, и вы сможете это обсудить максимально рано.
Шаг 5: удаляем старую реализацию
--------------------------------
После того как мы закончили работу над новой реализацией, старую можно удалять, как и механизм включения (удалить тогглы).
То есть в итоге всё будет выглядеть вот так:
Если надо, то можно удалить и абстракции. На мой взгляд, это не обязательно и зачастую не нужный шаг, только если вы не приближаетесь к той известной поговорке:
> Любую проблему можно решить введением новой абстракции. За исключением проблемы чрезмерного количества абстракций.
>
>
Но если удалять всё, то станет всё совсем просто:
«Стоп! Все эти стрелочки влево вправо я видел, когда читал про инверсию зависимостей! Это тоже самое?» — можете справедливо спросить вы. Нет, не тоже самое.
Действительно, всё, что я нарисовал, можно встретить в статьях и книжках про «Инверсию зависимостей» (ту самую букву D из SOLID). Тоже выделяем интерфейс, рисуем стрелочку вправо — и вуаля.
Здесь надо понимать важное и принципиальное отличие. Когда мы говорим про инверсию зависимостей, то ключевую роль играет то, как модули или слои зависят друг от друга. Меняется ли направление зависимостей, если мы вводим абстракцию. Далеко не всегда выделение абстракции будет менять зависимость между модулями или слоями. На рисунке ниже показано это отличие.
Слева — инверсия зависимостей. Сначала Module 1 зависел от Module 2, а потом мы инвертировали это и теперь Module 2 зависит от Module 1.
Справа — не инверсия зависимостей. Как Module 1 зависел от Module 2, так он и остался зависеть.
Инверсия зависимостей — это принцип организации зависимостей в приложении. Она помогает, например, грамотно разделить бизнес-логику от логики приложения или инфраструктуры.
Branch by Abstraction — это техника, которая позволяет создать «виртуальную» ветку кода и работать в ней. Это никак не связано с организацией зависимостей в приложении.
Пример с кодом
--------------
Давайте посмотрим на то же самое в коде.
Для разнообразия я возьму не те же классы, а немного другой кейс. Это реальный код из приложения Додо Пиццы, только упрощённый и с удалением всего лишнего.
У нас есть класс `CardPaymentInteractorImpl`, который отвечает за кейс оплаты по карте. Он использует доменный сервис `CardChargeService`, чтобы произвести непосредственно оплату. `cardChargeService` нам приходит как зависимость. В данном случае уже есть абстракция (`CardChargeService` это интерфейс, его не нужно вводить).
```
interface CardChargeService {
fun chargeNewCard(
card: Card
): PaymentAuthorization
}
class CardPaymentInteractorImpl(
... // dependencies for interactor
private val cardChargeService: CardChargeService
) : CardPaymentInteractor {
override fun chargeOrder(...): Async {
// some code
cardChargeService.chargeNewCardPayment(...)
// some code
}
...
}
```
Делаем новую реализацию, пусть она называется `CardChargeServiceAsyncImpl` (новая асинхронная оплата, не будем заострять внимание на нейминге). И включаем нужную версию через DI. Всё просто.
```
class CardChargeServiceAsyncImpl(
... // dependencies
) : CardChargeService {
override fun chargeNewCard(card: Card): PaymentAuthorization {
// new implementation
}
}
@Provides
fun provideCardChargeService(
featureService: FeatureService
): CardChargeService {
return if (featureService.isEnabled(ASYNC_PAYMENT)) {
CardChargeServiceAsyncImpl(
... // dependencies
)
} else {
CardChargeServiceImpl(
... // dependencies
)
}
}
```
После этого работаем над `CardChargeServiceAsyncImpl`, часто сливаем изменения в основную ветку. В процессе работы этот код может уезжать в релиз, в этом нет ничего страшного, потому что новая реализация закрыта тогглом.
Пример чуть посложнее
---------------------
В примере выше мы рассмотрели вариант, где у нас для `CardChargeService` уже есть абстракция, поэтому всё выглядело слишком просто. Это некий идеальный кейс, который будет не всегда. У меня чаще бывает такое, что надо сделать какой-то рефакторинг и нет готовых абстракций для этого. Что можно сделать в таком случае?
Рассмотрим ещё один реальный, но упрощённый пример. Допустим, у нас есть класс `MenuService`, который надо отрефакторить «где-то посередине» и нет очевидной готовой зависимости.
Так как нет готовой зависимости, то вычленяем её из кода и объявляем как абстракцию.
Сразу посмотрим в код. `MenuService` — это класс, который отвечает за доменную логику с меню. В одном из методов мы получаем объект `menuDto`, конвертируем его в доменные объекты через расширения `toMenuItems` и `toProducts` и сохраняем.
```
class MenuServiceImpl(
... // dependencies for service
) : MenuService {
fun updateMenu() {
val menuDto = ...
...
onMenuLoaded(menuDto)
...
}
private fun onMenuLoaded(menuDto: MenuDto) {
menuItemRepository.save(menuDto.toMenuItems())
productRepository.save(menuDto.toProducts())
}
...
}
fun MenuDto.toMenuItems(): Collection = ...
fun MenuDto.toProducts(): Collection = ...
```
Допустим, что в новой версии меню изменился формат и логика парсинга, `toMenuItems` и `toProducts` теперь не подходят.
Ок, начинаем делать *Branch By Abstraction*, вводим абстракцию. Например, назовём её `MenuConverter` и тут же перенесём текущую реализацию в класс `OldMenuConverter`.
Для новой версии конвертера `MenuConverterImpl` можем пока сделать пустую реализацию.
В коде это выглядит так:
```
interface MenuConverter {
fun convert(menuDto: MenuDto): Menu
}
class MenuConverterImpl : MenuConverter {
override fun convert(menuDto: MenuDto): Menu {
return Menu(
items = listOf(),
products = listOf()
)
}
}
class MenuConverterOldImpl : MenuConverter {
override fun convert(menuDto: MenuDto): Menu {
return Menu(
items = menuDto.toMenuItems(),
products = menuDto.toProducts()
)
}
}
```
И в сервисе заменяем прямое использование `toMenuItems` и `toProducts` на `menuConverter::convert`.
```
class MenuServiceImpl(
... // dependencies for service
private val menuConverter: MenuConverter
) : MenuService {
...
private fun onMenuLoaded(menuDto: MenuDto) {
val menu = menuDto.let(menuConverter::convert)
menuItemRepository.save(menu.items)
productRepository.save(menu.products)
}
}
```
Включаем в DI и используем:
```
@Provides
fun provideMenuConverter(featureService: FeatureService): MenuConverter {
return if (featureService.isEnabled(NEW_MENU_PARSING)) {
MenuConverterImpl()
} else {
MenuConverterOldImpl()
}
}
```
Всё, абстрактная ветка создана, теперь можно работать над новым меню.
После всех этапов и удаления старых реализаций может остаться что-то вроде такого:
Более сложный пример
--------------------
Несмотря на то, что выше были реальные примеры, я понимаю, что они довольно простые. Они могут показаться как из учебника. И не всегда можно использовать Branch by Abstraction, когда хочется.
Давайте разберём пример посложнее.
Введу немного в контекст. Одна из основных функций приложения Додо Пиццы — это заказ на доставку. Значит, нам нужен адрес доставки. Адрес доставки — это сущность, от которой зависит очень много других компонентов приложения: профиль, чекаут, онбординг и другие. В общем, ситуация такая, что адрес используется во многих местах.
Задача состоит в том, чтобы перейти на новую адресную систему во всей нашей системе Dodo IS. Если говорить про мобильное приложение, то доменный объект адреса и логика работы с ним сильно изменились, нельзя было просто расширить старый. В итоге надо было отрефакторить много кода.
Выглядело примерно всё вот так. Был доменный объект `Address`, от него зависело много компонентов (я их обозначил как Service1, 2, N). Надо было перейти на `NewAddress`.
Делаем первый шаг — вводим абстракцию. Здесь это будет посложнее, чем в предыдущих примерах. Мы вводим абстракции:
* `Address`
* `AddressFactory`
* и вспомогательные классы для работы с адресами, назовём их `AddressFormatter`, `AddressAdapter` и т.п. и фабрики для них, если нужны.
Переключатель новых и старых реализаций через фича-тогглы будет в фабриках.
На шаге введения абстракций мы должны добиться того, чтобы текущие адреса работали как раньше и ничего не сломалось. После этого можем сливать код в develop, абстрактная ветка создана.
Теперь можно итеративно работать над новой адресной системой.
В идеальном мире мы должны были бы работать только над новыми реализациями (жёлтыми прямоугольниками). В реальности местами код имеет более сильное связывание, поэтому мы работали и над самими сервисами (Service1, 2, N) тоже. Но старались максимально выносить логику в общие вспомогательные классы, которые накрыты абстракцией.
Мы делали этот рефакторинг несколько месяцев, за это время прошло несколько релизов. Но ничего не ломалось, рефакторинг продолжался. Branch by Abstraction отлично сработал!
Последний шаг — удаление старых адресов и всего, что с ними связано. На момент написания статьи их ещё не удалили, потому что переход на новую адресную систему происходит не только в мобильном приложении, а в целом во всей Dodo IS. Мы работаем в 15 странах и раскатываем это решение постепенно. Поэтому ещё какое-то время будет переходный период с двумя адресными системами.
Но когда удалим, всё должно выглядеть вот так.
Дополнительные преимущества
---------------------------
Перед тем как закончить, я хотел бы перечислить дополнительные плюшки, которые мы получаем, используя Branch by Abstraction.
Легко ставить на паузу
----------------------
Branch by Abstraction чаще всего подходит под большие и долгие задачи, для долгих рефакторингов или переезда с одного фреймворка на другой. Но мы живём в таком быстро меняющемся мире, что завтра придётся срочно начать делать другую задачу.
Например, мы делали рефакторинг оплаты в мобильном приложении, такой, чтобы приложение могло поддерживать сразу несколько эквайеров. Это нужно было для пиццерий во Вьетнаме — планировалось, что там будут использоваться сразу два эквайринга в приложении. Для нас это был немаленький и продолжительный рефакторинг. Его оценили в 2 спринта. Но после первого спринта бизнес-приоритеты изменились и нам надо было переключиться на задачу по новой адресной системе. А по эквайерам во Вьетнаме ситуация изменилась, приоритеты упали. Мы легко поставили задачу на паузу. Для этого не пришлось долго держать отдельную ветку и постоянно её обновлять.
Релизы не останавливаются
-------------------------
Для бизнеса критически важно регулярно и предсказуемо выпускать новые фичи и релизы. Для команд разработки это тоже важно, потому что регулярные и сравнительно небольшие релизы повышают стабильность системы. Мы не копим большие изменения, чтобы выкатить их сразу. Чем меньше частота релизов, тем выше шанс выпустить нестабильный билд и броситься его героически чинить.
Branch by Abstraction позволяет релизам выходить вне зависимости от того, на какой стадии задачи вы находитесь, даже если у вас сейчас абсолютно не работающий код. Главное, чтобы он скомпилировался и был надёжно закрыт тогглом.
Код становится лучше
--------------------
У многих из нас есть legacy код (или скоро появится). Или просто какой-то код, который написан не идеально или не по архитектурным договорённостям в команде. Часто он ещё и не покрыт тестами. В этом случае введение абстракции приведёт и к улучшению тестируемости кода. Если вы вводите абстракцию, то сможете покрыть новую реализацию тестами. Таким образом часть вашего кода станет лучше. Конечно, здесь не надо доводить до абсурда и вводить абстракцию на каждый чих. Но для legacy-кода и кода с сильной связанностью введение абстракций, которые можно протестировать, скорее всего, будет во благо.
Выводы
------
Подведём итоги. Можно ли делать большой и продолжительный рефакторинг и не страдать потом от мёрж-конфликтов? Да, можно! Branch by Abstraction как раз подходит для этого.
Эта техника позволяет делать продолжительные задачи, при этом регулярно (хоть каждый день) сливать свой код в основную ветку.
Основная идея сводится к тому, что мы работаем не просто в отдельной ветке репозитория, а в абстрактной ветке. Её мы создаём сами в коде с помощью введения абстракции и механизма тогглов.
Branch by Abstraction состоит из простых шагов:
* ввести абстракцию и создать новую реализацию (она может быть пустой);
* включить для себя, выключить для всех остальных;
* итеративно делать новую реализацию;
* выключить и удалить старую реализацию.
Главное, не забывать, что код может в любой момент уйти в прод. Поэтому он должен быть покрыт тестами, не ломать билд и не должно быть возможности его случайно включить в рантайме на проде.
Надеюсь, что эта статья была полезной и вы теперь сможете применять эту технику в своей работе. Если вы уже её используете, буду рад почитать о вашем опыте в комментариях. | https://habr.com/ru/post/652029/ | null | ru | null |
# Два парадокса в программах на языке C
Хочу рассказать о двух странностях, с которыми мне пришлось столкнуться, программируя вычислительные алгоритмы на языке C.
Итак, первое неожиданное поведение для некоторых программистов. Вот маленькая прога.
```
#include
int main()
{
unsigned char a = 1, b;
b = ~a >> 1;
printf("%u\n", b);
return 0;
}
```
Разберем ее. Поразрядная операция **~** инвертирует состояние каждого бита байта **a**, в который изначально записана единица. В результате должны получить **11111110b**, то есть **254**. Сдвигая этот байт вправо на один бит, должны получить **127**. Однако код, который дает, например, компилятор **gcc**, выводит в консоль число **255**?!
Сначала я подумал о том, что дело в приоритете — вдруг у компилятора приоритет операций «косячит»? То есть будто бы сначала делается сдвиг, а потом — инверсия (а что, логично...). Так в чем же дело?
После некоторых раздумываний мне пришла в голову другая гипотеза о том, что при инверсии байт приводится к слову (ну, или к двойному слову), а потом уже инвертированное слово сдвигается. Вот откуда и получается **255** — старшие биты в слове нули, инвертируя их, имеем единицы. Затем, делая сдвиг слова вправо на один бит, в его младшем байте во всех битах будут находиться единицы.
Это и подтверждает следующий код.
```
#include
int main()
{
unsigned char a = 1, b;
b = (unsigned char)~a >> 1;
printf("%u\n", b);
return 0;
}
```
Теперь мы получаем правильный результат. Но окончательно убедился в этом, дизассемблировав ELF-файл, который дает **gcc**. Приведу фрагмент полученного ассемблерного кода.
```
mov [ebp+var_6], 1
movzx eax, [ebp+var_6]
not eax
sar eax, 1
mov [ebp+var_5], al
```
Сначала через стек единица попадает в 32-х разрядный регистр **eax**. Далее он инвертируется, а потом сдвигается. Результат достается из младшей части регистра **ax** — регистра **al**. Это и оправдывает мою гипотезу — единицы, которые были за нужным байтом, при сдвиге двойного слова в него попали.
Как потом выяснилось, эта ситуация называется **Integer Promotion** и описывается в п. **6.3.1.1** стандарта **C99**. Загрузить его можно отсюда [www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf](http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf)
Второе неожиданное поведение для некоторых программистов связано с вещественными числами. Имеем следующий код.
```
#include
int main()
{
float a = 1.005, b = 1000;
int c = a\*b;
printf("%d\n", c);
return 0;
}
```
Компилируя его ****gcc** 4.1.1**, получаю **1004**. Опять вопрос — откуда берется странный результат? Даже это
```
int c = (float)(a*b);
```
также не дает правильного результата.
Полазив по стандарту **C89**, оказалось, что он ничего не регламентировал о способах работы с вещественными числами. Ведь, когда появилось расширение **SSE**, компиляторы начали считать смешанным образом — как посчитается быстрее: что-то на **FPU**, что-то на **SSE**. В новом стандарте **C99** появилась некоторая определенность. Компилятор должен выставить значение макроса **FLT\_EVAL\_METHOD** (заголовочный файл **float.h**) в **0**, **1**, **2** для способа, которым он считает. Итак, **0** — все считать так, как написано; **1** — **float** на самом деле считать в **double** и затем конвертировать обратно во **float**; 2 — все считать в **long double**, конвертируя во **float** или **double** в конце вычислений соответственно.
Теперь, чтобы заставить считать прогу так, как надо, нужно собирать ее
```
gcc proga.c -msse
```
Только после этого у меня в консоль вывелось число **1005**. При этом выяснилось, что моя версия компилятора **gcc** не поддерживает макрос **FLT\_EVAL\_METHOD**. Кстати, с **double** **gcc** даёт код, выводящий **1004**. Только **Intel C 9.0** сделал нормальный код с **double**, но когда я записал
```
int c = (float)(a*b);
```
(здесь **a** и **b** уже типа **double**). Без приведения типа код и там даёт **1004**. | https://habr.com/ru/post/201868/ | null | ru | null |
# Solaris Container (zone). Создание и администрирование. Часть 1
[Solaris Container (zone). Создание и администрирование. Часть 2](http://habrahabr.ru/blogs/sysadm/123621/)
#### Введение
Технология Solaris Zone (Solaris Container) – это технология, позволяющая разделить на программном уровне Solaris 10 ОС на контейнеры(зоны), почти самостоятельные ОС, которые могут иметь отдельные независимые ресурсы (процессоры, память, дисковое пространство) и своих собственных пользователей.
Конетейнеры – это хорошее решение для построение серверов приложений, в которых каждое приложение будет иметь свой честный гарантированный (или разделяемый между всеми зонами) кусочек ресурсов, с которым сможет работать. Такое решение позволит консолидировать инфраструктуру на более мощных серверах, что в общем понизит стоимость и сложность информационных систем.
При планировании консолидации серверов перед нами появляется достаточно много разнородных решений, из которых мы должны выбрать как раз то, которое полностью нас удовлетворит. Обычно мы выбираем между этими тремя:
* Домены – [Oracle VM Server for SPARC](http://ru.wikipedia.org/wiki/Logical_Domains) (ex LDom от Sun) или [IBM LPAR](http://ru.wikipedia.org/wiki/LPAR)ы
* Виртуальные машины – Vmware, Microsoft Hyper-V etc
* Изолированные разделы на уровне ОС – **Solaris Zones**, FreeBSD Jail, LVS (Linux Virtual Server)
Особенности Solaris Zones:
* Безопасность – приложение, запущенное в зоне, запущено в «песочнице», то есть процесс, даже запущенный от имени root в рамках зоны, не может повлиять на другие зоны или на global зону (управляющая, корневая зона). Перезагрузка или выключение доступно только из global зоны.
* Изоляция – зоны имеют исключительное право на выделенные ей ресурсы; зоны могу иметь своих собственных пользователей и свое собственного пользователя root. Перезагрузка зоны никак не может повлиять на другие зоны, работающие на хосте
* Гибкость – ресурсы зоне могу быть назначены жестко или зона может использовать общий пул ресурсов хоста.
#### Создание Solaris Zone
Для демонстрации установим зону с именем habrazone.
У меня Solaris OS 10 09/10 и установлена она на [ZFS](http://ru.wikipedia.org/wiki/Zettabyte_File_System). В следующей статье я опишу процесс создания отдельного пула на ZFS, установки в этот пул зоны, а так же выделение гарантированных CPU и RAM для зоны, а в этой – только установка зоны в отдельную директорию без привязки ее к ресурсам. Зона будет без изысков (проброса физических сетевых интерфейсов, raw устройств etc), а просто с виртуальным сетевым интерфейсом на уровне хоста.
Итак, для начала создадим директорию, в которую будет установлена зона, и назначим права для нее
`**# mkdir /export/habrazone
# chown root:root /export/habrazone
# chmod 700 /export/habrazone**`
Все просто. Только root может смотреть в эту зону и больше никто.
Для создания зоны используем команду zonecfg с ключом –z.
`**# zonecfg -z habrazone**
habrazone: No such zone configured
Use 'create' to begin configuring a new zone.
zonecfg:habrazone> **create**
zonecfg:habrazone> **set zonepath=/export/habrazone**
zonecfg:habrazone> **set autoboot=true**
zonecfg:habrazone> **add net**
zonecfg:habrazone:net> **set physical=bge0**
zonecfg:habrazone:net> **set address=10.44.3.92**
zonecfg:habrazone:net> **end**
zonecfg:habrazone> **add attr**
zonecfg:habrazone:attr> **set name=comment**
zonecfg:habrazone:attr> **set type=string**
zonecfg:habrazone:attr> **set value="Habrahabr"**
zonecfg:habrazone:attr> **end**
zonecfg:habrazone> **verify**
zonecfg:habrazone> **commit**
zonecfg:habrazone> **exit**`
Теперь немного прокомментирую то, что тут произошло:
zonecfg:habrazone> **create** — создаем зону. На самом деле зоны еще как таковой нет. Это всего навсего ее конфиг в XML.
zonecfg:habrazone> **set zonepath=/export/habrazone** — зона будет располагаться по пути /export/habrazone
zonecfg:habrazone> **set autoboot=true** — зона будет запускать автоматически вместе с загрузкой хоста, например после ребута.
zonecfg:habrazone> **add net** — добавляем сетевой интрефейс в конфиг зоны
zonecfg:habrazone:net> **set physical=bge0** — виртуальный интерфейс будет размещен над bge0
zonecfg:habrazone:net> **set address=10.44.3.92** — адрес нашей зоны
zonecfg:habrazone:net> **end** — конец
zonecfg:habrazone> **add attr** — добавил «название» для зоны
zonecfg:habrazone:attr> **set name=comment**
zonecfg:habrazone:attr> **set type=string**
zonecfg:habrazone:attr> **set value=«Habrahabr»** — наш любимый ресурс
zonecfg:habrazone:attr> **end** — и опять конец
zonecfg:habrazone> **verify** — проверим конфиг. Если в конфиге есть ошибки, то в этом месте нам об этом сообщат
zonecfg:habrazone> **commit** — коммит
zonecfg:habrazone> **exit** — выход
Посмотрим наш конфиг целиком. Обратите внимание на **inherit-pkg-dir**. Они указывают на директории, которые «наследуются» из global зоны.
`**# zonecfg -z habrazone info**
zonename: habrazone
zonepath: /export/habrazone
brand: native
autoboot: true
bootargs:
pool:
limitpriv:
scheduling-class:
ip-type: shared
hostid:
inherit-pkg-dir:
dir: /lib
inherit-pkg-dir:
dir: /platform
inherit-pkg-dir:
dir: /sbin
inherit-pkg-dir:
dir: /usr
net:
address: 10.44.3.92
physical: bge0
defrouter not specified
attr:
name: comment
type: string
value: Habrahabr`
Сейчас у нас только 1 зона – глобальная. Список зон можно посмотреть командой zoneadm c ключами list –iv:
`# **zoneadm list -iv**
ID NAME STATUS PATH BRAND IP
0 global running / native shared`
Теперь у нас все готов к инсталляции зоны. Для инсталляции зоны используется уже знакомая команда zoneadm, но в качестве параметров ей передается имя еще незаинсталлиной зоны с командой install:
`**# zoneadm -z habrazone install**
A ZFS file system has been created for this zone.
Preparing to install zone habrazone.
Creating list of files to copy from the global zone.
Copying 3137 files to the zone.
Initializing zone product registry.
Determining zone package initialization order.
Preparing to initialize 1207 packages on the zone.
Initialized 1207 packages on zone.
Zone habrazone is initialized.
The file /export/habrazone/root/var/sadm/system/logs/install_log contains a log of the zone installation.`
Хотел бы обратить внимание, что в зону файлы ОС копируются из global зоны, а часть директорий наследуются. Наследуемые директории в зоне находятся в read only.
В списке зон у нас появилась новоустановленная зона:
`**# zoneadm list -iv**
ID NAME STATUS PATH BRAND IP
0 global running / native shared
- habrazone installed /export/habrazone native shared`
И размер ее очень небольшой как для почти отдельной ОС.
`# **du -shk /export/habrazone/**
79M /export/habrazone`
Запуск и остановка выполняется с помощью команды zoneadm –z <имя зоны> boot и zoneadm –z <имя зоны> halt соответственно:
`**# zoneadm -z habrazone boot**`
После запуска зоны можно проверить что поменялось, например в конфигурации сетевых интерфейсов хоста.
`**# /sbin/ifconfig -a**
lo0: flags=2001000849 mtu 8232 index 1
inet 127.0.0.1 netmask ff000000
lo0:1: flags=2001000849 mtu 8232 index 1
zone habrazone
inet 127.0.0.1 netmask ff000000
bge0: flags=1000843 mtu 1500 index 2
inet 10.44.3.93 netmask ffffff00 broadcast 10.44.3.255
ether 0:14:4f:79:91:1a
bge0:1: flags=1000843 mtu 1500 index 2
zone habrazone
inet 10.44.3.92 netmask ffffff00 broadcast 10.44.3.255`
Как видно из вывода ifconfig, в системе появился виртуальный интерфейс, на который назначен адрес зоны. Зоне можно так же отдать отдельный физический интерфейс, например, в случае если в зоне поднято приложение, которое активно эксплуатирует сеть, и дать возможность другим зонам нормально функционировать.
После того, как зона загрузилась, необходимо зайти в нее консоль и провести минимальную конфигурацию (hostname, time zone, name service, пароль root etc).
Зайти можно используя zlogin –C <имя зоны>:
`**# zlogin –C habrazone**`
Далее отвечаем на вопросы ОС о hostname, time zone, name service, вводим пароль root. После всех конфигурационных шагов зона сама перезагрузится и мы сможем попасть в ее консоль по средстава все того же zlogin <имя зоны> или по ssh:
`**# hostname**
globalzone
**# zlogin habrazone**
[Connected to zone 'habrazone' pts/1]
Last login: Fri Jul 1 18:43:32 on pts/3
Oracle Corporation SunOS 5.10 Generic Patch January 2005
**# hostname**
habrazone`
Зона готова.
В следующей статье я постараюсь описать то, как можно выделать ресурсы(raw, CPU, RAM) для зоны и как можно мигрировать зоны между хостами.
Спасибо за внимание. | https://habr.com/ru/post/123221/ | null | ru | null |
# Цифровой словарь от А до Я
Одной из самых полезных программ на ПК и смартфоне в моем понимании является электронный словарь. В те стародавние времена, когда я учил иностранный язык, каждое слово приходилось искать в бумажном словаре. Эту тривиальную операцию я проделывал сотни раз, а некоторые зловредные слова приходилось смотреть снова и снова, так как я успевал забыть их значение. Как это было обидно! То ли дело сейчас, вжух и перевод перед глазами на экране монитора. История поиска, на случай, если искомое слово не перешло из области кратковременной памяти в долгосрочную.
Давайте своими силами создадим электронный словарь для программ StarDict / GoldenDict. Для этого может понадобится много, или мало человеко-часов, в зависимости от качества исходного материала.
Шаг первый: OCR
---------------
В отличие от альпинизма при оцифровке словаря самый тяжелый шаг, не последний а первый. Если вам придется проводить OCR бумажного словаря с выцветшими страницами, напечатанного слишком мелко, с различными артефактами небрежного использования, или на экзотическом языке, то даже FineReader не сильно поможет. На некоторых страницах разница в длительности времени между ручным набором текста и OCR с корректировкой ошибок ничтожна.
Советую сохранять все в простых **текстовых файлах,** так как продвинутый поиск и исправление ошибок, расстановка тэгов, преобразование сортировки и прочие операции с текстовым массивом *невообразимо осуществлять с бинарным фалом*.
На этом шаге важно определиться со структурой словарных статей. В самом простом случае будет всего два поля: *ключ* и *значение*. Этого достаточно, но если нужна подсветка различных элементов статей, то тогда потребуется все такие элементы определенным образом маркировать.
Самое время немного поговорить о форматах. Существует много форматов электронных словарей, [вот](https://github.com/goldendict/goldendict/wiki/Supported-Dictionary-Formats) их список.
Все форматы мы здесь разбирать не будем, так как большинство из них проприетарные. Нас интересуют открытые стандарты и открытое ПО.
### Dictd
Возникший в эпоху, когда сетевые TCP/IP протоколы беспрепятственно плодились и размножались `dictd` сейчас представляет лишь археологический интерес. Это клиент серверный протокол, использующий TCP порт 2628, определен в [RFC 2229](https://tools.ietf.org/html/rfc2229).
Исходный файл для словаря форматируется следующим образом.
```
:статья: объяснение
```
Например, [такой](https://github.com/jessykate/nomadict) словарик
```
:catalysis: "increase in the rate of a chemical reaction due to the participation of an additional substance called a catalyst, which is not consumed in the catalyzed reaction and can continue to act repeatedly.
" [ref](is.gd/v6a22Q).
:deconstruction:
:rendered: eg. "rendered irrelevant."
:reading: cf. 'reading of'
:minor: a minor reading.
```
Готовый файл для словаря создается командой `dictfmt`.
```
dictfmt --utf8 -s "Длинное имя словаря" -j dict-name < mydict.txt
```
В результате образуются 2 файла: `dict-name.index` и `dict-name.dict`. Из них первый очевидно индексный файл, с ним ничего делать не нужно, а второй можно сжать командой `dictzip`. Данная команда сжимает \*.dict файл с помощью утилиты `gzip`. Сразу же возникает вопрос: а зачем оно тогда нужно, если есть обычный `gzip`?
Дело в том, что `dictzip` использует добавочные байты в заголовке архивного файлы для обеспечения псевдо-произвольного доступа к файлу.
Наконец файлы помещаются в профильные каталоги, т. к. `/usr/lib/dict`, перезагружаем службу `dictd` и вуаля. Синтаксис поиска прост, достаточно набрать
dict СЛОВО.
Пробежка по *dictd* ссылкам напоминает сафари по интернет сети 90-х, жив и еще лягается!
Sdict
-----
[Дерзкая попытка](http://swaj.net/) Алексея Семенова изменить мир к лучшему с помощью магии Perl в ту пору, когда Microsoft еще не крутил шашни с Linux и сообществом открытого ПО, а основной источник словарей были пиратки ABBYY Lingvo.
Заголовок исходного файла словаря.
```
title = Sample 1 test dictionary - dictionary name;
copyright = GNU Public License - copyright information;
version = 0.1 - version;
w\_lang = en - language for words;
a\_lang = fi - language for articles. For further information
about language codes refer 'C:\Sdict\share\doc\iso639.htm' file;
# charset = ... - use if your source file is not in UTF-8 encoding.
```
Тело форматировано следующим образом:
```
word___article
```
Можно качнуть версию для ОС Symbian, если что. Проект более не жив, и даже сами словари можно почерпнуть лишь с [Машины Времени](https://web.archive.org/web/*/http://www.pscience5.net/lost/SDict/*).
XDXF
----
Ну все, завязываем с археологией и переходим к словарным форматам и программам годным для использования IRL.
XDXF имеет все преимущества и недостатки XML формата, каковым и является. Весь синтаксис формата и примеры можно обозреть [тут](https://github.com/soshial/xdxf_makedict/blob/master/format_standard/xdxf_description.md).
Скелет словарного файла выгладит следующим образом, состоит из 2-х частей: `meta_info` и `lexicon`.
```
Вся информация про словарь: название, автор и пр.
статья 1
статья 2
статья 3
статья 4
...
```
Есть [огромное количество](http://www.dicto.org.ru/xdxf.html) словарей в этом формате. Большим достоинством формата является то, что далее нет надобности ничего конвертировать. Программа *GoldenDict* распознает XDXF файлы наряду с большим количеством других поддерживаемых форматов.
TSV / StarDict
--------------
*StarDict* и клоны его это не столько про формат электронного словаря, сколько про качественное ПО просмотра, конвертации и создания таковых.
Для создания электронного словаря с помощью *StarDict* достаточно TSV файла, что я и выбрал для цифровой копии [армяно-русского словаря](https://sourceforge.net/projects/arm2rus-dict/).
Тем не менее возможно и кое-какое [форматирования](http://stardict-4.sourceforge.net/StarDictFileFormat) и разметка файла словаря, однако не идет ни в какое сравнение с `XDXF`.
```
a 1\n2\n3
b 4\\5\n6
c 789
```
Формат определяет символ переноса строки `\n`, в том случае, когда статья разбита на параграфы.
Шаг второй: корректировка
=========================
После первого шага скорее всего будут десятки, а то и сотни орфографических, грамматических и всяких прочих ошибок, странных символов и прочих артефактов OCR.
Особенность словарей в том, что проверка орфографии нужна одновременно по двум языкам. Даже сейчас в 2018-м удивительно мало текстовых редакторов и даже офисных пакетов умеют это нехитрое действие выполнять.
Не холивара для, рекомендую обработку теска производить с **Vim**. Если ваш любимый текстовый редактор справляется с этим не хуже, то и славно. С Vim достаточно команды.
```
:setlocal spell spelllang=en,ru
```
для проверки орфографии по двум словарям, в данном случае русском и английском. Далее список граблей.
* Сортировка текста работает абы как для не латинских локалей, особенно плохо там, где написание буквы требует более одного символа, как армянская `ու = ո + ւ`. Необходимо в таких случаях самостоятельно сортировать список слов с помощью простенького Perl, или иного скрипта.
* Поиск по шаблону также может работать неожиданно для некоторых локалей, даже если сам текст и консоль в UTF-8.
* При оцифровке печатного словаря нужно быть готовым не только к ошибкам оцифровки, но и ошибкам в самом печатном словаре. Их там может содержаться немало!
* Если название статьи пишется заглавными, то возможно следует перевести при оцифровке в нижний регистр. Не все буквы имеют символы в верхнем регистре, собственно не для всех локалей даже есть верхний регистр.
Шаг третий: компиляция словаря
==============================
Для формата `XDXF`, как уже было сказано, этот шаг не требуется. Просто запихнуть файл в папку `/usr/share/goldendict`, где программа подхватит его.
Для TSV файла, используется утилита `stardict-editor`, поставляемого с набором инструментов *StarDict*.
На выходе программа создает следующие файлы, наподобие древнего Dict.
1. somedict.ifo
2. somedict.idx либо somedict.idx.gz
3. somedict.dict либо somedict.dict.dz
4. somedict.syn (optional)
Файлы копируются в каталог `/ysr/share/stardict/dic` и на этом все.
P. S. Для мобильной платформы Android программа [GoldenDict](http://goldendict.mobi/) внезапно стал платной, однако в интернет сети все еще можно найти последнюю бесплатную версию программы. | https://habr.com/ru/post/421075/ | null | ru | null |
# Обзор uniset2-testsuite — небольшого велосипеда для функционального тестирования. Часть 2
В [первой части](https://habrahabr.ru/post/323290/) был обзор возможностей. А в этой части рассмотрим, какие уже реализованы интерфейсы тестирования и как добавить свой…
Если что, вот ссылка на [первую часть статьи](https://habrahabr.ru/post/323290/)
На текущий момент uniset2-testsuite поддерживает три интерфейса:
* uniset
* modbus
* snmp
Интерфейс type=«uniset»
-----------------------
Как я писал в первой части, весь [uniset2-testsuite](https://github.com/Etersoft/uniset2-testsuite) поначалу разрабатывался для тестирования проектов, использующих [libuniset](https://habrahabr.ru/post/278535/). Поэтому *type=«uniset»* — это первый и основной интерфейс, который был разработан. В uniset-проектах основным элементом являются «датчики», которые имеют уникальный идентификатор (числовой, но можно использовать строковые имена) и какое-то значение которое можно установить или получить. Поэтому в тестовом сценарии всё крутится вокруг этих датчиков и проверки их значений. Вот пример простого сценария, реализующего алгоритм, описанный [здесь](https://habrahabr.ru/post/278607/).
```
xml version = '1.0' encoding = 'utf-8'?
```
Интерфейс type=«modbus»
-----------------------
Это интерфейс является более интересным для широкого использования, так как позволяет общаться с тестируемой системой по стандартному протоколу [Modbus TCP](https://ru.wikipedia.org/wiki/Modbus). Тестовый сценарий с его использованием выглядит следующим образом:
```
xml version = '1.0' encoding = 'utf-8'?
```
В начале в секции **Config** определяются параметры двух узлов, с которыми ведётся работа. Условно им присвоены имена **mb1** и **mb2**. Один из них при этом назначается как умолчательный **default=«1»**. Поэтому везде далее по тексту, если не указан параметр **config=".."** используется узел по умолчанию.
Сам формат записи тестов выглядит так:
`"mbreg@mbaddr:mbfunc:nbit:vtype"`
Где:
* **mbaddr** — адрес устройства на шине. По умолчанию: 0x01
* **mbfunc** — функция опроса или записи. По умолчанию для опроса используется mbfunc=0x04, а для записи mbfunc=0x06
* **nbit** — номер бита [0...15]. Для случая, если опрос ведётся функцией чтения «слова», а при этом данные хранятся в каком-то бите. По умолчанию nbit=-1 — что означает не использовать.
* **vtype** — тип запрашиваемого значения, задаётся строковым значением. По умолчанию «signed».
**Поддерживаемые vtype**
+ **F2** — двойное слово float(4 байта)
+ **F4** — 8-х байтовое слово (double)
+ **byte** — байт
+ **unsigned** — беззнаковое целое (2 байта)
+ **signed** — знаковое целое (2 байта)
+ **I2** — целое (4 байта)
+ **U2** — беззнаковое целое (4 байта)
**ВНИМАНИЕ:** Следует иметь ввиду, что в текущей реализации работа ведётся только с целыми значениями, поэтому все 'float'-значения округляются до целых.
Обращаю внимание, что поля *mbadrr*, *mbfunc*, *nbit* и *vtype* не являются обязательными и имеют значения по умолчанию.
В итоге этот интерфейс позволяет Вам писать тестовые сценарии для работы с многими устройствами. Например Вы можете управлять каким-то своим тестовыми стендом для подачи тестовых воздействий на ваше устройство и проверять его реакцию. Всё это по протоколу Modbus TCP, который поддерживается практически всеми производителями устройств, используемых в АСУ (и не только).
Интерфейс type=«snmp»
---------------------
Данный интерфейс предназначен для работы с тестируемой системой по протоколу snmp.
**Немного деталей по реализации**У меня было несколько реализаций на основе python-модулей pysnmp, netsnmp. Но в итоге возникшие трудности с разными версиями на разных платформах привели меня к
более «дубовому» решению. А именно, к использованию вызовов утилит семейства *net-snmp-clients* и обработке результатов через popen. Как ни парадоксально это звучит, но такой способ оказался более «портабельным», чем использование чистых питон-модулей.
Пример тестового сценария с использованием snmp приведён ниже:
```
xml version="1.0" encoding="utf-8"?
```
Этот интерфейс для своего использования ещё требует специальный конфигурационный файл, который указывается в секции **Config** (*snmp=".."*).
**Конфигурационный файл snmp.xml для snmp сценария**
```
xml version='1.0' encoding='utf-8'?
```
Секция **Nodes** задаёт список узлов (устройств) с которыми будет происходит обмен. При этом возможно задавать следующие параметры:
* **name** — название узла используемое в дальнейшем в тесте
* **ip** — адрес устройства (ip или hostname)
* **timeout** — таймаут на одну попытку связи, в секундах. Необязательный параметр. По умолчанию 1 сек.
* **retries** — количество попыток считать параметр. Необязательный параметр. По умолчанию 2.
* **port** — Порт для связи с устройством. Необязательный параметр. По умолчанию 161.
* **comment** — комментарий к названию. Необязательный параметр, на данный момент не используется.
Непосредственно в секции **Nodes** можно задать параметры по умолчанию для всех узлов.
* defaultProtocolVersion
* defaultTimeout
* defaultRetries
* defaultPort
В секции **MIBdirs** задаются каталоги с mib-файлами, для проверки корректности OID
* **path** — путь до каталога
* **mask** — маска для файлов. Если не указана, загружаются все файлы из каталога
Секция **Parameters** задаёт список параметров, которые будут участвовать в тестах:
* **name** — название параметра используемое в дальнейшем в тесте
* **r\_community** — установка 'community string' при чтении параметра (см. snmp протокол).
* **w\_community** — установка 'community string' для записи параметра (см. snmp протокол).
* **OID** — идентификатор параметра в соответствии с протоколом SNMP.
* **ObjectName** — название параметра в соответствии с протоколом SNMP. Не обязательный параметр.
* **ignoreCheckMIB** — не проверять параметр по mib-файлу (в режиме --check-scenario)
Параметры *OID* и *ObjectName* являются взаимозаменяемыми. Если заданы оба параметра, используется OID. Непосредственно в секции **Parameters** можно задать параметры по умолчанию для всех узлов.
* defaultReadCommunity
* defaultWriteCommunity
Использование нескольких интерфейсов в одном сценарии
-----------------------------------------------------
Просто покажу пример:
```
xml version="1.0" encoding="utf-8"?
...
```
Т.е. для каждой проверки можно указать, какой интерфейс использовать, задав параметр **config**=«aliasname»
Как реализовать свой интерфейс
------------------------------
#### Вводная
Во время работы над базовыми интерфейсами, сформировались видение о минимальном API тестового интерфейса для встраивания его в uniset2-testsuite. И оказалось, что для основной функциональности достаточно реализовать всего две функции (~~ну почти~~)
```
def get_value(self, name, context):
...
def set_value(self, name, value, context):
...
```
В основе этого лежит простая идея. Если посмотреть на тестовый сценарий, то можно видеть, что в общем виде check или action можно записать в виде
`сheck="[NAME]=[VALUE]"`.
Вместо *'='* на самом деле может стоять что-то из этого [=,>,>=,<,<=,!=].
Т.е. у нас есть некий **[NAME]** как название параметра который мы проверяем. И конкретный интерфейс знает как его распарсить. И есть **[VALUE]** — это значение с которым происходит сравнение результата или которое мы выставляем. В итоге uniset2-testsuite берёт на себя работу по разбору теста на NAME и VALUE и вызывает функцию **get\_value** или **set\_value** конкретной реализации интерфейса. При этом интерфейс сам отвечает за то, как у него в поле [NAME] *зашифрован* параметр с которым производится работа. Например:
* в «uniset» формат *NAME*: `id@node`
* в «modbus» формат *NAME*: `"mbreg@mbaddr:mbfunc:nbit:vtype"`
* в «snmp» формат *NAME*: `"varname@node"`
Т.е. разработчик интерфейса сам решает какой формат для *NAME* ему выбрать.
**Важно иметь ввиду**, что в текущей реализации такие параметры тестового сценария как *timeout*, *check\_time*, *holdtime* обрабатываются на уровне uniset2-testsuite. И поэтому, когда в тесте написано , это означает, что каждые 3 секунды будет вызываться функция get\_value(varname), пока не истечёт timeout или не будет получено значение 34.
**Еще одно важное ограничение** — это то, что в текущей реализации поддерживается [VALUE] только как число. На самом деле переделать для поддержки «любого типа» (~~по сути строки~~) не сильно сложно, просто не было пока необходимости реализовывать поддержку VALUE не как числа. Напомню, что есть проверка типа *compare*, которая позволяет сравнивать не с числом, а со значением другого параметра.
#### Кофигурирование
Каждый интерфейс сам определяет, какие конфигурационные параметры ему нужны для работы. В uniset2-testsuite для их записи предусмотрена секция **Config**/**aliases**, где в виде xml-свойств можно записать параметры. При создании интерфейса ему будет передан конфигурационный узел, из которого он считает всё, что ему нужно. Если требуется слишком много всего дополнительного определять, то, например, в snmp-интерфейсе в конфигурационном узле определяется только где взять конфиг-файл (snmp.xml), а уже там определяется всё, что необходимо интерфейсу для работы. В свою очередь для интерфейса modbus, например, достаточно только определить ip и port для связи с устройством, и эти параметры записываются напрямую в секции *Config*.
#### Загрузка плагинов (интерфейсов)
Загрузка интерфейсов построена на простом принципе. Есть каталог '**plugins.d**' из которого загружаются все лежащие там интерфейсы. Есть каталог «системный», а также плагины ищутся в подкаталоге **plugins.d** в текущем каталоге, где запускается тест. Соответственно, пользователь может просто разместить свои плагины там же, где находится тест и они автоматически подхватятся.
Каждая реализация интерфейса оформляется в виде отдельного python-файла, который **обязан** содержать функцию **uts\_plugin\_name()**. Например, в snmp интерфейсе она выглядит так
```
def uts_plugin_name():
return "snmp"
```
В итоге сама загрузка интерфейсов построена на следующем механизме:
```
..
...
```
Начиная обработку тестового сценария, uniset2-testsuite составляет список доступных плагинов по именам, загружая их из каталогов *plugins.d*. Далее при прохождении
по секции **Config** смотрится type=«xxxx» и ищется соответствующий интерфейс,
для создания которого вызывается специальная функция
`uts_create_from_xml(xmlConfNode)`, которой передаётся xml-узел
в качестве параметра. Далее уже в ней реализуется создание интерфейса и его инициализация.
Если коротко:
```
uts_plugin_name() - чтобы найти нужный интерфейс указанный в type="..."
uts_create_from_xml(xmlConfNode) - чтобы его создать
```
#### Проверка корректности конфигурационных параметров
Выше я писал, что для реализации своего интерфейса, достаточно реализовать только две функции **set\_value()** и **get\_value()**. На самом деле, желательно (но не обязательно) реализовать ещё две:
```
def validate_parameter(self, name):
...
def validate_configuration(self):
...
```
Они необходимы для режима --check-scenario, когда происходит проверка корректности параметров теста, без фактического их исполнения. **validate\_parameter** — вызывается для проверки корректности параметра *name*. И надо иметь ввиду, что она вызывается для каждой проверки в тесте. А **validate\_configuration** — вызывается один раз, для проверки конфигурационных параметров всего теста. Например в snmp-интерфейсе, в ней проверяется, доступность узлов, а также проверка валидности OID и ObjectName по mib-файлам (если указаны соответствующие каталоги где их найти).
#### Реализация
Ну вот наконец-то мы добрались и до реализации. Размышляя над тем какой интерфейс реализовать в качестве показательного примера, я решил, что разработаю ''самый универсальный'' из возможных интерфейсов — а именно интерфейс, который в качестве проверок будет запускать скрипты. Назову его **«scripts»**. Сразу хочу отметить, что под словом «скрипт» подразумевается не только bash, а всё что «можно запустить». Т.к. мы фактически запускаем *на каждую проверку* программу через оболочку.
Итак.
Для начала надо придумать формат для NAME (что имеется ввиду см. выше). Немного поразмышляв, ~~а если честно, то и попробовав~~, я пришёл к такому простому формату:
```
..
```
**О поиске формата**Сперва мне хотелось сделать формат, а-ля GET-запрос: `scriptname?param1¶m2¶m3.`
Но я столкнулся с ограничением в том, что у нас xml. А в нём нельзя так просто взять и использовать '**&**'. Только если его записать в виде **'&'amp;**. Что понятное дело уже сводит всё удобство на нет.
Т.е. в **test=".."** записывается название скрипта (можно с указанием пути). Т.к. нам ведь хочется передавать и параметры скрипту, то для этого введём специальное поле (расширение) **params="..."**.
Теперь надо понять как нам **получить результат**. Т.к. принято что программа возвращает 0 — в случае успеха и «не ноль» в случае провала, то использовать код возврата, в качестве результата, мне кажется, не лучшая идея. В итоге я решил, что наиболее простым способом будет, чтобы программа выводила в stdout специальный маркер с результатом. Т.е. с одной стороны мы не запрещаем программе выводить какие-то свои сообщения, но с другой нам нужно получить от неё результат. Маркером будет строка вида: `TEST_SCRIPT_RESULT: VALUE`
Т.е. мы запускаем скрипт и ловим в выводе маркер, вырезая оттуда результат. ~~Ну вот да, ничего лучшего я не придумал.~~
Следующий вопрос, это **обработка ошибок**. Тут всё стандартно. Если код возврата != 0, значит ошибка. В качестве деталей ошибки берём всё что было выведено программой в stderr.
**Глобальные параметры конфигурирования** интерфейса: ну пока считаем что для нашего простого интерфейса они не нужны. Хотя потом я для примера один сделал.
На этом описательная часть закончена. Что получилось
* ***ФОРМАТ ТЕСТА:***
* ***РЕЗУЛЬТАТ:*** В качестве результата скрипт должен вывести на экран (stdout) строку `TEST_SCRIPT_RESULT: VALUE`
* ***ОШИБКИ:*** Если код возврата !=0 считается что произошла ошибка! В случае успеха скрипт должен вернуть код возврата 0.
* ***КОНФИГУРИРОВАНИЕ:*** отсутствует
Тогда приступаем к реализации…
Для того, чтобы наш модуль мог загружаться необходимо реализовать в нём две глобальные функции **uts\_create\_from\_xml(..)** и **uts\_plugin\_name()**.
**Они простые**
```
def uts_create_from_xml(xmlConfNode):
"""
Создание интерфейса
:param xmlConfNode: xml-узел с настройками
:return: объект наследник UTestInterface
"""
return UTestInterfaceScripts(xmlConfNode=xmlConfNode)
def uts_plugin_name():
return "scripts"
```
Сам интерфейс должен наследоваться от базового класса UTestInterface и реализовать необходимые функции. Для начала покажу как выглядит класс UTestInterface.py
**UTestInterface.py**
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from TestSuiteGlobal import *
class UTestInterface():
"""Базовый интерфейс тестирования"""
def __init__(self, itype, **kwargs):
self.itype = itype
self.ignore_nodes = False
def set_ignore_nodes(self, state):
"""
set ignore 'node' for tests (id@node)
:param state: TRUE or FALSE
"""
self.ignore_nodes = state
def get_interface_type(self):
return self.itype
def get_conf_filename(self):
return ''
def validate_parameter(self, name):
"""
Validate test parameter (id@node)
:param name: parameter from or
:return: [ RESULT, ERROR ]
"""
return [False, "(validateParam): Unknown interface.."]
def validate\_configuration(self):
"""
Validate configuration parameters (check-scenario-mode)
:return: [ RESULT, ERROR ]
"""
return [False, "(validateConfiguration): Unknown interface.."]
def get\_value(self, name):
raise TestSuiteException("(getValue): Unknown interface..")
def set\_value(self, name, value, supplier\_id):
raise TestSuiteException("(setValue): Unknown interface...")
```
Начнём с реализации главной функции `get_value(self, name, context)`.
Нам передаётся **name** — в нашем случае это по сути и есть название скрипта.
Но поскольку мы ввели ещё дополнительное поле params, то нам надо обработать и его.
Для того, что бы достучаться до нашего дополнительного поля, воспользуемся таким полезным параметром как **context**. Что в нём ещё есть интересного написано в [документации](https://wiki.etersoft.ru/UniSet2/testsuite/index.html#uts_Context), мы же вытащим xml-узел текущего теста, с учётом того, что его может и не быть (тогда мы выкинем исключение).
```
def get_value(self, name, context):
xmlnode = None
if 'xmlnode' in context:
xmlnode = context['xmlnode']
if not xmlnode:
raise TestSuiteException("(scripts:get_value): Unknown xmlnode for '%s'" % name)
...
```
Для удобства я выделил отдельную функцию (мало ли формат будет меняться потом) которая на вход получает name и context, а возвращает *scriptname* и *parameters*.
Вот она:
**parse\_name()**
```
@staticmethod
def parse_name(name, context):
"""
Разбор строки вида:
:param name: исходный параметр (по сути и есть наш scriptname)
:param context:
:return: [scriptname, parameters]
"""
if 'xmlnode' in context:
xmlnode = context['xmlnode']
return [name, uglobal.to_str(xmlnode.prop("params"))]
return [name, ""]
```
Дальше наш get\_value() должен
* запустить скрипт
* обработать ошибки
* распарсить результат
Я просто приведу полную реализацию
**get\_value()**
```
def get_value(self, name, context):
xmlnode = None
if 'xmlnode' in context:
xmlnode = context['xmlnode']
if not xmlnode:
raise TestSuiteException("(scripts:get_value): Unknown xmlnode for '%s'" % name)
scriptname, params = self.parse_name(name, context)
if len(scriptname) == 0:
raise TestSuiteException("(scripts:get_value): Unknown script name for '%s'" % name)
test_env = None
if 'environment' in context:
test_env = context['environment']
s_out = ''
s_err = ''
cmd = scriptname + " " + params
try:
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=test_env, close_fds=True, shell=True)
s_out = p.stdout.read(self.max_read)
s_err = p.stderr.read(self.max_read)
retcode = p.wait()
if retcode != 0:
emessage = "SCRIPT RETCODE(%d) != 0. stderr: %s" % (retcode, s_err.replace("\n", " "))
raise TestSuiteException("(scripts:get_value): %s" % emessage)
except subprocess.CalledProcessError, e:
raise TestSuiteException("(scripts:get_value): %s for %s" % (e.message, name))
if xmlnode.prop("show_output"):
print s_out
ret = self.re_result.findall(s_out)
if not ret or len(ret) == 0:
return None
lst = ret[0]
if not lst or len(lst) < 1:
return None
return uglobal.to_int(lst)
```
Небольшие пояснения.
Для запуска скрипта мы ещё воспользовались возможностью передать в него свои переменные окружения. В документации это можно почитать в разделе [про скрипты](http://wiki.etersoft.ru/UniSet2/testsuite/index.html#uts_Actions_SCRIPT)
Словарик с переменными окружения мы опять же достаём из контекста: `test_env = context['environment']`
Я позволил себе в реализацию ввести два дополнительных параметра **show\_output=«1»** — это параметр уровня **check**. Включающий вывод на экран всего того, что скрипт там выведет в stdout. По умолчанию скрипты запускаются с отключённым выводом. А второй параметр который я ввёл, это глобальная настройка **max\_read** — которая определяет сколько (первых) байт из вывода нужно прочитать для получения результата. Во первых мне нужно было продемонстрировать как использовать глобальные настройки. А во вторых, я подумал, что ограничить буфер на чтение, неплохая идея. Тем более можно сделать, что если размер задан <=0, то читать всё.
В обработке кода возврата, если код не нулевой, в качестве текста ошибки забираем stderr (делая его попутно в одну строку).
Результат парсим при помощи регулярного выражения.
**Небольшая деталь**В данном случае можно увидеть, что мы ждём завершения запущенной программы. Т.е. подразумеваем, что программы будут достаточно немногословны и
быстро завершающиеся. Всё-таки было бы странно, если программа будет работать «много часов подряд». С другой стороны, можно было бы завершать программу принудительно по timeout-у.
Для проверки нашего интерфейса, создадим каталог *plugins.d* и поместим туда наш модуль. А так же напишем небольшой тест
**Тест для проверки интерфейса**
```
xml version="1.0" encoding="utf-8"?
```
Обращаю внимание, что в секции *Config*, указано, что у нас default-интерфейс type=«scripts». А также указано в теге *TestList* что весь сценарий у нас этого типа.
Помимо сценария не забудем создать и указанные bash-скриптики, примерно такие:
**test-script.sh**
```
#!/bin/sh
echo "TEST SCRIPT: $*"
echo "SHOW OUTOUT..."
echo "TEST_SCRIPT_RESULT: 100"
```
Заодно выведем переменные окружения, чтобы посмотреть на них
**test-script-negative-number.sh**
```
#!/bin/sh
echo "TEST SCRIPT: $*"
echo "SHOW ENV VARIABLES: .."
env | grep MyTEST
env | grep UNISET_TESTSUITE
echo "TEST_SCRIPT_RESULT: -20"
```
В итоге если мы запустим наш сценарий ту увидим такую картину (с учётом параметра *show\_output=«1»* у одного из скриптов и параметром ignore\_failed=«1» у теста):
**команда для запуска**
```
uniset2-testsuite-xmlplayer --testfile tests-scripts-interface.xml --log-show-actions --log-show-tests
```
Но это ещё не всё. Мы реализовали пока-что только одну функцию `get_value(...)`. У нас осталось ещё несколько.
А что насчёт поддержки «действий»(action)? Т.е. реализации функции **set\_value()**…
Я решил, что в нашем интерфейсе, нет смысла делать поддержку потому-что есть штатный механизм
Так что функция наша будет выглядеть так.
**set\_value(..)**
```
def set_value(self, name, value, context):
raise TestSuiteException("(scripts:set_value): Function 'set' is not supported. Use for %s" % name)
```
Идём далее…
У testsuite существует режим --check-scenario в котором проверяется корректность настроек и тестов без фактического их исполнения. Для поддержки этого режима необходимо реализовать две функции **validate\_parameter** и **validate\_configuration**. Поскольку у нас глобальных конфигурационных параметров нет, кроме **max\_output\_read**, то проверять в конфигурации нам особо и нечего. Поэтому функция **validate\_configuration** ничего не делает. А вот **validate\_parameter** чуть более интересна. На самом деле, по скрипту максимум что мы можем проверить (не выполняя его фактически), это:
* задан ли он вообще
* существует ли указанный скрипт
Всё это и отражено в реализации.
**Реализации validate\_parameter() и validate\_configuration()**
```
def validate_configuration(self, context):
return [True, ""]
def validate_parameter(self, name, context):
"""
:param name: scriptname
:param context: ...
:return: [Result, errors]
"""
err = []
xmlnode = None
if 'xmlnode' in context:
xmlnode = context['xmlnode']
scriptname, params = self.parse_name(name, context)
if not scriptname:
err.append("(scripts:validate): ERROR: Unknown scriptname for %s" % str(xmlnode))
if not is_executable(scriptname):
err.append("(scripts:validate): ERROR: '%s' not exist" % scriptname)
if len(err) > 0:
return [False, ', '.join(err)]
return [True, ""]
```
Для примера вывода ошибки, я вставил в сценарий вызов «несуществующего» скрипта.
**Скорректированный сценарий**
```
xml version="1.0" encoding="utf-8"?
```
И если запустить проверку сценария, то получится примерно такая картинка
**команда для запуска**
```
uniset2-testsuite-xmlplayer --testfile tests-scripts-interface.xml --log-show-actions --log-show-tests --check-scenario
```
Ну и теперь уже можно всё сложить и увидеть итоговую версию реализации нашего интерфейса:
**UTestInterfaceScripts.py**
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import sys
import re
import subprocess
from UTestInterface import *
import uniset2.UGlobal as uglobal
class UTestInterfaceScripts(UTestInterface):
"""
Тестовый интерфейс основанный на вызове скриптов.
ФОРМАТ ТЕСТА:
РЕЗУЛЬТАТ: В качестве результата скрипт должен вывести на экран (stdout) строку TEST_SCRIPT_RESULT: VALUE
ОШИБКИ: Если код возврата !=0 считается что произошла ошибка! В случае успеха скрипт должен вернуть код возврата 0.
Дополнительные параметры:
show_output=1 - вывести на экран stdout..
Глобальные конфигурационные параметры (секция ):
max\_output\_read="value" - максимальное количество первых байт читаемое из вывода скрипта, чтобы получить результат.
По умолчанию: 1000
"""
def \_\_init\_\_(self, \*\*kwargs):
"""
:param kwargs: параметры
"""
UTestInterface.\_\_init\_\_(self, 'scripts', \*\*kwargs)
self.max\_read = 1000
if 'xmlConfNode' in kwargs:
xmlConfNode = kwargs['xmlConfNode']
if not xmlConfNode:
raise TestSuiteValidateError("(scripts:init): Unknown confnode")
m\_read = uglobal.to\_int(xmlConfNode.prop("max\_output\_read"))
if m\_read > 0:
self.max\_read = m\_read
self.re\_result = re.compile(r'TEST\_SCRIPT\_RESULT: ([-]{0,}\d{1,})')
@staticmethod
def parse\_name(name, context):
"""
Разбор строки вида:
:param name: исходный параметр (по сути и есть наш scriptname)
:param context:
:return: [scriptname, parameters]
"""
if 'xmlnode' in context:
xmlnode = context['xmlnode']
return [name, uglobal.to\_str(xmlnode.prop("params"))]
return [name, ""]
def validate\_configuration(self, context):
return [True, ""]
def validate\_parameter(self, name, context):
"""
:param name: scriptname
:param context: ...
:return: [Result, errors]
"""
err = []
xmlnode = None
if 'xmlnode' in context:
xmlnode = context['xmlnode']
scriptname, params = self.parse\_name(name, context)
if not scriptname:
err.append("(scripts:validate): ERROR: Unknown scriptname for %s" % str(xmlnode))
if not is\_executable(scriptname):
err.append("(scripts:validate): ERROR: '%s' not exist" % scriptname)
if len(err) > 0:
return [False, ', '.join(err)]
return [True, ""]
def get\_value(self, name, context):
xmlnode = None
if 'xmlnode' in context:
xmlnode = context['xmlnode']
if not xmlnode:
raise TestSuiteException("(scripts:get\_value): Unknown xmlnode for '%s'" % name)
scriptname, params = self.parse\_name(name, context)
if len(scriptname) == 0:
raise TestSuiteException("(scripts:get\_value): Unknown script name for '%s'" % name)
test\_env = None
if 'environment' in context:
test\_env = context['environment']
s\_out = ''
s\_err = ''
cmd = scriptname + " " + params
try:
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=test\_env, close\_fds=True,
shell=True)
s\_out = p.stdout.read(self.max\_read)
s\_err = p.stderr.read(self.max\_read)
retcode = p.wait()
if retcode != 0:
emessage = "SCRIPT RETCODE(%d) != 0. stderr: %s" % (retcode, s\_err.replace("\n", " "))
raise TestSuiteException("(scripts:get\_value): %s" % emessage)
except subprocess.CalledProcessError, e:
raise TestSuiteException("(scripts:get\_value): %s for %s" % (e.message, name))
if xmlnode.prop("show\_output"):
print s\_out
ret = self.re\_result.findall(s\_out)
if not ret or len(ret) == 0:
return None
lst = ret[0]
if not lst or len(lst) < 1:
return None
return uglobal.to\_int(lst)
def set\_value(self, name, value, context):
raise TestSuiteException(
"(scripts:set\_value): Function 'set' is not supported. Use for %s" % name)
def uts\_create\_from\_args(\*\*kwargs):
"""
Создание интерфейса
:param kwargs: именованные параметры
:return: объект наследник UTestInterface
"""
return UTestInterfaceScripts(\*\*kwargs)
def uts\_create\_from\_xml(xmlConfNode):
"""
Создание интерфейса
:param xmlConfNode: xml-узел с настройками
:return: объект наследник UTestInterface
"""
return UTestInterfaceScripts(xmlConfNode=xmlConfNode)
def uts\_plugin\_name():
return "scripts"
```
Итог
----
uniset2-testsuite это простенький велосипед, которого в большинстве случаев может быть достаточно, если тесты укладываются в схему «*подали воздействие — проверили реакцию*». Минимальный набор механизмов для тестирования присутствует:
* Возможность запускать до начала теста всё, что нужно
* Возможность группировать тесты
* Возможность повторного использования тестов (механизм шаблонов и ссылок на внешние файлы
* Настраиваемая обработка завершения тестов
Помимо этого, наличие системы плагинов позволяет легко расширять возможности под свои нужды, реализовывать интерфейс взаимодействия со своей тестовой системой по любому доступному протоколу (будь то REST API или RS485). Нужно только реализовать пару функций.
**Небольшое дополнение**Вообще-то python это не мой основной язык. Сам я программист на C++. Думаю, что это повлияло на архитектуру и скорее всего python позволяет делать какие-то вещи *элегантнее*. Поэтому буду рад конструктивным комментариям и замечаниям.
**Ссылки по теме:**
* [Первая часть статьи](https://habrahabr.ru/post/323290/)
* [Документация по uniset2-testsuite](http://wiki.etersoft.ru/UniSet2/testsuite/)
* [github uniset2-testsuite](https://github.com/Etersoft/uniset2-testsuite)
* [Статья про libuniset2](https://habrahabr.ru/post/278535/) | https://habr.com/ru/post/323444/ | null | ru | null |
# Машинное обучение для поиска ошибок в коде: как я стажировался в JetBrains Research
Недавно мы [рассказывали](https://habr.com/company/hsespb/blog/432912/) о том, как попасть на стажировку в Google. Помимо Google наши студенты пробуют свои силы в JetBrains, Яндекс, Acronis и других компаниях.
В этой статье я поделюсь своим опытом прохождения стажировки в [JetBrains Research](https://research.jetbrains.org/), расскажу о задачах, которые там решают, и подробнее остановлюсь на том, как при помощи машинного обучения можно искать баги в программном коде.
О себе
------
Меня зовут Егор Богомолов, я студент 4-го курса бакалавриата Питерской Вышки по направлению “Прикладная математика и информатика”. Первые 3 года я, как и мои однокурсники, учился в Академическом Университете, а с этого сентября мы всей кафедрой переместились в Высшую школу экономики.
После 2-го курса я ездил на летнюю стажировку в Google Zurich. Там я в течение трех месяцев работал в команде Android Calendar, большую часть времени занимаясь frontend’ом и немного UX-research. Самой интересной частью моей работы было исследование, как могут выглядеть интерфейсы календаря в будущем. Приятным оказалось то, что почти вся проделанная мной работа к концу стажировки попала в основную версию приложения. Но тема стажировок в Google очень хорошо освещена в предыдущем посте, поэтому я расскажу о том, чем занимался этим летом.
Что такое JB Research?
----------------------
JetBrains Research представляет из себя набор лабораторий, работающих в разных областях: языках программирования, прикладной математике, машинном обучении, робототехнике и других. Внутри каждого направления есть несколько научных групп. Я, в силу своего направления, лучше всего знаком с деятельностью групп в сфере машинного обучения. В каждой из них проходят еженедельные семинары, на которых члены группы или приглашенные гости рассказывают о своей работе или интересных статьях в их области. На эти семинары приходит много студентов из Вышки, благо проходят они через дорогу от основного корпуса Питерского кампуса ВШЭ.
На нашей бакалаврской программе мы обязательно занимаемся научно-исследовательской работой (НИР) и два раза в год презентуем результаты исследований. Часто эта работа плавно перерастает в летние стажировки. Это произошло и с моей научно-исследовательской работой: летом этого года я проходил стажировку в лаборатории “Методы машинного обучения в программной инженерии” у своего научного руководителя Тимофея Брыксина. В задачи, над которыми работают в этой лаборатории, входят автоматическое предложение рефакторингов, анализ стиля кода программистов, автодополнение кода, поиск ошибок в программном коде.
Моя стажировка длилась два месяца (июль и август), а осенью я продолжил заниматься поставленными задачами в рамках НИРа. Я работал в нескольких направлениях, самым интересным из них, на мой взгляд, был автоматический поиск багов в коде, про него я и хочу рассказать. Отправной точкой стала [статья Майкла Прадела](http://software-lab.org/publications/DeepBugs_arXiv_1805.11683.pdf).
Автоматический поиск багов
--------------------------
### Как ищут баги сейчас?
Зачем искать баги более-менее понятно. Давайте разберемся, как это делают сейчас. Современные баг-детекторы в основном базируются на статическом анализе кода. Для каждого вида ошибок ищут заранее замеченные паттерны, по которым его можно определить. Затем, чтобы уменьшить количество ложных срабатываний, добавляются эвристики, придуманные для каждого отдельного случая. Паттерны можно искать как в абстрактном синтаксическом дереве (AST), построенном по коду, так и в графах потока управления или данных.
```
int foo() {
if ((x < 0) || x > MAX) {
return -1;
}
int ret = bar(x);
if (ret != 0) {
return -1;
} else {
return 1;
}
}
```
Код и дерево, которое по нему построили.
Чтобы понять, как это работает, рассмотрим пример. Видом багов может быть использование = вместо == в C++. Посмотрим на следующий кусочек кода:
```
int value = 0;
…
if (value = 1) {
...
} else { … }
```
В нем в условном выражении допущена ошибка, при этом первое = в присвоении значения переменной правильное. Отсюда возникает паттерн: если присвоение используется внутри условия в if, это потенциальный баг. Ища такой паттерн в AST, мы сможем обнаружить ошибку и исправить ее.
```
int value = 0;
…
if (value == 1) {
...
} else { … }
```
В более общем случае у нас уже не получится так легко найти способ описать ошибку. Допустим, что мы хотим определять правильность порядка операндов. Опять посмотрим на фрагменты кода:
```
for (int i = 2; i < n; i++) {
a[i] = a[1 - i] + a[i - 2];
}
```
```
int bitReverse(int i) {
return 1 - i;
}
```
В первом случае использование 1-i было ошибочным, а во втором вполне корректным, что понятно из контекста. Но как описать это в виде паттерна? С усложнением вида ошибок приходится рассматривать все больший участок кода и разбирать все больше отдельных случаев.
Последний мотивирующий пример: полезная информация содержится еще и в именах методов и переменных. Ее еще сложнее выразить какими-то вручную заданными условиями.
```
int getSquare(int xDim, int yDim) { … }
int x = 3, y = 4;
int s = getSquare(y, x);
```
Человеку понятно, что, скорее всего, аргументы в вызове функции перепутаны, ведь у нас есть понимание того, что x больше похоже на xDim, чем на yDim. Но как сообщить об этом детектору? Можно добавлять какие-то эвристики вида “имя переменной это префикс имени аргумента”, но, допустим, то, что x чаще является шириной, чем высотой, так уже не выразить.
Итого: проблемой современного подхода к поиску ошибок является то, что очень много работы приходится проделывать руками: определять паттерны, добавлять эвристики, из-за этого добавление поддержки нового типа ошибок в детектор становится трудоемким. Помимо этого сложно использовать важную часть информации, которую в коде оставил разработчик: имена переменных и методов.
### Как может помочь машинное обучение?
Как вы могли заметить, во многих примерах ошибки видны человеку, но их тяжело описать формально. В таких ситуациях часто могут помочь методы машинного обучения. Давайте остановимся на поиске переставленных аргументов в вызове функции и поймем, что нам нужно, чтобы их искать при помощи машинного обучения:
1. Большое количество примеров кода без багов
2. Большое количество кода с ошибками заданного типа
3. Способ векторизации фрагментов кода
4. Модель, которую мы обучим различать код с ошибками и без
Мы можем надеяться, что в большей части кода, выложенного в открытый доступ, аргументы в вызовах функций стоят в правильном порядке. Поэтому для примеров кода без багов можно взять какой-нибудь большой датасет. В случае автора оригинальной статьи это был JS 150K (150 тысяч файлов на Javascript), в нашем случае — аналогичный датасет для Python.
Найти код с багами гораздо сложнее. Но мы можем не искать чьи-то ошибки, а делать их самостоятельно! Для типа ошибок нужно задать функцию, которая по корректному куску кода будет делать испорченный. В нашем случае — переставлять аргументы в вызове функции.
### Как векторизовать код?
Вооруженные большим количеством хорошего и плохого кода мы почти готовы кого-нибудь чему-нибудь учить. До этого нам еще нужно ответить на вопрос: а как представлять фрагменты кода?
Вызов функции можно представить как кортеж из названия метода, названия того, чей это метод, имен и типов аргументов, передаваемых переменных. Если мы научимся векторизовать отдельные токены (имена переменных и методов, все “слова”, встречающиеся в коде), то сможем взять конкатенацию векторов интересных нам токенов и получить желаемый вектор для фрагмента.
Чтобы векторизовать токены посмотрим на то, как векторизуют слова в обычных текстах. Одним из наиболее успешных и популярных способов является предложенный в 2013 году word2vec.
Работает он следующим образом: мы учим сеть предсказывать по слову другие слова, которые встречаются рядом с ним в текстах. Сеть при этом выглядит как входной слой размером равный словарю, скрытый слой размера векторизации, которую мы хотим получить, и выходной слой, тоже размера словаря. В ходе обучения сети подаются на вход вектора с одной единицей на месте рассматриваемого слова (fox), а на выходе мы хотим получать слова, которые встречаются в рамках окна вокруг этого слова (quick, brown, jumps, over). При этом сеть сперва переводит все слова в вектор на скрытом слое, а потом делает предсказание.
Получающиеся в результате векторы для отдельных слов обладают хорошими свойствами. Например, вектора слов с похожим значением близки друг к другу, а сумма и разность векторов являются сложением и разностью “смыслов” слов.
Чтобы сделать аналогичную векторизацию токенов в коде, нужно как-то задать окружение, которое будет предсказываться. Им может выступать информация из AST: типы вершин вокруг, встречающиеся токены, позиция в дереве.
Получив векторизацию можно посмотреть, какие токены похожи друг на друга. Для этого посчитаем косинусное расстояние между ними. В итоге для Javascript получаются следующие соседние вектора (число — косинусное расстояние):
ID и LIT дописанные в начале обозначают, является ли токен идентификатором (имя переменной, метода) или литералом (константа). Видно, что близость является осмысленной.
### Обучение классификатора
Получив векторизацию для отдельных токенов, получить представление для куска кода с потенциальной ошибкой достаточно просто: это конкатенация векторов важных для классификации токенов. По кускам кода обучается двухслойный перцептрон с ReLU в качестве функции активации и dropout для уменьшения переобучения. Обучение сходится быстро, полученная модель имеет маленький размер и может делать предсказания для сотен примеров в секунду. Это позволяет использовать ее в режиме реального времени, о чем будет сказано дальше.
### Результаты
Оценка качества полученного классификатора была разбита на две части: оценка на большом количестве искусственно сгенерированных примеров и ручная проверка на небольшом количестве (50 для каждого детектора) примеров с самой большой предсказанной вероятностью. Результаты для трех детекторов (переставленные аргументы, правильность бинарного оператора и бинарного операнда) получились следующими:
Некоторые из предсказанных ошибок было бы тяжело найти классическими методами поиска. Пример с переставленными res и err в вызове p.done:
```
var p = new Promise ();
if ( promises === null || promises . length === 0) {
p. done (error , result )
} else {
promises [0](error, result).then( function(res, err) {
p.done(res, err);
});
}
```
Также встречались примеры, в которых ошибки не содержится, но переменные стоило бы переименовать, чтобы не вводить человека, пытающегося разобраться в коде, в заблуждение. Например, сложение width и each не кажется хорошей идеей, хотя оказалось и не багом:
```
var cw = cs[i].width + each;
```
### Перенос на Python
Я занимался переносом работы Майкла Прадела с js на python, а затем созданием плагина для PyCharm, реализующим инспекции на основе вышеописанного метода. При этом использовался датасет [Python 150K](https://eth-sri.github.io/py150) (150 тысяч файлов на Python, доступных на GitHub).
Во-первых, оказалось, что в Python встречается больше разных токенов, чем в javascript. Для js 10000 самых популярных токенов составляли больше 90% от всех встречавшихся, в то время как для Python пришлось использовать около 40000. Это привело к росту размера отображения токенов в вектора, что осложнило портирование в плагин.
Во-вторых, реализовав для Python поиск неправильных аргументов в вызовах функции и посмотрев на результаты вручную, я получил долю ошибок больше 90%, что расходилось с результатами для js. Разобравшись в причинах, оказалось, что в javascript большее количество функций объявлено в том же файле, что и их вызовы. Я, последовав примеру автора статьи, сперва не стал разрешать объявления функций из других файлов, что и привело к плохим результатам.
К концу августа я закончил реализацию для Python и написал основу для плагина. Плагин продолжает разрабатываться, теперь этим занимается студентка Анастасия Тучина из нашей лаборатории.
Шаги для того, чтобы попробовать, как работает плагин, вы можете найти в вики репозитория.
Ссылки на github:
[Репозиторий с реализацией для питона](https://github.com/ml-in-programming/DeepBugs)
[Репозиторий с плагином](https://github.com/ml-in-programming/DeepBugsPlugin) | https://habr.com/ru/post/434368/ | null | ru | null |
# Внутренние механизмы ТСР, влияющие на скорость загрузки: часть 1
Ускорение каких-либо процессов невозможно без детального представления их внутреннего устройства. Ускорение интернета невозможно без понимания (и соответствующей настройки) основополагающих протоколов — IP и TCP. Давайте разбираться с особенностями протоколов, влияющих на скорость интернета.
IP (Internet Protocol) обеспечивает маршрутизацию между хостами и адресацию. TCP (Transmission Control Protocol) обеспечивает абстракцию, в которой сеть надежно работает по ненадежному по своей сути каналу.
Протоколы TCP/IP были предложены Винтом Серфом и Бобом Каном в статье «Протокол связи для сети на основе пакетов», опубликованной в 1974 году. Исходное предложение, зарегистрированное как RFC 675, было несколько раз отредактировано и в 1981 году 4-я версия спецификации TCP/IP была опубликована как два разных RFC:
* RFC 791 – Internet Protocol
* RFC 793 – Transmission Control Protocol
С тех пор было сделано несколько улучшений в TCP, но его основа осталась прежней. TCP быстро заменил другие протоколы, и теперь с его помощью функционируют основные компоненты того, как мы представляем себе интернет: сайты, электронная почта, передача файлов и другие.
TCP обеспечивает нужную абстракцию сетевых соединений, чтобы приложениям не пришлось решать различные связанные с этим задачи, такие как: повторная передача потерянных данных, доставка данных в определенном порядке, целостность данных и тому подобное. Когда вы работаете с потоком TCP, вы знаете, что отправленные байты будут идентичны полученным, и что они придут в одинаковом порядке. Можно сказать, что TCP больше «заточен» на корректность доставки данных, а не на скорость. Этот факт создает ряд проблем, когда дело доходит до оптимизации производительности сайтов.
Стандарт НТТР не требует использования именно TCP как транспортного протокола. Если мы захотим, мы можем передавать НТТР через датаграммный сокет (UDP – User Datagram Protocol) или через любой другой. Но на практике весь НТТР трафик передается через TCP, благодаря удобству последнего.
Поэтому необходимо понимать некоторые внутренние механизмы TCP, чтобы оптимизировать сайты. Скорее всего, вы не будете работать с сокетами TCP напрямую в своем приложении, но некоторые ваши решения в части проектирования приложения будут диктовать производительность TCP, через который будет работать ваше приложение.
Тройное рукопожатие
-------------------
Все TCP-соединения начинаются с тройного рукопожатия (рис. 1). До того как клиент и сервер могут обменяться любыми данными приложения, они должны «договориться» о начальном числе последовательности пакетов, а также о ряде других переменных, связанных с этим соединением. Числа последовательностей выбираются случайно на обоих сторонах ради безопасности.
### SYN
Клиент выбирает случайное число Х и отправляет SYN-пакет, который может также содержать дополнительные флаги TCP и значения опций.
### SYN ACK
Сервер выбирает свое собственное случайное число Y, прибавляет 1 к значению Х, добавляет свои флаги и опции и отправляет ответ.
### АСК
Клиент прибавляет 1 к значениям Х и Y и завершает хэндшейк, отправляя АСК-пакет.
*Рис. 1. Тройное рукопожатие.*
После того как хэндшейк совершен, может быть начат обмен данными. Клиент может отправить пакет данных сразу после АСК-пакета, сервер должен дождаться АСК-пакета, чтобы начать отправлять данные. Этот процесс происходит при каждом TCP-соединении и представляет серьезную сложность плане производительности сайтов. Ведь каждое новое соединение означает некоторую сетевую задержку.
Например, если клиент в Нью-Йорке, сервер – в Лондоне, и мы создаем новое TCP-соединение, это займет 56 миллисекунд. 28 миллисекунд, чтобы пакет прошел в одном направлении и столько же, чтобы вернуться в Нью-Йорк. Ширина канала не играет здесь никакой роли. Создание TCP-соединений оказывается «дорогим удовольствием», поэтому повторное использование соединений является важной возможностью оптимизации любых приложений, работающих по TCP.
TCP Fast Open (TFO)
-------------------
Загрузка страницы может означать скачивание сотен ее составляющих с разных хостов. Это может потребовать создания браузером десятков новых TCP-соединений, каждое из которых будет давать задержку из-за хэндшейка. Стоит ли говорить, что это может ухудшить скорость загрузки такой страницы, особенно для мобильных пользователей.
TCP Fast Open (TFO) – это механизм, который позволяет снизить задержку за счет того, что позволяет отправку данных внутри SYN-пакета. Однако и у него есть свои ограничения: в частности, на максимальный размер данных внутри SYN-пакета. Кроме того, только некоторые типы HTTP-запросов могут использовать TFO, и это работает только для повторных соединений, поскольку использует cookie-файл.
Использование TFO требует явной поддержки этого механизма на клиенте, сервере и в приложении. Это работает на сервере с ядром Linux версии 3.7 и выше и с совместимым клиентом (Linux, iOS9 и выше, OSX 10.11 и выше), а также потребуется включить соответствующие флаги сокетов внутри приложения.
Специалисты компании Google определили, что TFO может снизить сетевую задержку при HTTP-запросах на 15%, ускорить загрузку страниц на 10% в среднем и в отдельных случаях – до 40%.
Контроль за перегрузкой
-----------------------
В начале 1984 года Джон Нейгл описал состояние сети, названное им как «коллапс перегрузки», которое может сформироваться в любой сети, где ширина каналов между узлами неодинакова.
Когда круговая задержка (время прохождения пакетов «туда-обратно») превосходит максимальный интервал повторной передачи, хосты начинают отправлять копии одних и тех же датаграмм в сеть. Это приведет к тому, что буферы будут забиты и пакеты будут теряться. В итоге хосты будут слать пакеты по нескольку раз, и спустя несколько попыток пакеты будут достигать цели. Это называется «коллапсом перегрузки».
Нейгл показал, что коллапс перегрузки не представлял в то время проблемы для ARPANETN, поскольку у узлов была одинаковая ширина каналов, а у бэкбона (высокоскоростной магистрали) была избыточная пропускная способность. Однако это уже давно не так в современном интернете. Еще в 1986 году, когда число узлов в сети превысило 5000, произошла серия коллапсов перегрузки. В некоторых случаях это привело к тому, что скорость работы сети падала в 1000 раз, что означало фактическую неработоспособность.
Чтобы справиться с этой проблемой, в TCP были применены несколько механизмов: контроль потока, контроль перегрузки, предотвращение перегрузки. Они определяли скорость, с которой данные могут передаваться в обоих направлениях.
Контроль потока
---------------
Контроль потока предотвращает отправку слишком большого количества данных получателю, которые он не сможет обработать. Чтобы этого не происходило, каждая сторона TCP-соединения сообщает размер доступного места в буфере для поступающих данных. Этот параметр — «окно приема» (receive window – rwnd).
Когда устанавливается соединение, обе стороны задают свои значения rwn на основании своих системных значений по умолчанию. Открытие типичной страницы в интернете будет означать отправку большого количества данных от сервера клиенту, таким образом, окно приема клиента будет главным ограничителем. Однако, если клиент отправляет много данных на сервер, например, загружая туда видео, тогда ограничивающим фактором будет окно приема сервера.
Если по каким-то причинам одна сторона не может справиться с поступающим потоком данных, она должна сообщить уменьшенное значение своего окна приема. Если окно приема достигает значения 0, это служит сигналом отправителю, что не нужно более отправлять данные, пока буфер получателя не будет очищен на уровне приложения. Эта последовательность повторяется постоянно в каждом TCP-соединении: каждый АСК-пакет несет в себе свежее значение rwnd для обеих сторон, позволяя им динамически корректировать скорость потока данных в соответствии с возможностями получателя и отправителя.
*Рис. 2. Передача значения окна приема.*
Масштабирование окна (RFC 1323)
-------------------------------
Исходная спецификация TCP ограничивала 16-ю битами размер передаваемого значения окна приема. Это серьезно ограничило его сверху, поскольку окно приема не могло быть более 2^16 или 65 535 байт. Оказалось, что это зачастую недостаточно для оптимальной производительности, особенно в сетях с большим «произведением ширины канала на задержку» (BDP – bandwidth-delay product).
Чтобы справиться с этой проблемой в RFC 1323 была введена опция масштабирования TCP-окна, которая позволяла увеличить размер окна приема с 65 535 байт до 1 гигабайта. Параметр масштабирования окна передается при тройном рукопожатии и представляет количество бит для сдвига влево 16-битного размера окна приема в следующих АСК-пакетах.
Сегодня масштабирование окна приема включено по умолчанию на всех основных платформах. Однако промежуточные узлы, роутеры и сетевые экраны могут переписать или даже удалить этот параметр. Если ваше соединение не может полностью использовать весь канал, нужно начать с проверки значений окон приема. На платформе Linux опцию масштабирования окна можно проверить и установить так:
```
$> sysctl net.ipv4.tcp_window_scaling
$> sysctl -w net.ipv4.tcp_window_scaling=1
```
В следующей части мы разберемся, что такое TCP Slow Start, как оптимизировать скорость передачи данных и увеличить начальное окно, а также соберем все рекомендации по оптимизации TCP/IP стека воедино. | https://habr.com/ru/post/326258/ | null | ru | null |
# Устаревшие Python-библиотеки, с которыми пора попрощаться
В Python, с каждым релизом, добавляют новые модули, появляются новые и улучшенные способы решения различных задач. Все мы привыкли пользоваться старыми добрыми Python-библиотеками, привыкли к определённым способам работы. Но пришло время обновиться, время воспользоваться новыми и улучшенными модулями и их возможностями.
### Pathlib
Модуль `pathlib` — это, определённо, одно из крупнейших недавних дополнений стандартной библиотеки Python. Этот модуль стал частью стандартной библиотеки начиная с Python 3.4. Правда, многие всё ещё пользуются модулем `os` для работы с файловой системой.
Но модуль `pathlib`, всё же, во многом лучше старого `os.path`. Так, модуль `os` представляет пути в файловой системе в виде обычных строк, а в `pathlib` используется объектно-ориентированный стиль. Благодаря этому повышается читабельность кода и удобство его написания:
```
from pathlib import Path
import os.path
# Старый код с плохой читабельностью
two_dirs_up = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Новый, читабельный код
two_dirs_up = Path(__file__).resolve().parent.parent
```
Тот факт, что пути рассматриваются как объекты, а не как строки, делает, кроме прочего, возможным однократное создание объекта и последующее обращение к его атрибутам или выполнение операций с ними:
```
readme = Path("README.md").resolve()
print(f"Absolute path: {readme.absolute()}")
# Absolute path: /home/martin/some/path/README.md
print(f"File name: {readme.name}")
# File name: README.md
print(f"Path root: {readme.root}")
# Path root: /
print(f"Parent directory: {readme.parent}")
# Parent directory: /home/martin/some/path
print(f"File extension: {readme.suffix}")
# File extension: .md
print(f"Is it absolute: {readme.is_absolute()}")
# Is it absolute: True
```
Одна из моих любимых возможностей `pathlib`, которую я хочу особо отметить, это — допустимость применения оператора `/` (он выглядит как математический оператор «деление») для соединения путей:
```
# Операторы:
etc = Path('/etc')
joined = etc / "cron.d" / "anacron"
print(f"Exists? - {joined.exists()}")
# Exists? - True
```
Это весьма упрощает работу с путями. Эта возможность — ну просто вишенка на «торте» `pathlib`.
Учитывая это — важно отметить, что модуль `pathlib` — это замена лишь для `os.path`, а не для всего модуля `os`. В `pathlib`, правда, включён и функционал из модуля `glob`. Поэтому, если вы привыкли пользоваться `os.path` в комбинации с `glob.glob`, это значит, что, перейдя на `pathlib`, вы можете забыть об их существовании.
В вышеприведённых примерах продемонстрированы некоторые удобные приёмы работы с путями и с атрибутами объекта, представляющего путь. Но в `pathlib` имеются ещё и методы, привычные для тех, кто работал с `os.path`. Например:
```
print(f"Working directory: {Path.cwd()}") # то же, что os.getcwd()
# Working directory: /home/martin/some/path
Path.mkdir(Path.cwd() / "new_dir", exist_ok=True) # то же, что os.makedirs()
print(Path("README.md").resolve()) # то же, что os.path.abspath()
# /home/martin/some/path/README.md
print(Path.home()) # то же, что os.path.expanduser()
# /home/martin
```
Полные сведения о соответствии функций `os.path` и новых функций из `pathlib` имеются в [документации](https://docs.python.org/3/library/pathlib.html#correspondence-to-tools-in-the-os-module).
Больше примеров, демонстрирующих преимущества `pathlib`, можно найти в [этой](https://treyhunner.com/2018/12/why-you-should-be-using-pathlib/) хорошей статье.
### Secrets
Если продолжить разговор о модуле `os`, то ещё одна его часть, которую стоит отправить на покой — это `os.urandom`. Вместо неё лучше использовать новый модуль `secrets`, имеющийся в нашем распоряжении начиная с Python 3.6:
```
# Старый подход:
import os
length = 64
value = os.urandom(length)
print(f"Bytes: {value}")
# Bytes: b'\xfa\xf3...\xf2\x1b\xf5\xb6'
print(f"Hex: {value.hex()}")
# Hex: faf3cc656370e31a938e7...33d9b023c3c24f1bf5
# Новый подход:
import secrets
value = secrets.token_bytes(length)
print(f"Bytes: {value}")
# Bytes: b'U\xe9n\x87...\x85>\x04j:\xb0'
value = secrets.token_hex(length)
print(f"Hex: {value}")
# Hex: fb5dd85e7d73f7a08b8e3...4fd9f95beb08d77391
```
Тут, на самом деле, без проблем можно использовать и модуль `os.urandom`. Но [причина](https://peps.python.org/pep-0506/#rationale) появления модуля `secrets` заключается в том, что программисты использовали модуль `random` для генерирования паролей и прочего подобного. И это — несмотря на то, что модуль `random` не выдаёт криптографически безопасные токены.
Модуль `random`, в соответствии с документацией, не следует использовать для целей, связанных с безопасностью. Надо применять либо `secrets`, либо `os.urandom`. Но предпочтение, определённо, стоит отдать `secrets`, учитывая то, что этот модуль новее, и то, что он включает в себя некоторые утилиты/удобные методы для работы с шестнадцатеричными токенами, а так же — с временными URL-адресами, содержащими маркер безопасности.
### Zoneinfo
До Python 3.9 не существовало встроенного в стандартную библиотеку модуля для преобразований значений даты и времени, связанных с часовыми поясами. Поэтому все пользовались модулем `pytz`. Но теперь в стандартной библиотеке имеется модуль `zoneinfo`. А значит — пришло время переключиться на него!
```
from datetime import datetime
import pytz # pip install pytz
dt = datetime(2022, 6, 4)
nyc = pytz.timezone("America/New_York")
localized = nyc.localize(dt)
print(f"Datetime: {localized}, Timezone: {localized.tzname()}, TZ Info: {localized.tzinfo}")
# По-новому:
from zoneinfo import ZoneInfo
nyc = ZoneInfo("America/New_York")
localized = datetime(2022, 6, 4, tzinfo=nyc)
print(f"Datetime: {localized}, Timezone: {localized.tzname()}, TZ Info: {localized.tzinfo}")
# Datetime: 2022-06-04 00:00:00-04:00, Timezone: EDT, TZ Info: America/New_York
```
Модуль `datetime` делегирует все манипуляции с часовыми поясами абстрактному базовому классу `datetime.tzinfo`. Этот абстрактный базовый класс нуждается в конкретной реализации. До выхода этого модуля такую реализацию, по всей вероятности, брали из `pytz`. А теперь, когда в стандартной библиотеке есть `zoneinfo`, этот модуль можно использовать вместо `pytz`.
У использования `zoneinfo`, правда, есть один нюанс: модуль предполагает, что в системе имеются сведения о часовых поясах. В UNIX-подобных системах это так. Если же в вашей системе таких данных нет — тогда вам понадобится пакет `tzdata`. Это — библиотека, поддержкой которой занимаются основные разработчики CPython. В ней имеется база данных часовых поясов IANA.
### Dataclasses
Важным дополнением Python 3.7 стал пакет `dataclasses` (классы данных), являющийся заменой `namedtuple` (именованных кортежей).
Возможно, у вас появится вопрос о том, зачем менять на что-то `namedtuple`. Существует несколько причин перехода на `dataclasses`:
* Поддерживается мутабельность.
* По умолчанию предоставляются «магические» методы `repr`, `eq`, `init`, `hash`.
* Можно указывать значения по умолчанию.
* Поддерживается наследование.
Кроме того, классы данных поддерживают (начиная с Python 3.10) атрибуты `frozen` и `slots`, что делает их возможности аналогичными возможностям именованных кортежей.
Переход на `dataclasses`, на самом деле, не должен быть особенно сложным, так как для этого достаточно поменять определения классов:
```
# Старый подход:
# from collections import namedtuple
from typing import NamedTuple
import sys
User = NamedTuple("User", [("name", str), ("surname", str), ("password", bytes)])
u = User("John", "Doe", b'tfeL+uD...\xd2')
print(f"Size: {sys.getsizeof(u)}")
# Size: 64
# Новый подход:
from dataclasses import dataclass
@dataclass()
class User:
name: str
surname: str
password: bytes
u = User("John", "Doe", b'tfeL+uD...\xd2')
print(u)
# User(name='John', surname='Doe', password=b'tfeL+uD...\xd2')
print(f"Size: {sys.getsizeof(u)}, {sys.getsizeof(u) + sys.getsizeof(vars(u))}")
# Size: 48, 152
```
В этом коде, кроме прочего, мы исследуем размеры сущностей. Это — одно из самых больших различий между `namedtuple` и `dataclasses`. Как видите, размер именованного кортежа гораздо меньше. Это так из-за того, что классы данных, для представления атрибутов, используют `dict`.
Если сравнить скорость работы `namedtuple` и `dataclasses`, то окажется, что скорость доступа к атрибутам класса данных будет практически такой же, как и при работе с аналогичным именованным кортежем. Она может отличаться настолько незначительно, что на это можно закрыть глаза, но лишь в том случае, если не планируется создавать миллионы экземпляров объектов:
```
import timeit
setup = '''
from typing import NamedTuple
User = NamedTuple("User", [("name", str), ("surname", str), ("password", bytes)])
u = User("John", "Doe", b'')
'''
print(f"Access speed: {min(timeit.repeat('u.name', setup=setup, number=10000000))}")
# Access speed: 0.16838401100540068
setup = '''
from dataclasses import dataclass
@dataclass(slots=True)
class User:
name: str
surname: str
password: bytes
u = User("John", "Doe", b'')
'''
print(f"Access speed: {min(timeit.repeat('u.name', setup=setup, number=10000000))}")
# Access speed: 0.17728697300481144
```
Если вышесказанное убедило вас перейти на классы данных, но вы вынуждены применять Python 3.6 или более раннюю версию языка, можете воспользоваться соответствующим [бэкпортом](https://pypi.org/project/dataclasses/).
И наоборот — если переходить на классы данных вы не хотите, если по какой-то причине вам действительно нужны именованные кортежи, тогда вам стоит, как минимум, пользоваться `NamedTuple` из модуля `typing`, а не из модуля `collections`:
```
# Плохо:
from collections import namedtuple
Point = namedtuple("Point", ["x", "y"])
# Лучше:
from typing import NamedTuple
class Point(NamedTuple):
x: float
y: float
```
И, наконец, если вы не пользуетесь ни `namedtyple`, ни `dataclasses`, то вам, возможно, стоит взглянуть на проект [pydantic](https://pydantic-docs.helpmanual.io/).
### Качественное логирование
Тут речь пойдёт не о некоем недавнем дополнении стандартной библиотеки. Разговоры о логировании не новы, но нелишним будет снова поднять эту тему: используйте адекватные способы логирования вместо инструкций `print`. Если вы занимаетесь локальной отладкой — вполне можно пользоваться `print`. Но для чего-то, уходящего в продакшн, работающего самостоятельно, без вмешательства пользователя, совершенно необходимо нормальное логирование.
К тому же, такое логирование организовать очень просто — достаточно воспользоваться модулем `logging` и выполнить некоторые несложные настройки:
```
import logging
logging.basicConfig(
filename='application.log',
level=logging.WARNING,
format='[%(asctime)s] {%(pathname)s:%(lineno)d} %(levelname)s - %(message)s',
datefmt='%H:%M:%S'
)
logging.error("Some serious error occurred.")
# [12:52:35] {:1} ERROR - Some serious error occurred.
logging.warning('Some warning.')
# [12:52:35] {:1} WARNING - Some warning.
```
Даже та простейшая конфигурация логирования, что показана выше, даст, в сравнении с `print`, серьёзное повышение удобства отладки. Кроме того, библиотеку `logging` можно настраивать и дальше, сделав так, чтобы логи отправлялись бы в разные места, задавая уровни логирования, настраивая автоматическую ротацию логов и так далее. Подробности о том, как всё это настроить, смотрите в одной из моих предыдущих [статей](https://martinheinz.dev/blog/24), посвящённой отладке в Python.
### F-строки
В Python имеется достаточно много способов форматирования строк. Сюда входит форматирование в стиле C, f-строки, шаблонные строки, функция `.format`. Среди этих способов стоит отметить f-строки (f-strings), форматированные строковые литералы. Это — нечто совершенно замечательное. Они, в сравнении с другими способами форматирования строк, удобнее в написании, читабельнее, а ещё — быстрее всех остальных.
В результате я полагаю, что нет смысла что-то доказывать или объяснять, агитируя за использование f-строк. Правда, есть пара ситуаций, когда f-строки использовать не получится.
Так, одна из ситуаций, когда нужно пользоваться форматированием с применением `%` — формирование сообщений для логирования:
```
import logging
things = "something happened..."
logger = logging.getLogger(__name__)
logger.error("Message: %s", things) # Вычисляется в методе логирования
logger.error(f"Message: {things}") # Вычисляется немедленно
```
В этом примере, если воспользоваться f-строками, выражение будет вычислено немедленно. А применение стиля форматирования C позволяет отложить замену шаблона на реальные данные до того момента, когда это будет действительно нужно. Это важно для группировки сообщений, когда все сообщения с одним и тем же шаблоном можно записать как одно сообщение. А с применением f-строк так не получится, так как шаблон заполняется данными до передачи системе логирования.
Кроме того, есть вещи, которые f-строки просто не умеют. Например — формирование шаблона во время выполнения программы, то есть — динамическое форматирование. Именно поэтому использование f-строк называют форматированием с помощью строковых литералов:
```
# Динамическое формирование и шаблона, и его параметров
def func(tpl: str, param1: str, param2: str) -> str:
return tpl.format(param=param1, param2=param2)
some_template = "First template: {param1}, {param2}"
another_template = "Other template: {param1} and {param2}"
print(func(some_template, "Hello", "World"))
print(func(another_template, "Hello", "Python"))
# Динамическое переиспользование одного и того же шаблона с разными параметрами
inputs = ["Hello", "World", "!"]
template = "Here's some dynamic value: {value}"
for value in inputs:
print(template.format(value=value))
```
В итоге можно порекомендовать использовать f-строки везде, где это возможно, так как они читабельнее и производительнее других способов форматирования текста в Python. Но стоит помнить о том, что в некоторых случаях лучше (или необходимо) пользоваться другими механизмами.
> Читайте «[F-строки в Python мощнее, чем можно подумать](https://habr.com/ru/company/wunderfund/blog/674866/)» у нас в блоге
>
>
### Tomllib
TOML — это широко используемый формат конфигурационных файлов, который особенно важен при работе с Python-инструментами и, в целом, в экосистеме Python. Всё дело в том, что он используется в конфигурационных файлах `pyproject.toml`. До настоящего времени для управления TOML-файлами необходимо было использовать внешние библиотеки. Но, начиная с [Python 3.11](https://peps.python.org/pep-0680/), в нашем распоряжении окажется встроенная библиотека, названная `tomllib`, основанная на пакете `tomli`.
Как только вы перейдёте на Python 3.11, у вас должна появиться привычка использовать `import tomllib` вместо `import tomli`. В результате вам придётся заботиться о меньшем количестве зависимостей вашего проекта!
```
# import tomli as tomllib
import tomllib
with open("pyproject.toml", "rb") as f:
config = tomllib.load(f)
print(config)
# {'project': {'authors': [{'email': 'contact@martinheinz.dev',
# 'name': 'Martin Heinz'}],
# 'dependencies': ['flask', 'requests'],
# 'description': 'Example Package',
# 'name': 'some-app',
# 'version': '0.1.0'}}
toml_string = """
[project]
name = "another-app"
description = "Example Package"
version = "0.1.1"
"""
config = tomllib.loads(toml_string)
print(config)
# {'project': {'name': 'another-app', 'description': 'Example Package', 'version': '0.1.1'}}
```
### Setuptools
Наш последний раздел посвящён, в основном, уведомлению о том, что пакет `distutils` признан устаревшим:
Так как пакет `distutils` признан устаревшим, любое использование функций или объектов из этого пакета не приветствуется. Пакет `setuptools` ориентирован на замену или вывод из обращения устаревших механизмов.
Пришло время попрощаться с пакетом `distutils` и перейти на `setuptools`. [Документация](https://setuptools.pypa.io/en/latest/deprecated/distutils-legacy.html) по `setuptools` содержит руководство о том, как перейти с `distutils` на `setuptools`. Кроме того, в PEP 632 можно найти [рекомендации по миграции](https://peps.python.org/pep-0632/#migration-advice) с тех частей `distutils`, которые не перекрывает функционал `setuptools`.
### Итоги
Каждый новый релиз Python несёт в себе новые возможности. Поэтому рекомендую, заглядывая в примечания к выпуску ([release notes](https://docs.python.org/3/whatsnew/3.9.html#new-modules)) Python, обращать внимание на разделы «Новые модули» (New Modules), «Устаревшие модули» (Deprecated modules) и «Удалённые модули» (Removed modules). Это — хороший способ оставаться в курсе крупных изменений стандартной библиотеки Python. При таком подходе вы сможете постоянно включать в свои проекты новые возможности и следовать рекомендациям по разработке.
Возможно, вам кажется, что внесение всех этих изменений и обновлений в проекты потребует большой работы. Но, на самом деле, этот процесс можно облегчить, обработав проекты с помощью `pyupgrade`. Это позволит, там, где это возможно, автоматически обновить код до последней версии Python.
О, а приходите к нам работать? 🤗 💰Мы в [**wunderfund.io**](http://wunderfund.io/) занимаемся [высокочастотной алготорговлей](https://en.wikipedia.org/wiki/High-frequency_trading) с 2014 года. Высокочастотная торговля — это непрерывное соревнование лучших программистов и математиков всего мира. Присоединившись к нам, вы станете частью этой увлекательной схватки.
Мы предлагаем интересные и сложные задачи по анализу данных и low latency разработке для увлеченных исследователей и программистов. Гибкий график и никакой бюрократии, решения быстро принимаются и воплощаются в жизнь.
Сейчас мы ищем плюсовиков, питонистов, дата-инженеров и мл-рисерчеров.
[Присоединяйтесь к нашей команде.](http://wunderfund.io/#join_us) | https://habr.com/ru/post/681284/ | null | ru | null |
# Записки ярого спаммера (чукча не читатель!)
#### Комментирование блогов
**Комментирование блогов** — это размещение комментариев со ссылкой на продвигаемый сайт в блогах.
В данном случае, поиск блогов мы будем производить с помощью Google Blogs — (<https://www.google.com/blogsearch?hl=en&tab=bb>).
1. Открываем Google Blogs.
2. В поле поиска вводим релевантный нашей теме запрос. Например — geek news.
3. Для того, чтобы отсеять ненужные нам блоги, в которых нельзя оставлять комментарии, к запросу добавляем оператор *intext:leave a comment*. Этот оператор будет указывать поисковой системе искать в тексте странички текст “Leave a comment”, который сигнализирует нам, что на ней (страничке), можно оставлять комментарии.
4. При нажатии на кнопку “Поиск” у нас появятся первые результаты.
5. Нашей задачей является переход по ссылкам из SERP, ознакомление со статьями и оставление там комментариев, тематически наследующих смысл статьи. Важно брать более свежие статьи, т.е. из первых 10-ти страниц SERP, но ничего страшного не случится, если оставить комментарий в более устоявшейся статье.
*Например -*
| | |
| --- | --- |
| **URL** | <http://techtards.com/2011/tech-tards-developing-an-ios-app/> |
| **Text** | We are about to start developing an IOS app for the show. We would like to hear from you about what features you would like in the app. Leave us comments below so we can start building a feature list. Who knows which features we will be able to shove into your phone. We look forward to hearing from you. |
6. Ознакомившись со статьей, мы можем предположительно составить текст комментария, базируясь на вышесказанном.
*Например -*
*Wow, that sounds awesome! I’d like the app to be social and google-friendly. Is it hard to include such features? That would be totally cool!*
Такой комментарий имеет большой шанс быть утвержденным модератором.
Написав комментарий, нам нужно заполнить форму о себе. Нас зачастую спрашивают имя, сайт и адрес электронной почты.
Например, на приведенном выше сайте форма выглядит так — 
Все больше и больше блогов вводят социальный плагин для сайтов с возможностью размещать комментарий из социальных сетей, таких как facebook.com. Такие сайты, без возможности оставлять сообщения с указанием Name+Site мы пропускаем.
Также есть сайты, в которых форма для комментирования не содержит в себе поля для ввода сайта. Такие сайты нам **не нужны**, их мы пропускаем.
Иногда попадаются сайты, в которых есть поле для ввода Имени и Местоположения (Name and Location). В таких случаях не нужно писать в поле Location (т.к. под словом Location подрузумевается Ваше территориальное место нахождения) ничего, и вообще лучше пропустить этот сайт.
Также, сайты, которые не преобразуют поле **website** и не привязывают его к полю **name**, нас не интересуют, так как в конечном итоге просто появляется наш продвигаемый запрос без привязки к анкору, т.е. просто как текст:
Такие ссылки мы добавляем с пометкой No-link, чтобы больше не размещать на таких сайтах наши комментарии, не тратить время.
7. В поле **Name** нам нужно ввести анкор, который мы планируем продвигать. В поле **e-mail** нужно ввести адрес, желательно ненужный, (**ВАЖНО** — e-mail должен находиться на известном, надежном почтовом сервере, как google.com; hotmail.com) т.к. подобные сайты таким образом набирают себе подписчиков. В поле **website** нужно ввести адрес продвигаемого сайта. В поле website можно указать внутренние продвигаемые страницы. Т.е. поле website не обязательно должно быть <http://webhostinggeeks.com> но может быть и <http://webhostinggeeks.com/page1/>
8. Теперь нам нужно нажать на кнопку Post a comment. Т.к. большинство блогов сейчас модерируемые, сразу размещенной ссылки мы не увидим. Нужно будет подождать некоторое время, пока модератор проверит сообщение, и, если оно ему понравится, одобрит. Только тогда будет виден результат.
9. Не нужно размещать больше одного комментария на сайте. Даже на разных страницах. **Один сайт = один комментарий**.
10. Также не нужно размещать комментарии с ссылками на бесплатных социальных блог-сетях, типа \*.blogspot.net, \*.wordpress.com и т.д.
#### Основные типы утверждения комментариев модераторами
1. Заблаговременное сообщение *“Comment moderation has been enabled”* до того, как вы разместите комментарий;
2. Постфактум сообщение *“Your comment will be approved after moderation”*;
Иногда случается, что комментарий, оставленный вами, становится видимым, но над ним висит статус *“Your comment is awaiting moderation”* Такого рода ссылки мы заносим в статистику со статусом Pending.
3. Отправка комментария на модерацию без сообщения. Ничего не происходит, просто обновляется страница, нет никаких распознавательных знаков модерации. В таком случае нужно смотреть на адресную строку. После оставления комментариев, она должна измениться на примерно такую — [«http://yoururlhere/#**comment-1234**](http://yoururlhere/#comment-1234). Появление в конце строки текста **comment** означает, что комментарий записан в базу и ожидает модерирования. Такие ссылки помечаются как Pending.
4. Автоматическое размещение. Означает, что модерация отключена.
#### Page Rank
Что такое Page Rank (далее PR) можно узнать тут — <http://en.wikipedia.org/wiki/PageRank>
Узнать PR странички можно посредством сторонних сайтов, таких как <http://www.prchecker.info/check_page_rank.php>.
Или установив аддон для Chrome *SEO Site Tools*. Нам нужен PR каждой странички, на которой мы оставляем комментарий с ссылкой. Грубо говоря, чем выше PR — тем весомее ссылка.
Узнать PR с помощью аддона можно очень просто — иконка аддона в правом верхнем углу изменится на такую же, только с цифрой. Эта цифра и есть PR. Его мы тоже заносим в таблицу отчетности.
| | |
| --- | --- |
| image | Иконка, указывающая, что PR странички равен 5. |
Узнать PR с помощью сайта prchecker.info можно следующим образом:
* Вводим в зеленое поле адрес странички:
* Нажимаем Check PR. Попадаем на страничку, где нас попросят ввести Verification code, чтобы удостовериться, что вы не бот:
* Вводим код и нажимаем кнопку Verify Now. Если вы правильно ввели код, то вы должны увидеть следующее окно:
Как видим, PR этой странички равен 9.
Второй способ проверки PR занимает намного больше времени, поэтому рекомендуется использовать дополнение к браузеру. Дополнения такого плана доступны и для FireFox — *Seo Site Tools*.
#### Rel — “nofollow”
На многих блогах администраторы устанавливают аттрибут nofollow для исходящих ссылок из комментариев. Это служит для того, чтобы уменьшить количество спама в комментариях. Аттрибут nofollow — это аттрибут ссылки, который содержит указание боту поисковой системы не переходить по ссылке, к которой он приставлен.
Например: *```
[Link text](http://www.example.com/)
```*
Такая ссылка не принесет веса для сайта, указанного в ней. Потому ссылки с блогов, в которых комментарии ставятся nofollow мы будем стараться пропускать. Таких большинство. На основе работы по комментированию блогов другими сотрудниками, можно для наглядности привести диаграмму, которая показывает процентное соотношение блогов с nofollow и без них:
В среднем из ста блогов только восемь без аттрибута nofollow. Блоги брались выборочно из SERP Google Blogs. Блоги без nofollow — весьма трастовые блоги, с PR>4.
Как понять, какой тип ссылок устанавливает тот или иной блог нам поможет тот же аддон для Chrome — SEO SitE tools. В панели настроек достаточно лишь поставить галочку напротив пункта Show NoFollow.
После этого все ссылки с аттрибутом nofollow будут выделяться красным цветом. Вот так —
#### Советы по составлению комментариев
1. Комментарий должен быть ПО теме. Он должен отвечать на вопросы, которые, возможно, автор статьи задает. Он может задавать вопросы автору статьи. Он может поощрять автора статьи. Он может спорить с другими пользователями. Главное, чтобы по теме.
2. Комментарий не должен включать в себя ссылку на сторонний ресурс, кроме редких случаев, когда ссылка уместна.
3. Комментарий не должен включать в себя нецензурную лексику, призывы к насилию и расизму. Все то, что запрещено размещать везде.
4. Комментарий не должен содержать в себе много знаков восклицания (!!!!!!), знаков вопроса (??????). Запрещено писать весь текст комментария заглавными буквами.
5. Обязательно смотрим дату последнего комментария. Если последний комментарий был размещен больше месяца назад, то оставлять свой смысла особого не имеет.
6. Комментарии можно будет дополнительно брать из материалов, которые будут представлены позже. Такие комментарии необходимо будет отредактировать и разместить на трастовых блогах, таких как mattcutts.com. Будем делать больше упор на качество, а не количество.
7. Крайне нежелательно наполнять текст комментариев HTML тегами, в особенности тегом [a][/a]. Иногда можно использовать теги форматирования, такие как [b][/b], [i][/i]. Но ими не стоит увлекаться.
##### Немного о спаме
Иногда, после размещения сообщения, вы можете увидеть надпись, сигнализирующая о спаме с вашей стороны.
В таком случае, этот сайт лучше пропустить и воздержаться от размещения комментариев здесь в дальнейшем. Также нужно занести адрес сайта в своего рода “черный список”, чтобы предостеречь себя и ваших коллег от попадания в такие ситуации.
##### FAQ
1. **Как быть если нету поля для сайта? (Вставлять в тексте в виде
```
[text](site)
```
?)**
*Ответ:*
Комментарий с HTML тегами, еще и в виде ссылок не пройдет модерацию. Сайты без поля для ввода web-site мы пропускаем.
2. **Как быть с blogspot.com-овскими сайтами, где есть „Comment as: Name/URL“?**
*Ответ:*
На социальных блог-сетях комментарии мы не оставляем. Исключение: Если блог ведется на blogspot.com движке и НЕ включает в адресе домена \*.blogspot.com
*Пример:*
Не размещаем — site.blogspot.com
Размещаем — site.com
3. **Что делать, если комментарии не появляются на сайте. Скорее всего они на модерации. Сохранять ссылку и идти дальше?**
*Ответ:*
Да, сохранить ссылку и идти дальше. Подробнее о модерации читайте выше.
4. **Что делать с почтой? У меня есть левая которую вписывать в соответствующее поле, она подойдёт?**
*Ответ:*
Да, желательно вписывать левую почту, потому что вас, возможно подпишут на рассылку, даже не уведомив об этом. Почта должна быть на google.com, yahoo.com. Почтовые адреса, заканчивающиеся на \*.mail.ru, \*.bk.ru, \*.online.ua и т.д. более подвержены блокировке со стороны спам-фильтра.
5. **Как быть с livejournal.com? Пропускать или регаться?**
*Ответ:*
LiveJournal.com является социальной блог-сетью. На таких сетях мы не оставляем комментарии.
6. **По одному запросу „latest news intext:leave a comment“ сколько обычно страниц проходить, 5, 10 или 25, прежде чем начинать изменять словосочетания?**
*Ответ:*
Особо жестких рамок в данном случае нет. Старайтесь смотреть, чтобы дата статьи была приближенной к сегодняшнему дню. Т.е. чтобы статья была свежей.
7. **Как можно исключить просмотр сайтов без указания URL? А то из 50 сайтов, только 10, а то и меньше подходящие?**
*Ответ:*
Ответ будет предоставлен как только уточню у специализирующихся лиц.
Перевод с английского яз., источник: [webhostinggeeks.com](http://webhostinggeeks.com/)
Брошюра в PDFке: [Blog Commenting](http://webhostinggeeks.com/guides/blog-commenting/) | https://habr.com/ru/post/143274/ | null | ru | null |
# Почему стоит полностью переходить на Ceylon или Kotlin (часть 1)
В последнее время активную популярность набирает Kotlin. А что если попробовать выбрать более экзотические языки, и применить к ним те же аргументы? Статья написана по мотивам [этой](https://habrahabr.ru/company/mailru/blog/329294/), практически повторяя все аргументы за Kotlin. Основная задача: показать, что Ceylon может практически тоже самое, что и Kotlin, применительно к Java. Но кроме этого у Ceylon есть кое-что еще, что будет описано в следующей статье.
Хочу рассказать о новом языке программирования, который называется Ceylon, и объяснить, почему вам стоит использовать его в своём следующем проекте. Раньше я писал на Java (много и долго, более 10 лет, начиная с Java 1.4 и заканчивая Java 8), и Java мне нравилась. Затем на меня большое впечатление произвела Scala, в результате чего Java как язык стал любить несколько меньше. Но судьба свела меня с языком Сeylon, и в последние полтора года мы пишем на Ceylon везде, где только можно. В реальных коммерческих проектах, правда внутренних. И в данный момент я не представляю себе ситуации, в которой лучше было бы выбрать Java, я не рассматриваю Java как язык, на котором стоит начинать новые проекты.
Ceylon разработан в Red Hat, автор языка — Gavin King, известный по такому фреймворку как Hibernate. Он создавался людьми, которые хорошо понимают недостатки Java, основная цель заключалась в решении сугубо прикладных задач, обеспечение максимально легкой читаемости кода, избегание любых неоднозначностей и подводных камней, во главу всего стала предсказуемость и структурная красота языка. Также большое внимание уделялось приемлемому времени компиляции. В настоящее время версия языка 1.3.2, непосредственно я познакомился с языком, когда вышла версия 1.2.0.
Хотя Ceylon компилируется в JavaScript, я сконцентрируюсь на его первичной среде — JVM.
Итак, несколько причин, почему вам следует полностью переходить на Ceylon (порядок совпадает с одноименными пунктами соответствующей Kotlin статьи):
**0# Совместимость с Java**
Также, как и Kotlin, как и Scala, Ceylon на 100 % совместим с Java. Вы можете в буквальном смысле продолжать работать над своим старым Java-проектом, но уже используя Ceylon. Все Java-фреймворки также будут доступны, и, в каком бы фреймворке вы ни писали, Ceylon будет легко принят упрямым любителем Java. Можно без проблем вызывать из Java Ceylon код, также без проблем вызывается Java код.
**1# Знакомый синтаксис**
Одна из основных особенностей языка Ceylon — максимально удобно читаемый для существующих разработчиков синтаксис. Если взять существующего Java разработчика, то с пониманием Ceylon синтаксиса у него не будет ни малейших проблем. Даже такие языки, как Scala и Kotlin будут менее похожи на Java. Ниже приведен код, показывающий значительное количество конструкций языка, аналогичный примеру на Kotlin:
```
class Foo(String a) {
String b= "b"; // unmodifiable
variable Integer i = 0; // variable means modifiable
void hello() {
value str = "Hello";
print("``str`` World");
}
Integer sum(Integer x, Integer y) {
return x + y;
}
Float maxOf(Float a, Float b) => if (a > b) then a else b
}
```
Соответственно можно без проблем продолжать писать в Java стиле на Ceylon.
**2# Интерполяция строк**
Это как бы более умная и читабельная версия String.format() из Java, встроенная в язык:
```
value x = 4;
value y = 7;
print("sum of ``x`` and ``y`` is ``x + y``") ; // sum of 4 and 7 is 11
```
ИМХО синтаксис здесь будет поприятнее, чем в Kotlin, с Java даже не хочется сравнивать.
**3# Выведение типа**
Ceylon будет выводить ваши типы, если вы посчитаете, что это улучшит читабельность:
```
value a = "abc"; // type inferred to String
value b = 4; // type inferred to Integer
Float c = 0.7; // type declared explicitly
List d = ArrayList(); // type declared explicitly
```
**4# Умные приведения типов (Smart Casts)**
Компилятор Ceylon отслеживает вашу логику и по мере возможности автоматически выполняет приведение типов, т. е. вам больше не нужны проверки instanceof после явных приведений:
```
if (is String obj) {
print(obj.uppercased) // obj is now known to be a String
}
```
**5# Интуитивные равенства (Intuitive Equals)**
Можно больше не вызывать явно equals(), потому что оператор == теперь проверяет структурное равенство:
```
value john1 = Person("John"); //we override equals in Person
value john2 = Person("John");
print(john1 == john2); // true (structural equality)
print(john1 === john2); // false (referential equality)
```
**6# Аргументы по умолчанию**
Больше не нужно определять несколько одинаковых методов с разными аргументами:
```
void build(String title, Integer width = 800, Integer height = 600) {
return Frame(title, width, height);
}
```
**7# Именованные аргументы**
В сочетании с аргументами по умолчанию именованные аргументы избавляют от необходимости использовать Строителей:
```
build("PacMan", 400, 300) // equivalent
build {title = "PacMan"; width = 400; height = 300;} // equivalent
build {title = "PacMan"; height = 300;} // equivalent with default width
```
**8# Выражение switch**
Оператор ветвления заменён гораздо более читабельным и гибким в применении выражением switch:
```
switch (obj)
case(1) { print("x is 1"); }
case(2) { print("x is 2"); }
case(3 | 4) { print("x is 3 or 4"); }
case(is String) { print ("x is String"); }
case([Integer a, Float b, String c]) {print ("x is tuple with Integer ``a``, Float ``b`` and String ``c``");}
else { print("x is out of range");}
```
switch может работать как выражение, также результат switch может быть присвоен переменной:
```
Boolean|IllegalStateException res =
switch(obj)
case(null) false
case(is String) true
else IllegalStateException();
```
Это не полноценный pattern matching, но для большинства случаев хватает и текущего функционала.
В отличие от Kotlin у Ceylon требуется, чтобы к switch все условия были disjoint, то есть не пересекались, что для switch гораздо более логично. Если требуется сопоставление по диапазону или условия могут пересекаться, то нужно использовать обычный if.
**9# Свойства**
Можно добавить публичным полям кастомное поведение set & get, т. е. перестать набивать код безумными геттерами и сеттерами.
```
class Frame() {
variable Integer width = 800;
variable Integer height = 600;
Integer pixels => width * height;
}
```
**10# Data Class**
К сожалению данного функционала пока нет. Очень хотелось бы иметь иммутабельные классы, у которых автоматом переопределен toString(), equals(), hashCode() и copy(), но, в отличие от Java, не занимали 100 строк кода.
Но то, что этого пока нет в языке, не означает что это невозможно сделать. Приведу пример, как нужный функционал реализован у нас через библиотеки, средствами самого языка:
```
class Person(shared String name,
shared String email,
shared Integer age) extends DataObject() {}
value john = Person("John", "john@gmail.com", 112);
value johnAfterBirhstday = john.copy({`Person.age`->113;});
assertEquals(john, john.copy());
assertEquals(john.hash, john.copy().hash);
```
То есть на уровне библиотек получилось переопределить toString, оставить класс иммутабельным, мы получили возможность создавать клоны и изменениями отдельных аттрибутов. К сожалению работает это не так быстро, как могло быть, если бы поддержка была в языке. И нет проверки типов во время компиляции = если мы склонируем с переопределениев возраста и в качестве значения укажем строку, получим ошибку в рантайме. То, что такого функционала пока нет — безусловно плохо. Но то, что нужный функционал при необъодимости можем написать самостоятельно на уровне библиотеки — это очень хорошо.
**11# Перегрузка оператора (Operator Overloading)**
Заранее определённый набор операторов, которые можно перегружать для улучшения читабельности:
```
class Vec(shared Float x, shared Float y) satisfies Summable {
shared actual Vec plus(Vec v) => Vec(x + v.x, y + v.y);
}
value v = Vec(2.0, 3.0) + Vec(4.0, 1.0);
```
**12# Деструктурирующие объявления (Destructuring Declarations)**
Некоторые объекты могут быть деструктурированы, что бывает полезно, к примеру, для итерирования map:
```
for ([key -> [val1, val2, val3]] in map) {
print("Key: ``key``");
print("Value: ``val1``, ``val2``, ``val3``");
}
```
**13# Диапазоны (Ranges)**
Для улучшения читабельности:
```
for (i in 1..100) { ... }
for (i in 0 : 100) { ... }
for (i in (2..10).by(2)) { ... }
for (i in 10..2) { ... }
if (x in 1..10) { ... }
```
В отличие от Kotlin обошлось без ключевого слова downTo.
**14# Функции-расширения (Extension Functions)**
Их нет. Возможно появится, в ранних спецификациях языка такая возможность рассматривалась. Но вместо функций расширений в принципе работают top level функции. Если мы, допустим, хотим добавить к классу String метод sayHello, то "world".sayHello() выглядит не намного лучше чем sayHello("world"). В будущем они могут появиться.
В принципе соответствующие функции, доступные для класса, позволяет находить сама IDE, иногда это работает.
**15# Безопасность Null**
Java следует называть почти статично типизированным языком. Внутри него переменная типа String не гарантированно ссылается на String — она может ссылаться на null. И хотя мы к этому привыкли, это снижает безопасность проверки на статичное типизирование, и в результате Java-разработчики вынуждены жить в постоянном страхе перед NPE.
В Ceylon эта проблема решена посредством разделения на типы, допускающие и не допускающие значение null. По умолчанию типы не допускают null, но их можно преобразовать в допускающие, если добавить ?:
```
variable String a = "abc";
a = null; // compile error
variable String? b = "xyz";
b = null; // no problem
```
За счет функционала union types String? это просто синтаксический сахар для String|Null. Соответственно можно написать:
```
variable String|Null с = "xyz";
с = null; // no problem
```
Ceylon заставляет вас бороться с NPE, когда вы обращаетесь к типу, допускающему null:
```
value x = b.length // compile error: b might be null
```
Возможно, выглядит громоздко, но благодаря нескольким своим возможностям действительно полезно. У нас всё ещё есть умные приведения типов, когда типы, допускающие null, преобразуются в не допускающие:
```
if (!exists b) { return; }
value x = b.length // no problem
```
Также можно использовать безопасный вызов ?., он возвращает значение null вместо бросания NPE:
```
value x = b?.length; // type of x is nullable Int
```
Можно объединять безопасные вызовы в цепочки, чтобы избегать вложенных проверок если-не-null, которые иногда мы пишем в других языках. А если нам по умолчанию нужно не null-значение, то воспользуемся elvis-оператором else
```
value name = ship?.captain?.name else "unknown";
```
Если всё это вам не подходит и вам совершенно точно нужны NPE, то скажите об этом явно:
```
value x = b?.length else NullPointerException() // same as below
assert(!NullPointerException x);
```
**16# Улучшенные лямбды**
Это хорошая система лямбд — идеальный баланс между читабельностью и лаконичностью благодаря нескольким толковым решениям. Синтаксис прост:
```
value sum = (Integer x, Integer y) => x + y; // type: Integer(Integer, Integer)
value res = sum(4,7) // res == 11
```
Соответственно синтаксис может быть:
```
numbers.filter( (x) => x.isPrime() );
numbers.filter(isPrime)
```
Это позволяет нам писать лаконичный функциональный код:
```
persons
.filter ( (it) => it.age >= 18)
.sort(byIncreasing(Person.name))
.map ( Person.email )
.each ( print );
```
Система лямбд плюс синтаксические особенности языка, делает Ceylon неплохим инструментом для создания DSL. Пример DSL, похожего на Anko, в синтаксисе Ceylon:
```
VerticalLayout {
padding = dip(30); {
editText {
hint = "Name";
textSize = 24.0;
},
editText {
hint = "Password";
textSize = 24.0;
},
button {
"Login";
textSize = 45.0;
} }
};
```
**17# Поддержка IDE**
Между прочим, она достаточно неплохая. Есть eclipse плагин, есть IDEA плагин. Да, по части фич и багов все несколько хуже, чем в Scala или Kotlin. Но в принципе работать можно и достаточно комфортно, проблемы IDE на скорости разработки практически не сказываются.
Итого, если брать сильные стороны Kotlin, Ceylon уступает Kotlin отсутствием функционала DataObject (который можно эмулировать самостоятельно средствами библиотек). В остальном он обеспечивает не меньшие возможности, но с более приятным для чтения синтаксисом.
Ну и так же, как и на Kotlin, на Ceylon можно писать для Android.
Прочитав вышесказанное, может сложиться впечатление — а зачем нам это? Тоже самое есть и в Kotlin, практически 1 в 1.
А то, что в Ceylon есть вещи, которых нет ни в Kotlin, ни в Scala, и за счет этих вещей сам язык во многом гораздо лучше, чем другие языки. Например union types, intersection types, enumerated types, более мощные generics, модульность, herd, аннотации и метамодель, кортежи, for comprehensions. Что реально меняет подход к программированию, позволяет писать гораздо более надежный, понятный и универсальный код. Но об этом в [следующей](https://habrahabr.ru/post/330796/) части.
**Для заинтересованных немного полезных ссылок**<https://ceylon-lang.org/documentation/1.3/introduction/>
<https://ceylon-lang.org/documentation/1.3/faq/language-design/>
<https://dzone.com/articles/a-qa-with-gavin-king-on-ceylon>
<https://www.slant.co/versus/116/390/~scala_vs_ceylon>
<https://www.slant.co/versus/390/1543/~ceylon_vs_kotlin>
<https://dzone.com/articles/ceylon-enterprise-ready>
<http://tryge.com/2013/12/13/ceylon-and-kotlin/> | https://habr.com/ru/post/330412/ | null | ru | null |
# Введение в JavaScript итераторы на ES6
В EcmaScript 2015 (также известном как ES6) представлена совершенно новая концепция итераторов, которая позволяет задать последовательности (ограниченные и другие) на уровне языка.
Давайте поговорим об этом детальнее. Все мы хорошо знакомы с оператором цикла for, а многие даже знают его менее популярного брата for-in. Последний можно использовать, чтобы помочь нам объяснить базовые принципы работы с итераторами.
```
for (var key in table) {
console.log(key + ' = ' + table[key]);
}
```
С оператором цикла for-in есть много проблем, но самая большая, пожалуй, состоит в том, что он не дает никаких гарантий последовательности. Попытаемся решить эту проблему с помощью итераторов. Больше информации под катом!
##### Цикл for-of
for-of — новый синтаксис, представленный в ES6, разработанный для работы с итераторами.
```
for (var key of table) {
console.log(key + ' = ' + table[key]);
}
```
В данном примере мы хотим увидеть такое применение итераторов, которое гарантировало бы последовательность ключей. Чтобы объект стал итерабельным, он должен применять итерабельный протокол, то есть объект (или один из объектов выше по цепочке прототипов) должен иметь свойство с ключом Symbol.iterator. Именно это использует for-of, а в данном конкретном примере это будет table [Symbol.iterator].
Symbol.iterator — другое дополнение в ES6, которое мы подробно обсудим, но как-нибудь в другой раз. Пока считайте, что Symbol.iterator — способ, чтобы задать специальные ключи, которые не будут конфликтовать с обычными ключами объектов.
Элемент объекта table [Symbol.iterator] должен быть функцией, которая соответствует протоколу итераторов, то есть она должна возвращать объект следующим образом: { next: function () {}}.
```
table[Symbol.iterator] = function () {
return {
next: function () {}
}
}
```
Каждый раз когда функция next вызывается for-of, она должна возвращать объект, который выглядит так: {value: …, done: [true/false] }. Полная реализация нашего итератора выглядит следующим образом:
```
table[Symbol.iterator] = function () {
var keys = Object.keys(this).sort();
var index = 0;
return {
next: function () {
return {
value: keys[index], done: index++ >= keys.length
};
}
}
}
```
##### Лень
Итераторы позволяют нам откладывать выполнение функции до первого вызова next. В примере выше, как только мы вызываем итератор, начинается процесс получения и сортировки ключей. Однако, что будет, если next не будет вызвана? Просто потратим время зря. Поэтому давайте оптимизируем код:
```
table[Symbol.iterator] = function () {
var _this = this;
var keys = null;
var index = 0;
return {
next: function () {
if (keys === null) {
keys = Object.keys(_this).sort();
}
return {
value: keys[index], done: index++ >= keys.length
};
}
}
}
```
##### Разница между for-of и for-in
Важно понимать разницу между for-of и for-in. Приведем простой, но показательный пример, почему это так.
```
var list = [3, 5, 7];
list.foo = 'bar';
for (var key in list) {
console.log(key); // 0, 1, 2, foo
}
for (var value of list) {
console.log(value); // 3, 5, 7
}
```
Как видите, for-of выдает только значения, которые есть в массиве, и опускает все остальные свойства. Это происходит в следствии того, что итератор массива возвращает только ожидаемые параметры.
##### Встроенные итераторы
[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String), [Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array), [TypedArray](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray), [Map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map), [Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) содержат встроенные итераторы, потому что объекты их прототипов содержат метод Symbol.iterator.
```
var string = "hello";
for (var chr of string) {
console.log(chr); // h, e, l, l, o
}
```
##### Конструкт Spread
Оператор Spread так же может принимать итераторы. Это можно использовать примерно так:
```
var hello = 'world';
var [first, second, ...rest] = [...hello];
console.log(first, second, rest); // w o ["r","l","d"]
```
##### Бесконечный итератор
Применить бесконечный итератор так же легко, как никогда не возвращать done: true. Конечно, необходимо убедиться, что нигде не образовался бесконечный цикл.
```
var ids = {
*[Symbol.iterator]: function () {
var index = 0;
return {
next: function () {
return { value: 'id-' + index++, done: false };
}
};
}
};
var counter = 0;
for (var value of ids) {
console.log(value);
if (counter++ > 1000) { // let's make sure we get out!
break;
}
}
```
##### Генераторы
Если вы еще не знакомы с генераторами в ES6, то самое время почитать [документацию](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*). В двух словах, генераторы — это функции, выполнение которых можно приостановить, а затем возобновить. В последнее время генераторы — самая обсуждаемая функциональность в ES6. Контекст сохраняется между перезапусками. Генераторы содержат оба протокола — Iterable и Iterator. Давайте рассмотрим простой пример:
```
function* list(value) {
for (var item of value) {
yield item;
}
}
for (var value of list([1, 2, 3])) {
console.log(value);
}
var iterator = list([1, 2, 3]);
console.log(typeof iterator.next); // function
console.log(typeof iterator[Symbol.iterator]); // function
console.log(iterator.next().value); // 1
for (var value of iterator) {
console.log(value); // 2, 3
}
```
Принимая во внимание код выше, мы можем переписать код итератора, который сортирует ключи, с использованием генераторов:
```
table[Symbol.iterator] = function* () {
var keys = Object.keys(this).sort();
for (var item of keys) {
yield item;
}
}
```
##### Итог
Итераторы открывают целое новое измерение в работе с циклами, генераторами и наборами переменных. Их можно передавать, задавать как класс описывает список параметров, создавать “ленивые” или бесконечные списки и т.д. и т.п.
##### ES6 сегодня
Как можно ли воспользоваться возможностями ES6 уже сегодня? Использование транспайлеров стало нормой в последние несколько лет. Ни простые разработчики, ни крупные компании не стесняются их применять. [Babel](https://babeljs.io/) — транспайлер из ES6 в ES5, который поддерживает все нововведения ES6.
Если используете [Browserify](http://browserify.org/), то добавить [Babel](https://babeljs.io/) вы сможете всего [за пару минут](http://babeljs.io/docs/setup/). Конечно же, есть поддержка практически для любого билда с Node.js. Например: Gulp, Grunt и многие другие.
##### Как насчет браузеров?
Большинство браузеров постепенно [добавляют новые функции](https://kangax.github.io/compat-table/es6/), но полной поддержки пока нет ни у кого. Что, теперь ждать? Зависит. Имеет смысл начать использовать функции языка, которые станут универсальными через год-два. Это позволит вам комфортно перейти на новый этап. Однако, если вам нужен 100% контроль над исходным кодом, то пока лучше подождать и использовать ES5.
Перевод подготовили: [greebn9k](http://habrahabr.ru/users/greebn9k/)(Сергей Грибняк), [silmarilion](http://habrahabr.ru/users/silmarilion/)(Андрей Хахарев) | https://habr.com/ru/post/264345/ | null | ru | null |
# Доступ к VM в разных облаках по RDP и SSH (Windows и Linux)
[](https://habr.com/ru/company/ruvds/blog/696124/)
[IAP Desktop](https://github.com/GoogleCloudPlatform/iap-desktop) — полезная программа под Windows, которая управляет несколькими удалёнными десктопами и устанавливает туннели SSH/RDP к разным виртуальным машинам под Linux и Windows. Она сочетает преимущества стандартного менеджера RDP-соединений с безопасностью и гибкостью [Identity-Aware Proxy](https://cloud.google.com/iap) (IAP-прокси).
В 2022 году такой инструмент очень актуален, с распространением облачных сервисов и хостингов, где могут крутиться наши виртуальные машины и контейнеры. А также в связи с необходимостью удалённого доступа по RDP и SSH к разным корпоративным виртуалкам.
▍ IAP Desktop
-------------
Опенсорсный клиент [IAP Desktop](https://github.com/GoogleCloudPlatform/iap-desktop) позволяет подключаться не только к контейнерам в облаке Google Cloud, но и к любым другим VM через IAP-прокси. При этом коннект возможен из любой точки мира, а не только из внутренней сети. Утилита подключается даже к инстансам, у которых нет публичного IP-адреса или доступа в интернет через NAT (как это организовано на уровне архитектуры IAP, чуть ниже).
Поскольку туннель для TCP-форвардинга устанавливается по HTTPS, вы можете подключиться к своей рабочей машине даже из-за корпоративного файрвола или прокси.
Программа маленькая (4 МБ), устанавливается за полсекунды, что в эпоху засилья Electron просто удивительно:
Интерфейс крайне простой, всего несколько кнопок с очевидной функциональностью:
Как видим, разные туннели SSH и соединения RDP просто открываются в разных вкладках, а мы переключаемся между ними как в стандартном интерфейсе с табами. Каждая вкладка — отдельный инстанс в своём облаке или на каком-то хостинге. Это могут быть виртуалки на CentOS, Debian, Ubuntu или на разных версиях Windows. Всё подключается по стандартному протоколу Remote Desktop Protocol (RDP) или SSH.
Требования для установки IAP Desktop:
* ОС Windows 8, Windows Server 2012 или выше
* доступ в интернет (хотя бы к Google API), напрямую, через NAT, или через HTTP-прокси;
* для клиента на рабочей машине не требуются права администратора, если только он не установлен на Windows Server, где административные права [нужны обязательно](https://github.com/GoogleCloudPlatform/iap-desktop/wiki/Troubleshooting) — из-за специфического туннелирования RDP программа принимает только аутентификацию NTLM и не может использовать Kerberos;
* нужен [проект Google Cloud](https://cloud.google.com/resource-manager/docs/creating-managing-projects) с правами владельца или хотя бы со следующими ролями:
+ [Compute Viewer](https://cloud.google.com/compute/docs/access/iam) (для просмотра списка VM и доступа к инстансам);
+ [IAP-secured Tunnel User](https://cloud.google.com/iap/docs/managing-access#roles) (для форвардинга IAP TCP).
* [правило файрвола](https://cloud.google.com/vpc/docs/firewalls), разрешающее доступ Identity-Aware-Proxy к инстансам VM.
Это правило в Google Cloud можно задать [следующей командой](https://cloud.google.com/iap/docs/using-tcp-forwarding#preparing_your_project_for_tcp_forwarding):
```
gcloud compute firewall-rules create allow-rdp-ingress-from-iap \
--direction=INGRESS \
--action=allow \
--rules=tcp:3389,tcp:22 \
--source-ranges=35.235.240.0/20
```
После установки IAP Desktop запрашивает доступ к личным данным и проектам в Google Cloud:
В следующем окне необходимо обязательно поставить нижнюю птичку:
В диалоге *Add projects* добавляем проекты.
Для каждого проекта отобразятся доступные виртуальные машины.
К каждой из них можно подключиться в отдельной вкладке, как говорилось выше.
Для подключения к Windows VM по RDP можно сгенерировать новые учётные данные, чтобы создать на инстансе Windows-пользователя и подключиться через него. Как вариант, можно подключиться без создания отдельного юзера. В любом случае IAP Desktop автоматически создаст туннель для переадресации TCP и подключится к машине по RDP:
Посмотрим немного подробнее, как работает прокси IAP и механизм форвардинга TCP.
▍ TCP-форвардинг
----------------
[Функция переадресации (форвардинга) TCP](https://cloud.google.com/iap/docs/tcp-forwarding-overview) позволяет подключаться к произвольным TCP-портам инстансов в облаке, например, на Compute Engine. Как показано на иллюстрации, к одной виртуальной машине идёт обращение по порту TCP 22, а к другой — по TCP 3389.
Для обычного TCP-трафика прокси IAP на локальном хосте создаёт один порт, который перенаправляет весь трафик на определённый инстанс. Затем IAP оборачивает весь трафик от клиента в HTTPS. После аутентификации и авторизации пользователь получает доступ к этому интерфейсу и порту, если у него имеются соответствующие права в политике управления идентификацией и доступом целевого ресурса (Identity and Access Management, IAM).
Особый случай — соединение SSH, созданное командой `gcloud compute ssh`. Оно оборачивает SSH-туннель в HTTPS и сразу направляет на удалённый инстанс. Таким образом, исчезает необходимость в прослушивании порта на локальном хосте.
Включение IAP-прокси для управления доступом не блокирует автоматически прямые запросы к ресурсам. Блокируются только TCP-запросы к соответствующим службам, поступающие с других IP-адресов, не указанных в конфигурации `IAP TCP forwarding IPs`.
Как уже было сказано, TCP-форвардинг с IAP не требует наличия публичного IP-адреса, он использует только внутренние адреса.
▍ Функции прокси
----------------
Таким образом, TCP-форвардинг с IAP выполняет следующие цели:
1. Централизованное управление и контроль. Если у нас много инстансов и VM, то благодаря IAP мы получаем удобный способ удалённого управления ими, в том числе с десктопа под Windows.
2. Защита приложений и инстансов.
3. Совместимость с другими облаками и своим собственным хостингом.
Самое главное, что IAP может защищать приложения не только на Google Cloud, но также в других облаках и на своём хостинге.
В целом, IAP упрощает жизнь системным администраторам и девопсам, которые занимаются управлением облачными сервисами. Теперь они могут сконцентрироваться на логике работы приложений, а IAP берёт на себя аутентификацию и авторизацию.
Десктопный клиент IAP помогает удалённым работникам, которые получают доступ к корпоративным приложениям через публичный URL в браузере, без необходимости запускать VPN-клиент.
При этом прокси IAP обеспечивает защиту от несанкционированного доступа через детализированные политики управления по имени пользователя, уровню защищённости устройства и IP-адресам. Грубо говоря, мы можем разрешить доступ к приложению конкретного списка пользователей только с корпоративных устройств и строго из заданного диапазона корпоративных IP-адресов.
Если обобщить, то IAP создаёт **централизованный уровень авторизации** для приложений по HTTPS. Здесь мы используем модель контроля доступа на уровне приложений вместо файрволов сетевого уровня.
Политики IAP масштабируются на всю организацию. Их можно определять централизованно и применять сразу ко всем своим приложениям и ресурсам.
▍ Универсальный прокси
----------------------
IAP Desktop — опенсорсная программа под лицензией Apache 2.0, её можно свободно использовать в любых своих сервисах, в том числе коммерческих. В том числе для проксирования доступа к сервисам на собственных серверах (on-premise). Инструкции по настройке IAP для доступа к приложению на собственном хостинге см. [здесь](https://cloud.google.com/iap/docs/enabling-on-prem-howto).
В данном случае схема выглядит так:
Практически на любом хостинге можно поднять контейнер с RDP или SSH-сервером — и подключиться к нему по RDP или SSH. Прокси IAP демонстрирует общую методологию для управления виртуальными машинами на разных облаках по типу TCP-over-HTTPS. Например, нечто подобное можно организовать [с помощью stunnel, sslh и traefik](https://vadosware.io/post/stuffing-both-ssh-and-https-on-port-443-with-stunnel-ssh-and-traefik/) или ghostunnel вместо stunnel, авторизация в приложениях Docker/Kubernetes через [JWT Auth Proxy](https://jwt-auth-proxy.readthedocs.io/en/latest/) внутри IAP примерно по такой схеме:
```
IAP = внутри GCP => (JWT proxy -> ghostunnel) = через NAT наружу => (ghostunnel -> клиент)
```
С точки зрения пользователей [очень удобно поднимать в дата-центре отдельные приложения или сервисы в контейнерах](https://fly.io/blog/ssh-and-user-mode-ip-wireguard/) (микро VM), к которым всегда есть прямой доступ по SSH или RDP.
IAP тоже работает по схеме TCP-over-HTTPS, соединяя всё что угодно друг с другом. Для пользователя это выглядит предельно просто: авторизовался с Google — и подключаешься к любым удалённым машинам в одно нажатие кнопки. И [аккаунт Google даже не обязателен](https://cloud.google.com/iap/docs/external-identities): вместо него IAP может использовать аутентификацию по e-mail/паролю, OAuth (Google, Facebook, Twitter, GitHub, Microsoft и др.), SAML, OIDC, по номеру телефону и что угодно другое. Можно вообще разрешить анонимный доступ к приложению.
TCP-over-HTTPS используется как универсальный прокси-посредник для установления зашифрованных соединений между любыми приватными сетями, у которых нет публичных интерфейсов:
Вот пример [программы в 20 строчек на Rust](https://github.com/build-trust/ockam/tree/develop/documentation/use-cases/secure-remote-access-tunnels), которая соединяет приватные сети или клиент с сервером через любое публичное облако, где установлен узел Ockam.
Аналогичный безопасный туннель можно установить с помощью опенсорсного приложения [OpenZiti](https://openziti.io/). По сути, это принцип туннелирования с шифрованием в небезопасной сети (zero trust networking) **без использования VPN**.
Таким образом, принципы IAP отлично подходят для соединения между собой по SSH и RDP любых сервисов, клиентов и приложений на любых хостингах.
Кто-то может спросить, зачем в наше время вообще нужен Windows Server и протокол RDP. Но осталась ещё масса приложений, которые традиционно работают под Windows. На практике получается, что иногда проще поднять на Linux-сервере какой-нибудь контейнер с Windows, чем изменять весь рабочий процесс и переходить на Linux-софт. А что касается протокола RDP, то это уже давно не проприетарная игрушка Microsoft, сейчас даже под Linux он обеспечивает бóльшую эффективность, чем VNC, в некоторых приложениях.
Или вы можете поднять где-то в облаке Windows-виртуалку, чтобы поиграть в игру на мощном компьютере, если домашний ноут не тянет или не поддерживает эту игру, эдакий приватный вариант сервиса GeForce Now или покойной Stadia.
> **[Telegram-канал с полезностями](https://inlnk.ru/dn6PzK) и [уютный чат](https://inlnk.ru/ZZMz0Y)**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=ru_vds&utm_content=dostup_k_vm_v_raznyx_oblakax_po_rdp_i_ssh_windows_i_linux) | https://habr.com/ru/post/696124/ | null | ru | null |
# Используем SWC с Firebase функциями
В этой статье рассмотрим использование компилятора для js-кода облачных функций.
Проблема
--------
Создаем проект. Добавляем Firebase функцию.
```
// index.js
export const helloWorld = https.onRequest(/** … */);
```
Через некоторое время добавляем ещё несколько.
```
// index.js
export const helloWorld = https.onRequest(/** … */);
export const lol = https.onRequest(/** … */);
export const pirojok = https.onRequest(/** … */);
```
Ещё через некоторое время ещё и ещё.
А так как мы пишем код для людей, поэтому помимо кода, в нём будут комментарии и документация.
### Как увеличение количества кода влияет на проект?
Проект Firebase Functions — это node модуль. В `index.js` экспортируются все функции.
При первом запуске любой функции загружаются и инициализируются все импортированные файлы, от всех функций. Node.js загружает `index.js` и весь связанный код через `require` и/или `import`. Это особенность node модулей.
На время инициализации node модуля также влияют выражения, вычисляемые в этот момент.
Следующий пример будет вычисляться при каждой инициализации node модуля:
```
// constants.js
const ONE_MINUTES_IN_MS = 60 * 1000;
```
Далее происходит обработка события функцией.
Поэтому, чем больше кода и чем он сложнее, тем больше времени нужно для инициализации каждой функции.
Решение
-------
Если сократить, упростить код и загружать только используемые модули для запущенной функции, то можно сократить время инициализации функций.
Как можно сократить код? Существуют несколько вариантов, среди них минификация и/или компиляция.
### Минификация и компиляция
Грубо говоря, минификация сделает имена переменных короткими, а компиляция — уберёт неиспользуемый код, пред вычислит и упростит выражения, например: `50 + 50` превратит в `100`.
#### Минификация в действии
До:
```
const hello = sayHello("Pirojok");
console.log(hello, 40 + 2);
function sayHello(name) {
return `Hi, ${name}!`;
}
```
После:
```
"use strict";
const a = b("Pirojok");
console.log(a, 40 + 2);
function b(a) {
return `Hi, ${a}!`;
}
```
#### Компиляция в действии
До:
```
const hello = sayHello("Pirojok");
console.log(hello, 40 + 2);
function sayHello(name) {
return `Hi, ${name}!`;
}
```
После:
```
"use strict";
var name;
const hello = `Hi, ${(name = "Pirojok")}!`;
console.log(hello, 42);
```
#### Компиляция и минификация в действии
До:
```
const hello = sayHello("Pirojok");
console.log(hello, 40 + 2);
function sayHello(name) {
return `Hi, ${name}!`;
}
```
После:
```
"use strict";
var a;
const b = `Hi, ${(a = "Pirojok")}!`;
console.log(b, 42);
```
### Как загружать только используемые модули?
Основная идея — загружать модули в момент выполнения, а не инициализации функций.
Всё что нужно сделать — поместить загрузку модулей в тело обработчика функции.
До:
```
import {https, logger} from "firebase-functions";
import {initializeApp} from "firebase-admin";
initializeApp();
export const helloWorld = https.onRequest((request, response) => {
logger.info("Hello logs!", {structuredData: true, computed: 50 + 50});
response.send("Hello from Firebase!");
});
```
После:
```
import {https, logger} from "firebase-functions";
let app_inited_by_helloWorld = false;
export const helloWorld = https.onRequest(async (request, response) => {
if (!app_inited_by_helloWorld) {
const {initializeApp} = await import("firebase-admin");
initializeApp();
app_inited_by_helloWorld = true;
}
logger.info("Hello logs!", {structuredData: true, computed: 50 + 50});
response.send("Hello from Firebase!");
});
```
Глобальная переменная `app_inited_by_helloWorld` нужна, чтобы `firebase-admin` приложение инициализировалось, только один раз.
В глобальные переменные также можно помещать переменные из импортированных модулей.
Подробнее про [этот трюк](https://firebase.google.com/docs/functions/tips#use_global_variables_to_reuse_objects_in_future_invocations) можно почитать в документации Firebase.
Какой минификатор и компилятор выбрать?
---------------------------------------
В качестве компилятора и/или минификатора можно использовать проект SWC или любой другой.
### Используем SWC
Я выбрал SWC, он умеет минифицировать и компилировать код одновременно.
#### Установка
Установить SWC можно по [инструкции](https://swc.rs/#overview).
Чтобы создать конфигурационный файл `.swcrc` и подобрать нужные вам настройки, я рекомендую использовать [playground](https://swc.rs/playground) проекта. Получить конфигурацию можно нажав кнопку *Edit as JSON*.
Для Firebase Functions рекомендую сразу задать `Env Targets` = `node 16` и убрать `jsc.target` в конечном файле.
*Playground* добавляет в конфигурационный файл опцию `"isModule"` = `true`, её потребуется удалить, если компилятор, будет выдавать ошибку в вашем проекте.
Бонусом можно настроить использование es-модулей, весь старый код, использующий `require`, и новый будут прекрасно жить вместе. Отличная возможность для плавного перехода на es-модули.
#### Подготовка кода проекта
Для того, чтобы код можно было компилировать и использовать, его нужно как-то разделять между собой. Отличным способом является разделение по директориям `src` и `lib`. Если весь код лежит в корне пакета, то это сильно осложнит процесс.
После подготовки можно настроить скрипты для компиляции проекта.
В `package.json` нужно изменить точку входа и добавить скрипты:
```
{
"main": "lib/index.js",
"scripts": {
"dev": "swc src -w -d lib",
"build": "swc src -d lib"
}
}
```
`build` компилирует код из директории `src` в `lib`, а `dev` следит за изменениями файлов и перекомпилирует их. `dev` может потребоваться для удобной работы с эмулятором, для него потребуется установить дополнительный [пакет](https://swc.rs/docs/usage/cli#--watch--w).
#### Автоматизация деплоя
Чтобы не забыть перед деплоем компилировать проект, рекомендую установить predeploy скрипт. Это можно сделать в `firebase.json`.
```
{
"functions": {
"predeploy": [
"npm --prefix \"$RESOURCE_DIR\" run lint",
"npm --prefix \"$RESOURCE_DIR\" run build"
]
}
}
```
Теперь при вызове команды `firebase deploy`, код предварительно будет собран.
### Пример проекта
[Пример](https://github.com/arthurgubaidullin/using-swc-with-firebase-functions) уже настроенного Firebase проекта можно посмотреть на GitHub.
### Подводные камни
Если во время выполнения кода появится ошибка, то прочитать её стектрейс будет затруднительно из-за модификаций кода.
Эта проблема решается генерацией **source maps** и подключением модуля [source-map-support](https://github.com/evanw/node-source-map-support).
### Полезные ссылки
1. [Use TypeScript for Cloud Functions](https://firebase.google.com/docs/functions/typescript) (Firebase Documentation)
2. [Tips & tricks](https://firebase.google.com/docs/functions/tips) (Firebase Documentation)
### Финал
Поздравляю! Теперь ваш проект компилируемый и вы сделали небольшой шаг в его оптимизации.
Чтобы одним из первых прочитать мою следующую статью, можно подписаться на мой [канал](https://t.me/arthur_g_wrotes) в Телеграм.
Если у вас возникли вопросы или замечания, можно свободно писать их в комментариях.
#### Лицензия
Лицензировано под [Attribution 4.0 International (CC BY 4.0)](https://creativecommons.org/licenses/by/4.0/). | https://habr.com/ru/post/670954/ | null | ru | null |
# bobaoskit — аксессуары, dnssd и WebSocket
Таким образом я описал строение системы управляемых программных аксессуаров.
Упрощенная модель включает в себя главный процесс(`bobaoskit.worker`) и скрипты аксессуаров(использующие объекты `bobaoskit.sdk` и `bobaoskit.accessory`). От главного процесса идет запрос к аксессуару для контроля некоторых полей. От аксессуара, в свою очередь, идет запрос к главному на обновление статуса.
В качестве примера возьмем обычное реле.
При входящей команде реле может иногда не изменить свое положение в силу различных причин(зависло оборудование, и прочее). Соответственно, сколько мы не будет отправять команд, статус меняться не будет. И, в другой ситауции, реле может поменять свое состояние при команде от сторонней системы. Его статус в таком случае изменится, скрипт аксессуара может среагировать на входящее событие о смене статуса и отправить запрос главному процессу.
Мотивация
---------
Внедрив на несколько объектов Apple HomeKit, я начал искать похожее на Android, т.к. сам из iOS устройств имею только рабочий iPad. Основным критерием была возможность работать в локальной сети, без облачных сервисов. Так же, что недоставало в HomeKit — ограниченность информации. Для примера можно взять термостат. Все его управление сводится к выбору режима работы(выкл, нагрев, охлаждение и авто) и заданной температуре. Проще — лучше, но, по моему мнению, не всегда. Не хватает диагностической информации. Например, работает ли кондиционер, конвектор, какие параметры вентиляции. Возможно, кондиционер работать не может из-за внутренней ошибки. Учитывая то, что эту информацию можно считать, решено было написать свою реализацию.
Можно было посмотреть варианты, такие как ioBroker, OpenHAB, home-assistant.
Но на node.js из перечисленных только ioBroker(пока пишу статью, обратил внимание, что redis тоже участвует в процессе). И к тому моменту обнаружил каким образом можно организовать межпроцессное взаимодействие и интересно было разобраться с redis, который на слуху в последнее время.
Так же можно обратить внимание на следующую спецификацию:
→ [Web Thing API](https://iot.mozilla.org/wot/)
Устройство
----------
`Redis` помогает межпроцессному взаимодействию, а так же выступает в качестве базы данных для аксессуаров.
Модуль `bobaoskit.worker` случает очередь запросов(поверх `redis` с использованием `bee-queue`), исполняет запрос, записывает/читает из базы данных.
В пользовательских скриптах объект `bobaoskit.accessory` слушает отдельную очередь `bee-queue` для данного конкретного аксессуара, выполняет прописанные действия, отправляет запросы в очередь главного процесса посредством объекта `bobaoskit.sdk`.
Протокол
--------
Все запросы и опубликованные сообщения — строки в `JSON` формате, содержат поля `method` и `payload`. Поля обязательны, даже если `payload = null`.
### Запросы к `bobaoskit.worker`:
* method: `ping`, payload: `null`.
* method: `get general info`, payload: `null`
* method: `clear accessories`, payload: `null`,
* method: `add accessory`,
payload:
```
{
id: "accessoryId",
type: "switch/sensor/etc",
name: "Accessory Display Name",
control: [],
status: []
}
```
* method: `remove accessory`, payload: `accessoryId/[acc1id, acc2id, ...]`
* method: `get accessory info`, payload: `null/accId/[acc1id, acc2id...]`
В поле `payload` можно отправить `null`/`id` аксессуара/массов `id`. Если отправлен `null`, тогда в ответ придет информация о всех существующих аксессуарах.
* method: `get status value`, payload: `{id: accessoryId, status: fieldId}`
В поле `payload` можно отправить объект вида `{id: accessoryId, status: fieldId}`, (где поле `status` может быть массивом полей), либо `payload` может быть массивом объектов такого вида.
* method: `update status value`, payload: `{id: accessoryId, status: {field: fieldId, value: value}`
В поле `payload` можно отправить объект вида `{id: accessoryId, status: {field: fieldId, value: value}}`, (где поле `status` может быть массивом `{field: fieldId, value: value}`), либо `payload` может быть массивом объектов такого вида.
* method: `control accessory value`, payload: `{id: accessoryId, control: {field: fieldId, value: value}}`.
В поле `payload` можно отправить объект вида `{id: accessoryId, control: {field: fieldId, value: value}}`, (где поле `control` может быть массивом `{field: fieldId, value: value}`), либо `payload` может быть массивом объектов такого вида.
В качестве ответа на любой запрос в случае успеха приходит сообщение вида:
`{ method: "success", payload: <...> }`
В случае неудачи:
`{ method: "error", payload: "Error description" }`
Также публикуются сообщения в `redis PUB/SUB` канал(определенный в `config.json`) в следующих случаях: очищены все аксессуары(`clear accessories`); аксессуар добавлен(`add accessory`); аксессуар удален(`remove accessory`); аксесуар обновил статус(`update status value`).
Широковещательные сообщения также содержат два поля: `method` и `payload`.
Клиентский SDK
--------------
### Описание
Клиентский SDK(`bobaoskit.accessory`) позволяет вызывать вышеперечисленные методы из `js` скриптов.
Внутри модуля два объекта конструктора. Первый создает объект `Sdk` для доступа к вышеперечисленным методам, а второй создает аксессуар — обертку поверх этих функций.
```
const BobaosKit = require("bobaoskit.accessory");
// Создаем объект sdk.
// Не обязательно,
// но если планируется много аксессуаров,
// то лучше использовать общий sdk,
const sdk = BobaosKit.Sdk({
redis: redisClient // optional
job_channel: "bobaoskit_job", // optional. default: bobaoskit_job
broadcast_channel: "bobaoskit_bcast" // optional. default: bobaoskit_bcast
});
// Создаем аксессуар
const dummySwitchAcc = BobaosKit.Accessory({
id: "dummySwitch", // required
name: "Dummy Switch", // required
type: "switch", // required
control: ["state"], // requried. Поля, которыми можем управлять.
status: ["state"], // required. Поля со значениями.
sdk: sdk, // optional.
// Если не определен, новый объект sdk будет создан
// со следующими опциональными параметрами
redis: undefined,
job_channel: "bobaoskit_job",
broadcast_channel: "bobaoskit_bcast"
});
```
Объект sdk поддерживает `Promise`-методы:
```
sdk.ping();
sdk.getGeneralInfo();
sdk.clearAccessories();
sdk.addAccessory(payload);
sdk.removeAccessory(payload);
sdk.getAccessoryInfo(payload);
sdk.getStatusValue(payload);
sdk.updateStatusValue(payload);
sdk.controlAccessoryValue(payload);
```
Объект `BobaosKit.Accessory({..})` является оберткой поверх объекта `BobaosKit.Sdk(...)`.
Далее покажу каким образом это оборачивается:
```
// из исходного кода модуля
self.getAccessoryInfo = _ => {
return _sdk.getAccessoryInfo(id);
};
self.getStatusValue = payload => {
return _sdk.getStatusValue({ id: id, status: payload });
};
self.updateStatusValue = payload => {
return _sdk.updateStatusValue({ id: id, status: payload });
};
```
Оба объекта являются так же `EventEmitter`.
`Sdk` вызывает функции по событиям `ready` и `broadcasted event`.
`Accessory` вызывает функции по событиям `ready`, `error`, `control accessory value`.
### Пример
```
const BobaosKit = require("bobaoskit.accessory");
const Bobaos = require("bobaos.sub");
// init bobaos with default params
const bobaos = Bobaos();
// init sdk with default params
const accessorySdk = BobaosKit.Sdk();
const SwitchAccessory = params => {
let { id, name, controlDatapoint, stateDatapoint } = params;
// init accessory
const swAcc = BobaosKit.Accessory({
id: id,
name: name,
type: "switch",
control: ["state"],
status: ["state"],
sdk: accessorySdk
});
// по входящему запросу на переключение поля state
// отправляем запрос в шину KNX посредством bobaos
swAcc.on("control accessory value", async (payload, cb) => {
const processOneAccessoryValue = async payload => {
let { field, value } = payload;
if (field === "state") {
await bobaos.setValue({ id: controlDatapoint, value: value });
}
};
if (Array.isArray(payload)) {
await Promise.all(payload.map(processOneAccessoryValue));
return;
}
await processOneAccessoryValue(payload);
});
const processOneBaosValue = async payload => {
let { id, value } = payload;
if (id === stateDatapoint) {
await swAcc.updateStatusValue({ field: "state", value: value });
}
};
// при входящем значении с шины KNX
// обновляем поле state аксессуара
bobaos.on("datapoint value", payload => {
if (Array.isArray(payload)) {
return payload.forEach(processOneBaosValue);
}
return processOneBaosValue(payload);
});
return swAcc;
};
const switches = [
{ id: "sw651", name: "Санузел", controlDatapoint: 651, stateDatapoint: 652 },
{ id: "sw653", name: "Щитовая 1", controlDatapoint: 653, stateDatapoint: 653 },
{ id: "sw655", name: "Щитовая 2", controlDatapoint: 655, stateDatapoint: 656 },
{ id: "sw657", name: "Комната 1", controlDatapoint: 657, stateDatapoint: 658 },
{ id: "sw659", name: "Кинотеатр", controlDatapoint: 659, stateDatapoint: 660 }
];
switches.forEach(SwitchAccessory);
```
WebSocket API
-------------
`bobaoskit.worker` слушает WebSocket порт, определенный в `./config.json`.
Входящие запросы — `JSON` строки, которые должны иметь следующие поля: `request_id`, `method` и `payload`.
API ограничен следующими запросами:
* method: `ping`, payload: `null`
* method: `get general info`, payload: `null`,
* method: `get accessory info`, payload: `null/accId/[acc1Id, ...]`
* method: `get status value`, payload: `{id: accId, status: field1/[field1, ...]}/[{id: ...}...]`
* method: `control accessory value`, payload: `{id: accId, control: {field: field1, value: value}/[{field: .. value: ..}]}/[{id: ...}, ...]`
Методы `get status value`, `control accessory value` принимают поле `payload` как один объект, либо как массив. Поля `control/status` внутри `payload` так же могут быть как одним объектом, так и массивом.
Так же рассылаются следующие сообщения о событиях от сервера всем клиентам:
* method: `clear accessories`, payload: null
* method: `remove accessory`, payload: accessory id
* method: `add accessory, payload`: {id: ...}
* method: `update status value, payload`: {id: ...}
dnssd
-----
Приложение рекламирует WebSocket порт в локальной сети как сервис `_bobaoskit._tcp`, благодаря npm модулю `dnssd`.
Демо
----
О том как написано приложение с видео и о впечатлениях от `flutter` будет отдельная статья.
Послесловие
-----------
Таким образом, получилась простая система для управления программными аксессуарами.
Аксессуары можно противопоставить объектам из реального мира: кнопки, датчики, переключатели, термостаты, радио. Поскольку нет стандартизации, можно реализовывать любые аксессуары, укладываясь в модель `control < == > update`.
Что можно было сделать лучше:
1. Бинарный протокол позволил бы отправлять меньше данных. С другой стороны, `JSON` быстрее в разработке и понимании. Так же бинарный протокол требует стандартизации.
На этом все, буду рад любой обратной связи. | https://habr.com/ru/post/437846/ | null | ru | null |
# Definer.js — простая модульная система
Пока JavaScript не обзавёлся настоящими модулями мы продолжаем импровизировать.
Так появилась на свет ещё одна реализация модулей — [definer](https://github.com/tenorok/definer).
Главная идея этой модульной системы в отсутствии модульной системы. Исходные коды приложения удобно раскладываются по модулям с указанием зависимостей между собой, а затем собираются в один самодостаточный файл, который ничего про модули не знает.
Для хорошего понимания идеи, под катом примеры от простого к сложному.
Возьмём абстрактную страницу товаров интернет-магазина, `index.html`:
```
Каталог интернет-магазина
* Компьютер, 250
* Телевизор, 100
* Холодильник, 300
```
Будем использовать jQuery для работы с DOM и definer для модулей.
Модуль `Cart`, реализующий корзину интернет-магазина с возможностью добавить товар и получить суммарную стоимость добавленных товаров:
```
definer('Cart', function() {
function Cart() {
this.list = [];
}
Cart.prototype = {
add: function(target) {
var item = $(target);
this.list.push({
name: item.find('.name').text(),
price: +item.find('.price').text()
});
},
sum: function() {
return this.list.reduce(function(sum, item) {
return sum + item.price;
}, 0);
}
};
return Cart;
});
```
Модуль `list`, зависящий от `Cart` и реализующий взаимодействие посетителя с каталогом:
```
definer('list', function(Cart) {
var iCart = new Cart();
$(function() {
$('.item').on('click', function(e) {
iCart.add(e.currentTarget);
console.log(iCart.sum());
});
});
});
```
Получилась страница, где можно кликнуть по товару и в консоли увидеть суммарную стоимость добавленных товаров. Но, при этом, мы разделили функциональность на два самостоятельных модуля.
В данном примере, у нас осталась глобальная переменная, которую тоже можно вынести в модуль, это jQuery.
Подключим файл `modules/clean.js` перед существующими модулями:
```
definer.clean('$');
```
Теперь переменной `$` нет в глобальном контексте:
```
console.log($); // undefined
```
Чтобы продолжать использовать jQuery в модулях, добавим зависимость:
```
definer('Cart', function($) { ... });
definer('list', function($, Cart) { ... });
```
#### Сборка
Теперь всё готово и можно собрать исходники в единый файл.
Устанавливаем сборщик модулей:
```
npm install definer
```
Собираем все модули из директории `modules` в файл `index.js`:
```
./node_modules/.bin/definer -d modules/ index.js
```
Теперь в `index.html` достаточно подключить только jQuery и собранный файл:
```
```
#### Сборка с помощью grunt-definer
Для удобства разработки есть [grunt-плагин](https://github.com/tenorok/grunt-definer). Можно установить мониторинг на изменение файлов модулей и автоматически запускать сборку.
Устанавливаем всё, необходимое для гранта:
```
npm install grunt grunt-cli grunt-contrib-watch grunt-definer
```
Добавим в корень проекта файл `Gruntfile.js`:
```
module.exports = function(grunt) {
grunt.initConfig({
watch: {
scripts: {
files: ['modules/*.js'],
tasks: ['definer:all']
},
},
definer: {
all: {
target: 'index.js',
directory: 'modules/'
}
}
});
grunt.loadNpmTasks('grunt-contrib-watch');
grunt.loadNpmTasks('grunt-definer');
};
```
И запустим мониторинг:
```
./node_modules/.bin/grunt watch
```
Теперь сборка будет выполняться автоматически в фоне, а мы можем изменять файлы модулей и обновлять страницу в браузере, чтобы увидеть результат.
#### Сборка сторонних файлов
Сейчас к странице подключается два файла — jQuery и собранные модули. Можно добавить jQuery в сборку и подключать к странице всего один файл.
Для этого достаточно добавить опцию `clean` в grunt-цель:
```
definer: {
all: {
target: 'index.js',
directory: 'modules/',
clean: {
$: 'jquery.js'
}
}
}
```
Теперь в `index.html` достаточно подключить только один собранный файл:
```
```
#### JSDoc
Возможно формирование JSDoc, содержащего информацию о собранном файле.
Для этого добавим опцию `jsdoc` в grunt-цель:
```
jsdoc: {
"file": "Добавление товаров в корзину интернет-магазина",
"copyright": "2014 Artem Kurbatov, tenorok.ru",
"license": "MIT license",
"version": "package.json",
"date": true
}
```
Возможно указание относительного пути до JSON-файла, из которого сборщик получит значение одноимённого поля.
Положим в корень проекта файл `package.json`:
```
{
"version": "0.1.0"
}
```
Перед модулями в собранном файле появится такой JSDoc:
```
/*!
* @file Добавление товаров в корзину интернет-магазина
* @copyright 2014 Artem Kurbatov, tenorok.ru
* @license MIT license
* @version 0.1.0
* @date 17 February 2014
*/
```
#### Итого
Definer помогает:
* разбить всё приложение на модули по зависимостям
* избавиться от глобальных переменных
* собирать все скрипты в один файл с помощью grunt-плагина
Документацию по [definer](https://github.com/tenorok/definer) и [grunt-definer](https://github.com/tenorok/grunt-definer) можно найти на гитхабе. | https://habr.com/ru/post/212817/ | null | ru | null |
# Service mesh для микросервисов. Часть II, основы работы с Istio
*Перевод статьи подготовлен специально для студентов курса [«Инфраструктурная платформа на основе Kubernetes»](https://otus.pw/w5x9/).*
Настройка базового микросервиса в Kubernetes обманчиво проста. В [одной из последних статей](https://medium.com/devopslinks/microservices-orchestration-with-kubernetes-1cbb737cfa46) мы рассказали, как легко начать работать с контейнерами. Мы скомпоновали простой образ Docker, развернули его с помощью Kubernetes и выполнили запрос приложения. Это было нетрудно, но в жизни облачные архитектуры, как правило, сложнее. Они включают десятки и даже сотни сервисов с базами данных, аутентификацией и другими нужными в реальности элементами.
Администрировать их порой — сплошная головная боль. В этой статье мы расскажем об Istio — инструменте для service mesh (эту архитектуру мы [рассматривали ранее](https://habr.com/ru/company/otus/blog/476358/)), который выводит управление крупными облачными развертываниями на новый уровень.
Микросервисы дают вам широкие возможности масштабирования, а service mesh дополняет их преимуществами централизации, типичными для монолитных сред (например, журналами и контролем версий). Подробнее об особенностях и преимуществах service mesh мы писали в предыдущей [статье](https://medium.com/@asad_5112/microservices-mesh-part-i-16ec52074dd2) из этой серии.
Эта же публикация посвящена возможностям Istio для реализации шаблона облачной архитектуры с использованием mesh-сетей. Мы научимся настраивать плоскость управления, рассмотрим сильные стороны Istio и, наконец, возьмем сервис Kubernetes, с которым работали в прошлый раз, добавим к нему sidecar-прокси и свяжем его со свежесозданной плоскостью управления.
Знакомство с плоскостью данных и sidecar-прокси
===============================================
Два основных архитектурных термина в Istio — плоскость данных (data plane) и плоскость управления (control plane). Плоскость данных работает с данными, которые перемещаются в приложении, передаются различным экземплярам сервисов и обрабатываются самими сервисами. Для ее реализации используется главным образом sidecar-прокси. На уровне управления определяется порядок инстанцирования сервисов, место хранения данных телеметрии и информации о сервисах. К основным элементам плоскости управления относятся Pilot и Mixer. Давайте разберемся, как это все работает.
Sidecar-прокси выполняется вместе с подом, который определяет ваш сервис в Kubernetes. Он добавляется к основным компонентам сервиса и работает с трафиком, который направляется в этот сервис. Вы можете добавить sidecar-прокси к существующему определению сервиса в поде: в сервис просто добавятся строки, определяющие sidecar-прокси, и он начнет работать.
Взамен вы получите целый список преимуществ, которые лежат в основе облачной mesh-сети Istio. Sidecar-прокси перехватывает трафик, поступающий в сервис, и позволяет осуществлять его интеллектуальную маршрутизацию. Речь идет и о простых задачах, таких как балансировка нагрузки или обработка прерываний TLS, которые заметно ускоряют работу, и о более сложных процессах, таких как контроль версий, поэтапное развертывание новой версии сервиса и сбор показателей использования ресурсов. Sidecar-прокси позволяет добавлять все эти возможности в существующую архитектуру микросервисов *без реорганизации всей системы*.
Как только проясняется первоначальное предназначение sidecar-прокси, становятся очевидными преимущества Istio и облачных service mesh в целом. Фактически все sidecar-прокси архитектуры в совокупности, функционируя как унифицированные связующие элементы между подами сервисов, пропускают через себя весь трафик, проходящий через приложение. Это значит, что при необходимости усилить защиту они выступают в роли единого расположения, где можно добавлять процессы аутентификации и протокол HTTPS между сервисами, вести журнал событий для проверки на наличие аномалий и развертывать средства управления трафиком и фильтрации для проверки подлинности.
Кроме того, поскольку sidecar-прокси работают как центральные конечные точки для коммуникации между сервисами, они позволяют повысить отказоустойчивость приложения и добавить дополнительный уровень масштабируемости. Один из недостатков микросервисов заключается в том, что все поды серверов изолированы, и, если с микросервисом что-то не так, запросы могут медленно обрабатываться или вовсе сбрасываться. Благодаря sidecar-прокси можно централизованно добавлять тайм-ауты, настраивать интеллектуальную балансировку нагрузки и расширять возможности мониторинга.
Централизация: плоскость управления
===================================
Помимо плоскости данных Istio включает плоскость управления. Она играет роль контроллера для всех sidecar-прокси, выполняемых в приложении, и центрального репозитория для всей информации (такой как записи журналов и сведения о версиях), который воспринимается сервисами в сети как единый источник достоверных данных.
При работе с Istio основным способом взаимодействия с плоскостью управления является Kubernetes. После установки пакетов Istio и добавления определений можно использовать для доступа к плоскости управления команды `kubectl`, которые управляют состоянием системы. Например, процесс обновления пода до новой версии с помощью `kubectl` начинается с обновления переменных локальной плоскости управления.
Это проще всего увидеть, воспользовавшись командой `get-svc` в составе `kubectl` — вы получите список сервисов, связанных с конкретной библиотекой. Чтобы проверить, какие компоненты Istio выполняются, можно воспользоваться следующей командой:
```
kubectl get svc -n istio-system
```
Отобразится список основных элементов плоскости управления Istio, выполняемых в фоновом режиме. Возможно, некоторые из них вам уже знакомы, например Citadel — сервис, который управляет защитой трафика между сервисами.
Установка Istio
===============
Давайте посмотрим, какие возможности Istio поддерживает по умолчанию. Мы установим плоскость управления Istio для администрирования базового API HTTP, который был описан в предыдущей [статье](https://medium.com/devopslinks/microservices-orchestration-with-kubernetes-1cbb737cfa46). Этот сервис API был определен в Kubernetes и реализован как одиночный под Kubernetes с выполняемым в нем API.
Чтобы установить Istio, выполняйте шаги, описанные в кратком официальном [руководстве](https://istio.io/docs/setup/kubernetes/quick-start/). Начните с загрузки последней версии Istio с соответствующей [страницы](https://istio.io/docs/setup/kubernetes/download-release/). Программа все еще активно развивается, поэтому работать лучше всего с ее последними выпусками. Просто скачайте файл и удостоверьтесь, что он доступен в нужном каталоге.
Затем добавьте определения Istio в Kubernetes, чтобы их можно было использовать с инструментом командной строки `kubectl`. Добавьте полученные ранее файлы `.yaml` в каталог установки с помощью команды `kubectl apply`:
```
kubectl apply -f install/kubernetes/helm/istio/templates/crds.yaml
```
Затем активируйте установку Istio, выбрав способ аутентификации. Я буду использовать доступную по умолчанию взаимную HTTPS-аутентификацию, которая отлично подходит для проведения демонстраций и начала работы. Чтобы добавить service mesh в существующий проект, нужно еще немного разобраться с доступными опциями. На данном этапе можно выполнить следующую команду:
```
kubectl apply -f install/kubernetes/istio-demo-auth.yaml
```
После этого вы сможете продолжить. Вам нужно будет добавить структуру Istio в поды, которые были созданы ранее, а для новых подов — добавлять Istio как зависимость.
Развертывание приложения helloworld
===================================
Воспользуемся пробным приложением helloworld, которое описано в нашей более ранней [публикации](https://medium.com/devopslinks/microservices-orchestration-with-kubernetes-1cbb737cfa46). Будут созданы: одно развертывание, один сервис, один шлюз и один виртуальный сервис. Обновите файл конфигурации, чтобы он совпадал со следующим:
helloworld.yaml
```
apiVersion: v1
kind: Service
metadata:
name: helloworld
spec:
type: ClusterIP
ports:
- port: 80
targetPort: 8080
selector:
app: helloworld
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: helloworld-v1
spec:
replicas: 1
selector:
matchLabels:
app: helloworld
template:
metadata:
labels:
app: helloworld
version: v1
spec:
containers:
- name: helloworld-kubernetes - image: haseebm/helloworld-kubernetes
ports:
- containerPort: 8080
---
apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
name: helloworld-gateway
spec:
selector:
istio: ingressgateway # use istio default controller
servers:
- port:
number: 80
name: http
protocol: HTTP
hosts:
- "*"
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
name: helloworld
spec:
hosts:
- "*"
gateways:
- helloworld-gateway
http:
route:
- destination:
host: helloworld
port:
number: 80
```
Внедрение sidecar-прокси Istio вручную
======================================
Istio задействует образец sidecar-прокси, чтобы разместить контейнер sidecar-прокси Istio в одном поде с контейнером приложения helloworld.
```
$ kubectl apply -f <(istioctl kube-inject -f helloworld.yaml)
service/helloworld created
deployment.extensions/helloworld-v1 created
gateway.networking.istio.io/helloworld-gateway created
virtualservice.networking.istio.io/helloworld created
```
Проверьте, чтобы поды и сервис выполнялись:
```
$ kubectl get pod,svc | grep helloworld
pod/helloworld-v1-1cbca3f8d5-achr2 2/2 Running
service/helloworld ClusterIP 10.160.58.61
```
Теперь проверьте трафик для приложения helloworld:
```
$ curl a2******.ap-southeast-1.elb.amazonaws.com/api/hello
```
Hello world v1
Следующие шаги
==============
Istio — это отличный способ познакомиться с облачными технологиями mesh-сетей и интеллектуальным управлением микросервисами в целом. Как мы уже не раз писали, правильно администрируемые микросервисы обладают множеством технических преимуществ, в том числе с точки зрения масштабирования. Однако чтобы получить эти преимущества, нужно эффективно использовать существующие технологии.
В дальнейшем мы рассмотрим другие сценарии применения Istio и облачных mesh-сетей для улучшения безопасности и управляемости нашей пробной архитектуры. Так, следующая статья будет посвящена управлению развертываниями и обновлением версий в Istio для эффективного распространения обновлений кода без перебоев в работе и повреждения развертываний.
Асад Файзи (Asad Faizi),
учредитель и исполнительный директор, CloudPlex.io, Inc
[asad@cloudplex.io](https://mail.google.com/mail/?view=cm&fs=1&tf=1&to=asad@cloudplex.io)
[www.cloudplex.io](http://www.cloudplex.io/) | https://habr.com/ru/post/477434/ | null | ru | null |
# Запускаем консольные Java приложения на Android
Речь пойдёт о проекте-утилитке, который может пригодиться всякому кто изучает Java и не всегда имеет под рукой ПК для просмотра работы примера кода в полевых условиях (как-то — в метро, маршрутке, кафешке и т.д.).
Необходимость создать сие поделище возникла когда я готовился к OCJP-сертификации. После успешного прохождения оной, решил предоставить плоды своих задумок на обозрение уважаемым участникам хабрасообщества.
Ноутбука у меня нет, а запускать примеры кода на смартфоне, сидя на кухне за чашечкой чая, удобно.
Так уж повелось, что бо́льшая часть примеров для обучения обычно приводится именно в формате консольных программ. Замечательный инструмент [AIDE](https://play.google.com/store/apps/details?id=com.aide.ui&hl=ru) позволяет собирать Android-приложение на основе Eclipse-проектов. Возможность, увы, недостаточная для запуска консольных примеров методом копипасты.
Дело за малым — перенаправляем потоки ввода/вывода в UI контролы:
```
private static OutputStream mOutputStream = new OutputStream() {
@Override
public void write(int b) {
MainActivity.getInstance().write((byte)b);
}
};
@Override
public void onCreate(Bundle savedInstanceState) {
...
System.setOut(new PrintStream(mOutputStream));
System.setErr(new PrintStream(mOutputStream));
...
}
```
Консольная программа стартует в отдельном потоке из обработчика activity `onResume()`:
```
@Override
public void run() {
try {
//
// Здесь запускается консольное приложение
//
Program.main(new String[0]);
} catch (Throwable ex) { // Тут же ловим все исключения
setErrorColor();
ex.printStackTrace();
}
}
```
Здесь же можно задавать аргументы командной строки — старый добрый `args`. Пример — запуск `BankTellerSimulation` на 10 секунд:
```
BankTellerSimulation.main(new String[] { "10" });
```
Поддерживается работа нескольких потоков (`SimpleThreadsTest`):
`HorseRace` и `BankTellerSimulation` — примеры более сложных многопоточных приложений (взяты из книги *Thinking in Java, 4th Ed by Bruce Eckel*).
##### Ошибки времени выполнения
Пример `ErrorTest`:
```
class FuuuuuuException extends RuntimeException {
public FuuuuuuException(String message) {
super(message);
}
}
...
throw new FuuuuuuException("!!!TROLLFACE!!!");
```
Получаем исключение:
##### Ввод
Напоследок, для полноты возможностей, был добавлен консольный ввод. Пока что мои познания в области пользовательского интерфейса Android не велики. Кое-как впихнуть `EditText` удалось, но результат не идеален :)
Приглашение ввода строки (`ReadingInputTest`):
Далее:
##### Функции меню
*Exit* выключает процесс через `System.exit(0)`.
Программа «одноразовая». Повторных перезапусков нет (не хотелось возиться с очисткой значений статических полей).
Что делает *Clear* — большой секрет.
##### Что не работает
• `assert`'ы Java. Т.е. оператор
```
assert "Cat".equals("Dog");
```
исключение `java.lang.AssertionError` не кинет. Не путать с assert'ами JUnit — с ними всё [в порядке](http://habrahabr.ru/post/162741/#comment_5599467)!)
• Класс `Console`.
• Поле ввода не всегда подхватывает фокус.
##### Файлы проекта
Исходники можно забрать с [GitHub](https://github.com/pnetesa/ConsoleApp), либо скачать [**zip-архив**](https://dl.dropbox.com/u/20368586/ConsoleApp.zip) с проектами для Android Studio и Eclipse.
Описанные примеры находятся в пакете `com.examples`. Все примеры можно без изменений запускать на обычном ПК (run everywhere!). | https://habr.com/ru/post/162741/ | null | ru | null |
# Оказывается, собственные NVMe-накопители Apple невероятно быстры, только если вы не заботитесь о целостности данных
Факт того, что в MacOS функция `fsync()` работает по-другому, не как в привычном всем Linux, далеко не новость. Но многие о нем забывают. Особенной хронической формой маразма страдают авторы бенчмарков. 17 февраля Hector Martin ([@marcan42](https://twitter.com/marcan42)) (разработчик [Asahi Linux](https://asahilinux.org/)) в очередной раз подтверждает это [своим постом](https://twitter.com/marcan42/status/1494213855387734019?cxt=HHwWhsDSzbblwbwpAAAA) в Твиттере.
Когда программа сохраняет информацию на диск, для особо чувствительной к потере информации программе необходимо дождаться освобождение кэша, чтобы имела место быть уверенность в том, что информация, во-первых сохранилась как факт, во-вторых сохранилась в нужном порядке. Для этого еще в первых версиях Unix была реализована функция `fsync()`. В линуксе эта функция реализована в glibc. По изначальному дизайну, `fsync()` должна возвращать результат только после полного опорожнения дискового кэша.
У разработчиков MacOS немного иной взгляд на этот процесс. Пробежавшись по манам [fsync](https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/fsync.2.html) и [fcntl](https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/fcntl.2.html#//apple_ref/doc/man/2/fcntl), можно сделать выводы. По мнению Apple, опорожнение кэша может длиться слишком долго, нет необходимости ждать столько времени. Чтобы программы не морозились при сохранении данных, выполнение функции `fsync()` можно игнорировать. Ну а прошивка контролера диска сама разберётся, когда ей надо будет опорожнять кэш, и надо ли его опорожнять вообще.
Для чувствительным к целостности и сохранности данных существует флаг F\_FULLSYNC. И он работает. Но возникает другая проблема. В таком режиме сохранение информации на собственные накопители Apple, устанавливаемые с процессорами линейки M1, происходит со скоростью около 6 Мб/сек и может проседать до 600 Кб/сек. Современные карты MicroSD подключенные через USB 2.0 работают быстрее. Сам Гектор Мартин сравнивает работу с первой попавшейся флешкой USB 3.0. Разумеется, запись на флешку происходит быстрее чем на встроенный NVMe-накопитель, ведь у флешки нет кэша. - с нотками сарказма отмечает он.
Игнорирование `fsync()` искусственно увеличивает мнимую производительность накопителя. Но с другой стороны это может привести к не полному сохранению данных или полному не сохранению данных в случаях перебоев подачи питания, неожиданного зависания или перезагрузки ОС, или даже простой ошибки сегментации. И тут важен не факт потери информации, а факт получаемого программой от ОС подтверждения о том, что данные были сохранены.
Hector Martin провел несколько тестов сохранения и последующими неожиданными для системы перезагрузками. И его опасения подтвердились. Сохраненный на диск файл после перезагрузки отсутствует в файловой системе.
Спустя несколько дней, другой энтузиаст Russ Bishop ([@xenadu02](https://twitter.com/xenadu02)) провел [серию подобных тестов](https://twitter.com/xenadu02/status/1495693475584557056) с четырьмя SSD-накопителями разных производителей. Метод тестирования довольно прост. Сразу после сохранения данных в файл с заранее заданным путём обесточивает компьютер образно выдёргиванием вилки шнура из розетки. В [результате тестов](https://twitter.com/xenadu02/status/1495809737396469765) два накопителя теряли данные частично или полностью, и два накопителя не теряли никаких данных на всех этапах тестирования.
Точные названия накопителей, которые сохраняли все данные:
* Samsung 970 Evo Plus: MZ-V7S2T0, 2021.10
* WD Red: WDS100T1R0C-68BDK0, 04Sept2021
Названия накопителей, теряющих данные:
* SK Hynix Gold P31 2TB SHGP31-2000GM-2, FW 31060C20
* Sabrent Rocket 512 (Phison PH-SBT-RKT-303 controller, версия ПО не указана)
Днем позже было проведено подобное испытание еще нескольких SSD-дисков, все они прошли проверку сохранив все данные:
* Crucial P5 Plus 1TB CT1000P5PSSD8, FW P7CR402
* Kingston SNVS/250G, 012.A005
* Seagate Firecuda 530 PCIe Gen 4 1TB ZP1000GM30013, FW SU6SM001
* Intel 670p 1TB, SSDPEKNU010TZ, FW 002C
* Crucial P2 250GB CT250P2SSD8, FW P2CR046
* Samsung 980 250GB MZ-V8V250, 2021/11/07
* WD Black SN750 1TB WDS100T1B0E, 09Jan2022
* WD Green SN350 240GB WDS240G20C, 02Aug2021
Не буду отнимать у читающих больше времени. Выводы предлагается делать читателю самостоятельно. Если по теоретической части есть вопросы, я буду рад стараться отвечать (на что знаю ответ). | https://habr.com/ru/post/653527/ | null | ru | null |
# EventBus — Система событий для Unity
В этой статье я расскажу вам о том, что такое система событий применительно к Unity. Изучим популярные методы и подробно разберем реализацию на интерфейсах, с которой я познакомился, работая в Owlcat Games.
#### Содержание
1. Что такое система событий?
2. Существующие реализации
2.1. Подписка по ключу
2.2. Подписка по типу события
2.3. Подписка по типу подписчика
3. Реализация на интерфейсах
3.1. Подписка на событие
3.2. Вызов события
3.3. В чем прелесть интерфейсов
4. Тонкости реализации
4.1. Отказоустойчивость
4.2. Кеширование типов подписчиков
4.3. Отписка во время события
5. Завершение
1. Что такое система событий?
=============================
Любая игра состоит из множества систем: UI, звук, графика, ввод и тд и тп. Эти системы неизбежно взаимодействуют:
1. В онлайн шутере игрок А убил игрока Б. Нужно вывести сообщение об этом в игровой лог.
2. В экономической стратегии завершилось строительство здания. Нужно проиграть звук уведомления и показать отметку на карте.
3. Игрок нажал на клавишу быстрого сохранения. Обработчик ввода должен передать сообщение об этом в систему сохранения.
Некоторые системы могут быть сильно связаны, например ввод и движение персонажа. В таких случаях можно вызывать нужный метод напрямую. Но если системы связаны слабо, гораздо лучше использовать систему событий. Давайте посмотрим, как это может работать на примере с сохранением.
```
public class InputManager : MonoBehavioiur
{
private void Update()
{
if (Input.GetKeyDown(KeyCode.S))
{
EventBus.RaiseEvent("quick-save");
}
}
}
public class SaveLoadManager : Monobehaviour
{
private void OnEnable()
{
EventBus.Subscribe("quick-save", QuickSave);
}
private void OnDisable()
{
EventBus.Unsubscribe("quick-save", QuickSave);
}
private void QuickSave()
{
// код сохранения
...
}
}
```
В методе `SaveLoadManager.OnEnable()` мы подписываем метод `QuickSave` на событие типа `"quick-save"`. Теперь, после вызова `EventBus.RaiseEvent("quick-save")` отработает метод `SaveLoadManager.QuickSave()` и игра сохранится. Важно не забывать отписываться от событий, иначе это может привести к null reference exception или утечке памяти.
Такая реализация системы служит лишь примером. Использование строк, как меток событий очень багоопасно и неудобно.
В широком смысле система событий — это общедоступный объект, чаще всего статический класс. У него есть метод подписки на определенные события и метод вызова этих событий. Все остальное — детали.
2. Существующие реализации
==========================
В большинстве случаев методы подписки и вызова будут выглядеть примерно следующим образом:
```
// Подписка
EventBus.Subscribe(тип_события, подписываемый_метод);
// Вызов
EventBus.RaiseEvent(тип_события, аргументы);
```
Рассмотрим самые популярные реализации, опираясь на эту схему.
#### 2.1. Подписка по ключу
Один из самых простых вариантов это использовать в качестве `тип_события` строку или Enum. Строка однозначно хуже — мы можем опечататься и нам не поможет ни IDE, ни компилятор. Но проблема с передачей аргументов встает в обоих случаях. Чаще всего они передаются через `params object[] args`. И тут мы опять лишены подсказок IDE и компилятора.
```
// Подписка
EventBus.Subscribe("get-damage", OnPlayerGotDamage);
// Вызов
EventBus.RaiseEvent("get-damage", player, 10);
// Подписанный метод
void OnPlayerGotDamage(params object[] args)
{
Player player = args[0] as Player;
int damage = args[1] as int;
...
}
```
#### 2.2. Подписка по типу события
Этот метод использует обобщенные методы, что позволяет нам жестко задать аргументы.
```
// Подписка
EventBus.Subscribe(OnPlayerGotDamage);
// Вызов
EventBus.RaiseEvent(new GetDamageEvent(player, 10));
// Подписанный метод
void OnPlayerGotDamage(GetDamageEvent evt)
{
Player player = evt.Player;
int damage = evt.Damage;
Debug.Log($"{Player} got damage {damage}");
}
```
#### 2.3. Подписка по типу подписчика
Этот способ как раз используется в нашем проекте. В нем мы опираемся на интерфейсы, которые реализует подписчик. Объяснение принципа его работы оставлю для следующей главы, здесь покажу лишь пример.
```
public class UILog : MonoBehaviour, IPlayerDamageHandler
{
void Start()
{
// Подписка
EventBus.Subscribe(this);
}
// Подписанный метод
public void HandlePlayerDamage(Player player, int damage)
{
Debug.Log($"{Player} got damage {damage}");
}
}
// Вызов
EventBus.RaiseEvent(h =>
h.HandlePlayerDamage(player, damage));
```
3. Реализация на интерфейсах
============================
В угоду понятности и краткости в выкладках ниже убраны некоторые детали. Без них система будет багоопасной, но для понимания основного принципа они не важны. Тем не менее мы рассмотрим их в разделе "Тонкости реализации".
#### 3.1. Подписка на событие
В нашем случае в качестве ключа выступает тип подписчика, а точнее интерфейсов, который этот тип реализует.
Рассмотрим на примере быстрого сохранения. Создадим интерфейс, который будет выступать в роли ключа для такого события:
```
public interface IQiuckSaveHandler : IGlobalSubscriber
{
void HandleQuickSave();
}
```
Для того, чтобы интерфейс мог выступать ключом, он должен наследовать IGlobalSubscriber. Этот позволит системе отличать интерфейсы-ключи от всех остальных, скоро увидим как именно. Сам интерфейс `IGlobalSubscriber` не содержит никаких свойств и методов, он лишь метка.
Теперь подписка и отписка будут выглядеть очень просто:
```
public class SaveLoadManager : Monobehaviour, IQiuckSaveHandler
{
private void OnEnable()
{
EventBus.Subscribe(this);
}
private void OnDisable()
{
EventBus.Unsubscribe(this);
}
private void HandleQuickSave()
{
// код сохранения
...
}
}
```
Посмотрим на код метода `Subscribe`.
```
public static class EventBus
{
private static Dictionary> s\_Subscribers
= new Dictionary>();
public static void Subscribe(IGlobalSubscriber subscriber)
{
List subscriberTypes = GetSubscriberTypes(subscriber.GetType());
foreach (Type t in subscriberTypes)
{
if (!s\_Subscribers.ContainsKey(t))
s\_Subscribers[t] = new List();
s\_Subscribers[t].Add(subcriber);
}
}
}
```
Все подписчики хранятся в словаре `s_Subscribers`. Ключом этого словаря является тип, а значением список подписчиков соответствующего типа.
Метод `GetSubscriberTypes` будет описан чуть ниже. Он возвращает список типов интерфейсов-ключей, которые реализует подписчик. В нашем случае это будет список из одного элемента: `IQiuckSaveHandler` — хотя в реальности `SaveLoadManager` может реализовать несколько интерфейсов.
Вот мы имеем список типов `subscriberTypes`. Теперь остается для каждого типа получить соответствующий список из словаря `s_Subscribers` и добавить туда нашего подписчика.
А вот и реализация `GetSubscribersTypes`:
```
public static List GetSubscribersTypes(IGlobalSubscriber globalSubscriber)
{
Type type = globalSubscriber.GetType();
List subscriberTypes = type
.GetInterfaces()
.Where(it =>
it.Implements() &&
it != typeof(IGlobalSubscriber))
.ToList();
return subscriberTypes;
}
```
Этот метод берет тип подписчика, берет у него список всех реализованных интерфейсов и оставляет среди них лишь те, которые в свою очередь реализуют `IGlobalSubscriber`. То есть делает ровно то, что и было заявлено.
Итак, в качества ключей в EventBus выступают интерфейсы, которые реализует подписчик.
#### 3.2. Вызов события
Напомню, что мы все еще рассматриваем пример с быстрым сохранением. InputManager отслеживает нажатие на кнопку 'S', после чего вызывает событие быстрого сохранения.
Вот как это будет выглядеть в нашей реализации:
```
public class InputManager : MonoBehavioiur
{
private void Update()
{
if (Input.GetKeyDown(KeyCode.S))
{
EventBus.RaiseEvent(
IQiuckSaveHandler handler => handler.HandleQuickSave());
}
}
}
```
Давайте посмотрим на метод `RaiseEvent`:
```
public static class EventBus
{
public static void RaiseEvent(Action action)
where TSubscriber : IGlobalSubscriber
{
List subscribers = s\_Subscribers[typeof(TSubscriber)];
foreach (IGlobalSubscriber subscriber in subscribers)
{
action.Invoke(subscriber as TSubscriber);
}
}
}
```
В нашем случае `TSubscriber` это `IQiuckSaveHandler`. `IQiuckSaveHandler handler => handler.HandleQuickSave()` это `action`, который мы применяем на всех подписчиков типа `IQiuckSaveHandler`. То есть в результате выполнения `action` вызовется метод `HandleQuickSave` и игра сохранится.
Для краткости вместо`IQiuckSaveHandler handler => handler.HandleQuickSave()` C# позволяет писать `h => h.HandleQuickSave()`.
Описание интерфейсов в итоге определяет события, которые мы можем вызывать.
#### 3.3. В чем прелесть интерфейсов
Интерфейс может реализовать более одного метода. Для нашего примера в реальности более логичным мог бы оказаться такой интерфейс:
```
public interface IQuickSaveLoadHandler : IGlobalSubscriber
{
void HandleQuickSave();
void HandleQuickLoad();
}
```
Таким образом мы подписываемся не по одному методу, а сразу группой методов, которые объединены в один интерфейс.
Также важно отметить, что передавать какие-либо параметры в такой реализации как никогда просто. Рассмотрим пример 1 из начала статьи про онлайн шутер. Работа системы событий могла бы выглядеть следующим образом.
```
public interface IUnitDeathHandler : IGlobalSubscriber
{
void HandleUnitDeath(Unit deadUnit, Unit killer);
}
public class UILog : IUnitDeathHandler
{
public void HandleUnitDeath(Unit deadUnit, Unit killer)
{
Debug.Log(killer.name + " killed " + deadUnit.name);
}
}
public class Unit
{
private int m_Health
public void GetDamage(Unit damageDealer, int damage)
{
m_Health -= damage;
if (m_Health <= 0)
{
EventBus.RaiseEvent(h =>
h.HandleUnitDeath(this, damageDealer));
}
}
}
```
Интерфейсы позволяют очень гибко определять набор возможных событий и их сигнатуру.
4. Тонкости реализации
======================
Как и обещал, рассмотрим некоторые технические детали, пропущенные в прошлом разделе.
#### 4.1. Отказоустойчивость
Код внутри любого из подписчиков может привести к ошибке. Чтобы это не оборвало цепочку вызовов, обнесем это место `try catch`:
```
public static void RaiseEvent(Action action)
where TSubscriber : IGlobalSubscriber
{
List subscribers = s\_Subscribers[typeof(TSubscriber)];
foreach (IGlobalSubscriber subscriber in subscribers)
{
try
{
action.Invoke(subscriber as TSubscriber);
}
catch (Exception e)
{
Debug.LogError(e);
}
}
}
```
#### 4.2. Кеширование типов подписчиков
Функция `GetSubscribersTypes` работает при помощи рефлексии, а рефлексия всегда работает очень медленно. Мы не можем полностью избавиться от этих вызовов, но можем закешировать уже пройденные значения.
```
private static Dictionary> s\_CashedSubscriberTypes =
new Dictionary>()
public static List GetSubscribersTypes(
IGlobalSubscriber globalSubscriber)
{
Type type = globalSubscriber.GetType();
if (s\_CashedSubscriberTypes.ContainsKey(type))
return s\_CashedSubscriberTypes[type];
List subscriberTypes = type
.GetInterfaces()
.Where(it =>
it.Implements() &&
it != typeof(IGlobalSubsriber))
.ToList();
s\_CashedSubscriberTypes[type] = subscriberTypes;
return subscriberTypes;
}
```
#### 4.3. Отписка во время события
Мы еще не описывали здесь метод отписки, но скорее всего он мог бы выглядеть как-то так:
```
public static void Unsubscribe(IGlobalSubsriber subcriber)
{
List subscriberTypes = GetSubscriberTypes(subscriber.GetType());
foreach (Type t in subscriberTypes)
{
if (s\_Subscribers.ContainsKey(t))
s\_Subscribers[t].Remove(subcriber);
}
}
```
И такой метод будет работать в большинстве случаев. Но рано или поздно при вызове очередного события мы можем получить ошибку вида
`Collection was modified; enumeration operation might not execute`.
Такая ошибка возникает, если внутри прохода по какой-то коллекции при помощи `foreach` мы удалим элемент из этой коллекции.
```
foreach (var a in collection)
{
if (a.IsBad())
{
collection.Remove(a); // получаем ошибку
}
}
```
В нашем случае проблема возникает, если во время вызова события один из подписчиков отписывается.
Для борьбы с этим мы во время отписки будем проверять, не проходимся ли мы сейчас по списку. Если нет, то просто удаляем, как и раньше. Но если проходимся, то обнулим этого подписчика в списке, а после прохода удалим из списка все `null`. Для реализации этого создадим обертку вокруг списка.
```
public class SubscribersList where TSubscriber : class
{
private bool m\_NeedsCleanUp = false;
public bool Executing;
public readonly List List = new List();
public void Add(TSubscriber subscriber)
{
List.Add(subscriber);
}
public void Remove(TSubscriber subscriber)
{
if (Executing)
{
var i = List.IndexOf(subscriber);
if (i >= 0)
{
m\_NeedsCleanUp = true;
List[i] = null;
}
}
else
{
List.Remove(subscriber);
}
}
public void Cleanup()
{
if (!m\_NeedsCleanUp)
{
return;
}
List.RemoveAll(s => s == null);
m\_NeedsCleanUp = false;
}
}
```
Теперь обновим наш словарь в `EventBus`:
```
public static class EventBus
{
private static Dictionary> s\_Subscribers
= new Dictionary>();
}
```
После этого обновим метод вызова события `RaiseEvent`:
```
public static void RaiseEvent(Action action)
where TSubscriber : IGlobalSubscriber
{
SubscribersList subscribers = s\_Subscribers[typeof(TSubscriber)];
subscribers.Executing = true;
foreach (IGlobalSubscriber subscriber in subscribers.List)
{
try
{
action.Invoke(subscriber as TSubscriber);
}
catch (Exception e)
{
Debug.LogError(e);
}
}
subscribers.Executing = false;
subscribers.Cleanup();
}
```
В теории этой ситуации может и не возникнуть, но на практике рано или поздно это происходит. Вы можете заметить, что мы беспокоимся только об удалении из коллекции, но не думаем о добавлении во время прохода. Вообще было бы правильно и этот случай обработать, но на практике у нас этой проблемы ни разу не возникало. Но если возникнет у вас, вы уже будете знать в чем дело.
5. Завершение
=============
Большинство систем событий похожи друг на друга. Они имеют в основе такую же подписку по ключу и реализованы внутри тоже при помощи словаря. Проблема удаления во время перебора для них тоже актуальна.
Наше решение отличается использованием интерфейсов. Если немного задуматься, то использование интерфейсов в системе событий является очень логичным. Ведь интерфейсы изначально придуманы для определения возможностей объекта. В нашем случае речь идет о возможностях реагировать на те или иные события в игре.
В дальнейшем систему можно развивать под конкретный проект. Например в нашей игре существуют подписки на события конкретного юнита. Еще на вызов и завершение какого-то механического события.
[Ссылка на репозиторий.](https://github.com/velik97/EventBus) | https://habr.com/ru/post/527418/ | null | ru | null |
# 3.1 Открытие и управление окнами
*От переводчика: данная статья является девятой в цикле переводов официального руководства по библиотеке SFML. Прошлую статью можно найти [тут.](https://habrahabr.ru/post/279689/ "Предыдущая статья: Работа с пользовательскими потоками данных") Данный цикл статей ставит своей целью предоставить людям, не знающим язык оригинала, возможность ознакомится с этой библиотекой. SFML — это простая и кроссплатформенная мультимедиа библиотека. SFML обеспечивает простой интерфейс для разработки игр и прочих мультимедийных приложений. Оригинальную статью можно найти [тут](http://www.sfml-dev.org/tutorials/2.3/window-window.php "Оригинальная статья: Opening and managing a SFML window"). Посвящается Еве Вайт. С днем рождения;). Начнем.*
**Оглавление:**0.1 Вступление
1. Приступая к работе
1. [SFML и Visual Studio](https://habrahabr.ru/post/278977/ "Перейти к статье: SFML и Visual Studio")
2. [SFML и Code::Blocks (MinGW)](https://habrahabr.ru/post/279069/ "Перейти к статье: SFML и Code::Blocks (MinGW)")
3. [SFML и Linux](https://habrahabr.ru/post/279107/ "Перейти к статье: SFML и Linux")
4. [SFML и Xcode (Mac OS X)](https://habrahabr.ru/post/279147/ "Перейти к статье: SFML и Xcode (Mac OS X)")
5. [Компиляция SFML с помощью CMake](https://habrahabr.ru/post/279279/ "Перейти к статье: Компиляция SFML с помощью CMake")
2. Модуль System
1. [Обработка времени](https://habrahabr.ru/post/279347/ "Перейти к статье: Обработка времени")
2. [Потоки](https://habrahabr.ru/post/279653/ "Перейти к статье: Потоки")
3. [Работа с пользовательскими потоками данных](https://habrahabr.ru/post/279689/ "Перейти к статье: Работа с пользовательскими потоками данных")
3. Модуль Window
1. [Открытие и управление окнами](https://habrahabr.ru/post/279957/ "Перейти к статье: Открытие и управление окнами")
2. [Обработка событий](https://habrahabr.ru/post/280153/ "Перейти к статье: Обработка событий")
3. Работа с клавиатурой, мышью и джойстиками
4. Использование OpenGL
4. Модуль Graphics
1. Рисование 2D объектов
2. Спрайты и текстуры
3. Текст и шрифты
4. Формы
5. Проектирование ваших собственных объектов с помощью массивов вершин
6. Позиция, вращение, масштаб: преобразование объектов
7. Добавление специальных эффектов с шейдерами
8. Контроль 2D камеры и вида
5. Модуль Audio
1. Проигрывание звуков и музыки
2. Запись аудио
3. Пользовательские потоки аудио
4. Спатиализация: звуки в 3D
6. Модуль Network
1. Коммуникация с использованием сокетов
2. Использование и расширение пакетов
3. Веб-запросы с помощью HTTP
4. Передача файлов с помощью FTP
Вступление
----------
Эта статья объясняет, как открыть и управлять окном. Рисование в окне выходит за пределы задач, решаемых модулем `sfml-window`; эту задачу решает модуль `sfml-graphics`. Однако управление окном с использование модуля `sfml-graphics` выполняется также, так что чтение данной статьи важно в любом случае.
Открытие окна
-------------
В SFML окна представлены классом [sf::Window](http://www.sfml-dev.org/documentation/2.3/classsf_1_1Window.php "Документация по sf::Window"). Окно может быть создано напрямую из конструктора данного класса:
```
#include
int main()
{
sf::Window window(sf::VideoMode(800, 600), "My window");
...
return 0;
}
```
Первый аргумент — видео режим, определяет размер создаваемого окна (размер области окна, без заголовка окна и границ). Тут мы создали окно размером 800x600 пикселей.
Класс [sf::VideoMode](http://www.sfml-dev.org/documentation/2.3/classsf_1_1VideoMode.php "Документация по sf::VideoMode") имеет интересные статические функции, с помощью которых можно получить разрешение рабочего стола или доступные видео режимы. Советуем посмотреть документацию по этому классу.
Второй аргумент — имя создаваемого окна.
Конструктор класса [sf::Window](http://www.sfml-dev.org/documentation/2.3/classsf_1_1Window.php "Документация по sf::Window") может принять и третий аргумент: стиль, который позволяет вам выбрать, какие украшения и функции вы хотите использовать.
Вы можете использовать любую комбинацию следующих стилей:
| | |
| --- | --- |
| `sf::Style::None` | Никаких украшений (используется, например, для загрузочных экранов); этот стиль не может быть использован с другими |
| `sf::Style::Titlebar` | У окна есть заголовок |
| `sf::Style::Resize` | Можно изменить размер окна и появляется кнопка открытие на весь экран |
| `sf::Style::Close` | У окна появляется кнопка закрытия |
| `sf::Style::Fullscreen` | Окно открывается в полноэкранном режиме; этот стиль не может быть скомбинирован с другими и требует доступный видео режим |
| `sf::Style::Default` | Стандартный стиль, который является сокращение `Titlebar | Resize | Close` |
Также есть четвертый аргумент, определяющий специфичные опции OpenGL. Эта тема рассматривается более подробно в статье по OpenGL.
Если вы хотите создать окно *после* создания экземпляра [sf::Window](http://www.sfml-dev.org/documentation/2.3/classsf_1_1Window.php "Документация по sf::Window") или создать окно заново, с другим видео режимом или названием, вы можете использовать функцию `create`. Она принимает те же аргументы, что и конструктор класса.
```
#include
int main()
{
sf::Window window;
window.create(sf::VideoMode(800, 600), "My window");
...
return 0;
}
```
Оживление окна
--------------
Если вы попробуете выполнить код выше (удалив "..."), вы вряд ли что-то увидите. Во-первых, потому что программа завершается немедленно. Во-вторых, потому что программа не обрабатывает события; так что, даже если вы добавили этот код в бесконечный цикл, вы увидите мертвое окно, которое не может быть перемещено или закрыто.
Давайте добавим немного кода, что бы сделать эту программу более интересной:
```
#include
int main()
{
sf::Window window(sf::VideoMode(800, 600), "My window");
// программа будет запущена до тех пор, пока окно открыто
while (window.isOpen())
{
// проверка всех событий окна, произошедших с последней итерации цикла
sf::Event event;
while (window.pollEvent(event))
{
// пользователь попытался закрыть окно: мы закрываем окно
if (event.type == sf::Event::Closed)
window.close();
}
}
return 0;
}
```
Код выше открывает окно и уничтожает его, когда пользователь закрывает его. Давайте посмотрим более детально, как он работает:
Во-первых, мы добавили цикл, который гарантирует, что приложение будет обновляться/дополняться до закрытия окна. Большинство (если не все) SFML программы будут иметь схожую конструкцию; иногда этот цикл называется *main loop* или *game loop*.
Затем, первое, что мы хотим сделать внутри нашего цикла — проверить наличие необработанных событий. Обратите внимание, что мы используем цикл `while` так, чтобы обработать все ожидающие обработки события. Функция `pollEvent` возвращает `true`, если есть события, ожидающие обработки, или `false`, если их нет.
Всякий раз, когда происходит событие, мы должны проверить его тип (закрытие окна? нажатие клавиши? перемещение мыши? подключение джойстика? ...), и, если мы заинтересованы в этом, отреагировать соответствующим образом. Здесь мы проверяем только то, произошло ли событие `Event::Closed`, которое срабатывает, если пользователь попытается закрыть окно. В этот момент окно еще открыто и мы должны закрыть его явным образом с помощью следующих функций. Это позволяет вам сделать что-то перед закрытием окна, например, сохранить текущее состояние приложения или отобразить сообщение.
Люди часто забывают о цикле обработки событий, потому что им не нужно обрабатывать события (вместо этого они используют ввод с клавиатуры). Без цикла обработки событий, окно перестанет отвечать на запросы. Важно помнить, что цикл обработки событий имеет две роли: в дополнение к обработке пользовательских событий, это еще и обработка внутренних событий окна, которые могут быть вызваны перемещением или изменением размера окна.
После того, как окно закрылось, основной цикл завершается и программа завершает свое выполнение.
В этот момент, вы, наверное, заметили, что мы не говорили о рисовании чего-то в окне. Как указывалось во введении, это не задача модуля `sfml-window`. Рисование объектов (спрайтов, текста или фигур) будет обсуждаться в статьях по `sfml-graphics`.
Чтобы что-то рисовать, вы также можете использовать OpenGL напрямую и игнорировать модуль `sfml-graphics`. [sf::Window](http://www.sfml-dev.org/documentation/2.3/classsf_1_1Window.php "Документация по sf::Window") создает OpenGL контекст и готова к принятию вызовов к OpenGL. Вы можете более подробно ознакомиться с данной темой в статье по использованию OpenGL.
Не ожидайте увидеть что-то интересное в новом окне: мы можете увидеть какой-нибудь цвет (черный или белый), или содержимое прошлого приложения, использовавшего OpenGL, или… что-то еще.
Играемся с окном
----------------
Конечно, SFML позволяет вам играться с вашими окнами. Основные операции с окнами, например изменение размера, положения, названия или иконки поддерживаются, но, в отличие от специальных библиотек GUI (Qt, wxWidgets), SFML не предоставляет расширенный функционал. Окна SFML предназначены только для обеспечения среды для OpenGL или SFML.
```
// изменение позиции окна (относительно рабочего стола)
window.setPosition(sf::Vector2i(10, 50));
// изменение размеров окна
window.setSize(sf::Vector2u(640, 480));
// изменение названия окна
window.setTitle("SFML window");
// получение размеров окна
sf::Vector2u size = window.getSize();
unsigned int width = size.x;
unsigned int height = size.y;
...
```
Вы можете обратиться к документации по API для получения полного списка функций [sf::Window](http://www.sfml-dev.org/documentation/2.3/classsf_1_1Window.php "Документация по sf::Window").
В случае, если вам действительно нужны расширенный функционал для вашего окна, вы можете создать одно окно с помощью другой библиотекой и внедрить его в SFML. Чтобы это сделать, вы можете использовать другой конструктор или создать функцию, которая передает [sf::Window](http://www.sfml-dev.org/documentation/2.3/classsf_1_1Window.php "Документация по sf::Window") дескриптор существующего окна. В этом случае, SFML будет создавать контекст рисования внутри переданного окна и отлавливать все события без вмешательства в родительский менеджер окна.
```
sf::WindowHandle handle = /* указание на то, что вы делаете и какую библиотеку вы используете */;
sf::Window window(handle);
```
Если вам нужна дополнительная, очень специфичная функция, вы можете сделать иначе: создать окно SFML, получить его дескриптор и сделать то, чего не позволяет SFML.
```
sf::Window window(sf::VideoMode(800, 600), "SFML window");
sf::WindowHandle handle = window.getSystemHandle();
// теперь вы можете использовать функции, специфичные для данной ОС
```
Интеграция SFML с другими библиотеками требует работы и не будет описана здесь, но вы можете обратиться к другим статьям, примерам или постам на форумах.
Контроль кадровой частоты
-------------------------
Иногда, когда приложение работает быстро, вы можете заметить визуальные артефакты. Причина в том, что частота обновления вашего приложения не синхронизирована с кадровой разверткой вашего монитора, и, как результат, нижняя часть предыдущего кадра смешивается с верхом следующего.
Решением этой проблемы является активизация вертикальной синхронизации. Синхронизация производится автоматически видеокартой и может быть просто включена или выключена с помощью функции `setVerticalSyncEnabled`:
```
window.setVerticalSyncEnabled(true); // вызовите эту функцию единожды, после создания окна
```
После этого вызова, приложение будет выполняться с определенной частой, равной частоте обновления монитора.
Иногда вызов `setVerticalSyncEnabled` не дает никакого эффекта: скорее всего, потому что вертикальная синхронизация выключена в настройках драйвера вашей видеокарты. Вы должны включить опцию «controlled by application» в настройках видеодрайвера.
Вы можете захотеть, чтобы ваше приложение работало на заданной кадровой частоте, вместо частоты обновления монитора. Это может быть достигнуто с помощью вызова `setFramerateLimit`:
```
window.setFramerateLimit(60); // вызовите эту функцию единожды, после создания окна
```
В отличие от `setVerticalSyncEnabled`, эта функция реализована SFML и использует комбинация [sf::Clock](http://www.sfml-dev.org/documentation/2.3/classsf_1_1Clock.php "Документация по sf::Clock") и `sf::sleep`. Важно отметить, что эта функция не является надежной на 100%, особенно для высокой кадровой частоты: возможности `sf::sleep` зависят от ОС и оборудования; минимальное время приостановки составляет 10-15 миллисекунд. Не полагайтесь на эту функцию, если вы создаете приложение, сильно зависящее от времени.
Никогда не используйте `setVerticalSyncEnabled` и `setFramerateLimit` вместе. Это может вызвать плохие последствия.
Вещи, которые нужно знать об окнах
----------------------------------
Ниже приведен список того, что вы можете и чего не можете делать с окнами SFML.
### Вы можете создавать множество окон
SFML позволяет создавать множество окон, а так же обрабатывать их события и управлять ими в главном потоке или в множестве потоков (но… смотрите ниже). В этом случае, не забудьте создать цикл обработки событий для каждого из них.
### Пока что, множество мониторов не поддерживается
SFML неявным образом управляет несколькими мониторами. По этой причине, вы не можете выбрать, на каком мониторе появится окно, и вы не можете создать более одного полноэкранного окна. Это должно быть исправлено в будущих версиях.
### События окна должны быть обработаны в потоке окна
Это является серьезным сдерживающим фактором для большинства операционных систем: цикл обработки событий (точнее, функция `pollEvent` или `waitEvent`) должен вызываться в том же потоке, в котором было создано окно. Это означает, что если вы хотите создать выделенный поток для обработки событий, вы должны убедиться, что окно создается в том же потоке. Если вы действительно хотите разделить задачи между потоками, удобнее обрабатывать события в главном потоке, и производить операции с окнами (например, отрисовку графики) в отдельном потоке. Эта конфигурация также будет совместима с других ограничений, описанными ниже.
### На Mac OS X обслуживание окон и обработка событий должны производиться в главном потоке
Ага, это правда. Mac OS X не позволит вам создать окно или обработать события в потоке, отличном от главного.
### На Windows окно, размером больше рабочего стола, не обрабатывается корректно
По какой-то причине, Windows не позволяет созвать окна, размером больше, чем рабочий стол. Это затрагивает окна, созданные с помощью `VideoMode::getDesktopMode()`: если вы будете использовать оформление окон (границы и заголовок), вы получите окно, которое будет немного больше, чем рабочий стол.
Следующая статья: [Обработка событий](https://habrahabr.ru/post/280153/ "Перейти к статье: Обработка событий"). | https://habr.com/ru/post/279957/ | null | ru | null |
# Может ли email быть «резиновым»?
[](http://habrahabr.ru/company/pechkin/blog/262585/)
Нравится это вам или нет, отрицать распространенность HTML-писем невозможно, также как и переход электронной почты в мобильную среду ([более половины](https://litmus.com/blog/53-of-emails-opened-on-mobile-outlook-opens-decrease-33) всех открытий теперь происходит на мобильных устройствах).
При этом ситуацию с версткой писем сейчас можно сравнить с тем, как обстояло дело в вебе до тех пор, пока веб-стандарты не стали хм… стандартами. Если вкратце — это просто ад для дизайнера.
При этом создание [почтовой рассылки](https://pechkin-mail.ru/?utm_source=habr&utm_medium=referral&utm_campaign=condom) вовсе не обязательно должно сопровождаться болью, кровью и слезами. Да, многие используют табличную верстку с медиазапросами и инлайн-стилями, но есть и «передовики производства», адаптирующие новейшие техники веб-дизайна к архаичной сфере дизайна почтового.
Принципы отзывчивого веб-дизайна, сформулированных в [книге Итана Маркотта](http://mann-ivanov-ferber.ru/books/book-apart/responsive-web-design/), можно применять и для работе с электронными письмами. И все это для того, чтобы подписчики могли нормально читать сообщения на разных устройствах.
#### В чем ценность HTML-писем
Вне зависимости от того, нравится это вам или нет, HTML-письма — это важный маркетинговый инструмент огромного количества бизнесов. Его эффективность зачастую значительно [превышает](http://www.wired.com/business/2013/07/email-crushing-twitter-facebook/) все другие маркетинговые каналы (вроде соцсетей). Кроме того, почтовая рассылка позволяет взаимодействовать с [огромным количеством](http://blog.getvero.com/email-marketing-statistics/) людей одновременно, при этом сохраняя интимность персонального общения.
Некоторые компании не используют email для активной коммуникации с пользователями, но так или иначе регулярно отправляют им письма. Счета, анонсы новых функций продукта, ссылка на новый технический пост в блоге — поводов отправить сообщение подписчикам можно найти много, и email подходит для этого как нельзя лучше.
Многие разработчики и дизайнеры отправляют подписчикам plain text-письма. Они могут быть [довольно эффективными](http://habrahabr.ru/company/pechkin/blog/259333/), кроме того их легче верстать, не говоря о других важных плюсах (быстро загружаются, отображаются в любом почтовом клиенте и т.п.). При этом, свои плюсы есть и у HTML-версий писем:
* **Гиперссылки** — часто бывает так, что из письма пользователя нужно направить на какую-то страницу, а без встроенной ссылки сделать это сложнее (мало кто захочет что-то копировать и вставлять в строку браузера).
* **Дизайн** — хорошо сделанные HTML-письма привлекательно выглядят и позволяют компаниям доносить свой фирменный стиль даже до папки входящих.
* **Иерархия** — С помощью HTML-верстки легче создать четкую иерархию и выделять важные места сообщения.
* **Отслеживание результатов** — HTML позволяет использовать механизмы отслеживания открытий и показателей вовлеченности — это важная информация для оптимизации маркетинговых усилий.
Если вы разработали вылизанное до мелочей приложение, но «забили» на свою почтовую рассылку, то это выливается в три негативных момента: 1) теряется возможность по работе над построением сильного бренда, 2) вы ничего не знаете о том, кто, когда и как вообще читает ваши письма, 3) никак не помогаете пользователям и не отвечаете на их вопросы за пределами приложения.
#### Почему HTML-письма — отстой
Традиционно считается, что заниматься разработкой HTML-рассылок — худшее занятие для дизайнера и разработчика. Это как сесть в машину времени и отправиться на ней прямиком в «лихие девяностые» табличных шаблонов, инлайн-стилей, несемантической разметки и хаков для каждого клиентского приложения.
Вот лишь краткий список причин, по которым HTML-письма — это больно:
* **Нет никаких стандартов**. Да, все используют HTML и CSS, но не как в вебе. Не существует никаких реальных стандартов того, как должны работать почтовые клиенты. Все это временами приводит к появлению по-настоящему безумного кода.
* **Почтовые клиенты**. Почтовые программы вроде того же Outlook или Gmail рендерят HTML по-разному, и часто довольно причудливо. Что, в свою очередь, приводит к…
* **Необходимости хаков**. Чтобы все работало в разных программах, нужно предусмотреть массу моментов, которые важны для отображения письма в каждой из них.
* **Никакого JavaScript**. Один из самых популярных веб-языков в email отсутствует как класс, потому что почтовые клиенты вырезают подобный код из соображений безопасности. Так что прощай интерактивность.
* **Инлайн-стили**. Большинство почтовых клиентов вынуждают использовать инлайн-стили и атрибуты по любому поводу.
Нет никаких оснований надеяться на существенные изменения в этом плане в ближайшем будущем. Однако среди дизайнеров и разработчиков email-кампаний есть целое движение людей, которые стремятся привнести в свою область деятельности больше порядка из веба. К ним относятся члены команды специализированных почтовых сервисов, вроде Litmus, MailChimp, Campaign Monitor, Печкин-mail.ru, и индивидуальные профессионалы вроде [Anna Yeaman](https://twitter.com/stylecampaign), [Nicole Merlin](https://twitter.com/moonstrips), [Fabio Carneiro](https://twitter.com/flcarneiro), [Elliot Ross](https://twitter.com/iamelliot), [Brian Graves](https://twitter.com/briangraves) и [dudeonthehorse](https://habrahabr.ru/users/dudeonthehorse/) здесь на Хабре.
#### Меняющийся инбокс
Как и все в вебе, электронная почта переходит в «мобайл». Сейчас уже более половины всех писем читают на экранах мобильных устройств, и эти цифры будут только расти. Хорошие новости заключаются в том, что веб-дихайнеры могут адаптировать свои уже имеющиеся навыки и применить их к созданию качественных и удобных для пользователей почтовых писем.
#### Как работает HTML-верстка
Если говорить в общем, то создание HTML-версии письма можно сравнить с версткой веб-страницы в мире, где ничего неизвестно о [веб-стандартах](http://en.wikipedia.org/wiki/Designing_with_Web_Standards) дизайна. HTMl-верстка в email стоит на трех китах: таблицах, HTML-атрибутах и инлайн-CSS. Важно понимать, что из-за особенностей рабоыт разных email-клиентов, которые по-разному поддерживают одни и те же вещи (а многое не поддерживают вообще), работать приходится с очень ограниченным набором HTML и CSS-элементов. Вот здесь представлен [отличный график](http://www.campaignmonitor.com/css/) того, что из CSS поддерживают популярные почтовые клиенты.
Прежде чем изучать вопросы резиновой верстки, взглянем на базовые вещи. Для примера разберем один из шаблонов Litmus ([код на гитхабе](https://github.com/alistapart/salted)).
##### Таблицы
Большинство веб-дизайнеров используют теги вроде div, header, section, article, nav и footer для структурирования веб-страниц. К сожалению, у email-дизайнеров нет такой роскоши, как возможность использования семантических элементов. Вместо этого вы \*обязаны\* использовать HTML-таблицы для создания шаблонов. И эти таблицы вставляют одна в другую…. много раз.
Для того, чтобы стилизовать эти таблицы, придется использовать атрибуты, которые большинство людей в глаза не видело уже довольно давно: `width`, `height`, `bgcolor`, `align`, `cellpadding`, `cellspacing` и `border`. В комбинации с инлайн стилями вроде `padding`, `width` и `max-width`, можно уже чего-то добиться.
Ниже представлен пример кода неплохо сверстанного табличного письма:
```
| | |
| --- | --- |
|
| |
| --- |
| …Content… |
|
```
Легко увидеть, как вложены таблицы и используются атрибуты `border`, `cellpadding` и `cellpsacing`. На уровне ячеек применяется `bgcolor` (это более надежный метод, чем `background` или `background-color`, хотя последний и применяется).
Интересный момент: чтобы отцентрировать вложенную таблицу и обеспечить наличие отступов вокруг контента, использован `div`. Наряду с использованием таблиц для структурирования, для выравнивания блоков контента применяют div. Тем не менее их нельзя использовать в качестве базовой структуры, поскольку во многих почтовых программах это не сработает.
##### Изображения
Использование изображений в email очень похоже на их использование в вебе за исключением одного небольшого момента: огромное число почтовых программ по-умолчанию отключают показ картинок, показывая пользователям «сломанные» письма:
Не существует способа автоматически включать отображение картинок в почтовых программах (и слава богу, в общем-то), но ситуацию можно улучшить с помощью использования alt- текста, который может передать некоторый контекст выключенных изображений. Более того, можно использовать инлайн-стили и img-элементы, чтобы стилизовать этот alt-текст и создать некоторую видимость наличия «дизайна»:
```
```
С помощью нашего кода можно привнести в отображаемое письмо чуточку больше смысла:
 | https://habr.com/ru/post/262585/ | null | ru | null |
# Пишем презентации в LaTeX
В процессе подготовки доклада на GolangConf'2019 я использовал LaTeX. Несмотря на некоторые устаревшие вещи, немного необычное поведение, скудную или сложную документацию, я внезапно получил удовольствие. Я не стал "гуру" LaTeX, но я смог делать весьма неплохие слайды. И я хочу описать основные точки создания современной презентации на LaTeХ. Особенно это должно "зайти" айтишникам, которые по роду занятий программируют. Программировать свою презентацию — это увлекательно.
#### Почему LaTeX:
* Гибкие оверлеи (когда информация на слайде появляется по очереди)
* Повторяемость и однозначность
* Пишем как программу. Некоторые ресурсы можно хранить отдельными файлами — код, список ссылок
#### Почему НЕ LaTeX:
* На выходе только PDF
* На тонкую подстройку таблиц и колонок, если они есть, может уйти больше времени, чем подвигать мышкой. Не надо делать презентацию в пять сложных слайдов в LaTeX. А в 55 — надо
Начнем с установки
------------------
Практически, сейчас существует один лидирующий дистрибутив утилит LaTeX/TeX, который поглотил все остальные — TexLive. Выпуски там нумеруются по годам. Не надо ставить археологические версии ранее 2018 года. Так что почти всем пользователям Ubuntu сразу [сюда](https://launchpad.net/~jonathonf/+archive/ubuntu/texlive). Для "маководов" есть [отдельный набор](http://www.tug.org/mactex/). Или можно использовать универсальный установщик, в том числе и [для Windows](https://www.tug.org/texlive/acquire-netinstall.html).
Пользователи CentOS должны страдать.
В любом случае можно создать свой Dockerfile и использовать его. Но учтите, что некоторые утилиты захотят видеть системные шрифты.
Дистрибутив TexLive увесистый, занимает до 5Gb. Ставить надо texlive-full или подобный пакет (название может разниться от дистрибутива к дистрибутиву).
Однако, на дворе XXI век, и вы можете воспользоваться одним из онлайн-сервисов для работы с LaTeX. Почему-то немногие даже научные работники об этом не знают. Например, [один](https://www.overleaf.com/) из самых продвинутых.
Немного о LaTeX
---------------
Это не пошаговое руководство, как начать работать в LaTeX. Мы поверхностно посмотрим, как сделать презентацию, а по пути вы сами воспользуетесь Google. Но базовые отсылки я буду делать. Также обратите внимание на [викикнигу](https://en.wikibooks.org/wiki/LaTeX).
Так будет выглядеть простейшая презентация с использованием пакета beamer — именно он отвечает за презентации:
```
\documentclass{beamer}% тип документа
% далее идёт преамбула
\title{My Super Topic}
\author{Ashot and Alice}
\begin{document}% начало презентации
\begin{frame}% первый слайд
\titlepage
\end{frame}
\begin{frame}% второй слайд
Hello, World!
\end{frame}
\end{document}
```
Поехали
-------
А вот так выглядит [готовая презентация](https://github.com/schors/gcr2019strangego), которую я сделал на **GolangConf2019**. Вокруг неё мы и будем крутиться.
Первое, что вы должны сделать, это забыть как страшный сон все отсылки к шрифтам TeX. Дональд Кнут начал разрабатывать систему шрифтов METAFONT в 1977 году, а в 1979 представил её. Это было ОЧЕНЬ круто на то время. Но на дворе 2019 год, тащить в сегодня стандарты наименований файлов 8+3 и специальные растровые шрифты можно только в минуты скуки. Все современные системы работают с современными векторными шрифтами. Утилиты TexLive имеют в своём составе новый компилятор документов — **xelatex**. Он полностью совместим с pdflatex, но работает с системными шрифтами. Всё что нужно дополнительно сделать, это подгрузить пакет fontspec или xltxtra (он подгружает fontspec) и задать шрифты:
```
% !TeX TS-program = xelatex
\documentclass[aspectratio=169]{beamer}
\usepackage{xltxtra}
\usepackage[main=russian,english]{babel}
\setmainfont{Arial}
\setromanfont{Times New Roman}
\setsansfont{Arial}
\setmonofont{Courier New}
...
```
В примере мы сразу задали размер презентации (16см на 9см), сделали комментарий чем собирать и подключили пакет babel, который мы разбирать не будем. Для пользователей Linux напомню, что в 2019 году TTF-шрифты можно кидать в директорию .fonts в домашнем каталоге.
Темы оформления
---------------
Можно делать презентацию и без специального оформления, но чувство прекрасного по умолчанию в beamer странное, поэтому практически все пользуются теми или иными темами. Обычно, темы оформления — это набор файлов .sty, размещенных там, где их может найти компилятор, т.е. там же, где и сам файл презентации. Подключается тема соответствующей строкой в преамбуле презентации:
```
\usetheme{gcr2019}% в скобках название темы
```
Есть, кстати, [чудесное руководство](https://tex.stackexchange.com/questions/146529/design-a-custom-beamer-theme-from-scratch/146682#146682) по созданию простейшей темы оформления презентации. Я сделал 3 темы на ближайшие конференции Олега Бунина, одну для себя, две — для иллюстрации к этой статье: [раз](https://github.com/schors/gcr2019theme), [два](https://github.com/schors/hl2019theme) и [три](https://github.com/schors/sc2019theme).
В принципе, всё что определено в этих темах, может быть и обычной простынёй в вашем файле презентации. В этом нет ничего плохого. Темы нужны, когда нужна повторяемость. В каждой из приведенных выше тем оформления есть пример использования и скомпилированный результат.
Оверлей
-------
Оверлей — это когда у вас информация постепенно появляется на одном и том же слайде. Вот например:
```
\begin{frame}
\begin{itemize}
\item<1-> Живи, безумец!.. Трать, пока богат!
\item<2-> Ведь ты же сам – не драгоценный клад.
\item<2-> И не мечтай – не сговорятся воры
\item<3-> Тебя из гроба вытащить назад!
\end{itemize}
\end{frame}
```
Сначала появится первая строка, затем вторая и третья, а затем четвертая. Заодно мы увидели, как сделать ненумерованный список. Систему оверлеев можно прикрутить практически к чему угодно. Я, например, делал так подсветку строк кода (рассмотрим ниже).
Обратите внимание на строки в моих шаблонах:
```
\setbeamercolor{itemize item}{fg=black}
\setbeamercolor{itemize subitem}{fg=black}
\setbeamercolor{alerted text}{fg=black}
\setbeamertemplate{itemize items}{\textbullet}% отключает кошмарные синие треугольники
\setbeamerfont*{itemize/enumerate subbody}{parent=itemize/enumerate body}
\setbeamerfont*{itemize/enumerate subsubbody}{parent=itemize/enumerate subbody}
\setbeamerfont{alerted text}{series=\bfseries}
```
Закомментируйте строки (для комментариев используйте символ "%") и посмотрите, что будет. Не тот цвет, синие треугольнички и вот это вот всё.
Не нашел куда это определить. beamer предоставляет возможность несколько раз использовать один и тот же слайд. Это вот прямо очень круто:
```
\begin{frame}[label=again]{Слайд покажем ещё раз}
...
\end{frame}
...
\againframe{again}
```
Картинки
--------
Возьмем пример из моей презентации. Две колонки, слева ненумерованный список, справа — картинка:
```
\begin{frame}{Редактор Acme}
\begin{columns}[T,onlytextwidth]
\begin{column}{0.44\textwidth}
\begin{itemize}
\item Для разработчиков
\item Автор --- \emph{Роб Пайк}
\item Написан на Alef
\item Alef = Acme
\item 30 лет с нами
\end{itemize}
\end{column}
\begin{column}{0.56\textwidth}
\includegraphics[width=\textwidth]{acme-alef.png}
\end{column}
\end{columns}
\end{frame}
```
Параметр [T,onlytextwidth] говорит о том, что вертикальное выравнивание производится по базовой линии строк вверх, а блок колонок имеют ширину равной ширине фрейма для текста. LaTeX сам сожмет картинку как надо. Можете создать свой пример и поиграться параметрами, чтобы увидеть, как и что будет перекрываться.
Листинг кода
------------
Сразу оговорюсь, что подсветка синтаксиса в листинге кода в презентации не нужна. Если она там вам нужна — вы что-то делаете не так. Больше нужны выделения. Я использую стандартный пакет listings, который умеет подсветку синтаксиса, и не умеет выделений. Вы можете посмотреть настройки оформления блока листинга в любом из моих примеров:
```
\definecolor{acmebg}{HTML}{FFFFEF}
\definecolor{acmel}{HTML}{52AAAD}
\lstset{
columns=flexible,
keepspaces=true,
showstringspaces=false,
showtabs=false,
tabsize=4,
frame=single,
basicstyle=\fontsize{10pt}{12}\bf\ttfamily\color{black},
backgroundcolor=\color{acmebg},
commentstyle=\color{black},
keywordstyle=\color{black},
stringstyle=\color{red},
rulecolor=\color{acmel},
framerule=1pt
}
```
Для выделения фона я пользуюсь пакетом lstlinebgrd, который "заброшен". Приходится вставлять [исправляющий код](https://gist.github.com/schors/44e177d8acf0f681bf3c13ca949110e3). А вот [этот](https://gist.github.com/schors/e56679852e8bb0774fa75ec9397ce18f) дополнительный код даёт мне команду \btLstHL, которая позволяет подсвечивать строки в оверлее:
```
\begin{frame}[fragile]{Limbo. Примеры синтаксиса}
\begin{lstlisting}[basicstyle=\fontsize{12pt}{12}\bf\ttfamily\color{black},linebackgroundcolor={%
\btLstHL<1>{1}%
\btLstHL<2>{2-3}%
\btLstHL<3>{5,6}%
\btLstHL<4>{8,9}%
\btLstHL<5>{11}%
}]
i, j: int;
k := 1; # int
b := byte 2; # byte
s: string; # длина в символах
s1 := s[0:]; # срез
a: array of int;
a = array[10] of int;
myfunc: fn(i, k: int, s: string) : (list of string, int);
\end{lstlisting}
\end{frame}
```
Библиография
------------
Для простоты и универсальности я использую пакет biblatex. Вот тут есть сложность. Пакет beamer перекрывает часть умолчаний biblatex. Вот эти команды убирают иконки и задают фонт библиографии:
```
\setbeamertemplate{bibliography item}{\insertbiblabel}
\renewcommand*{\bibfont}{\fontsize{8}{1}\selectfont}
```
Надо помнить важный момент — библиография задаётся в отдельном файле. В примерах в шаблонах я пишу библиографию в основном тексте с помощью пакета filecontents, который в свою очередь создаёт нужный реальный файл. И компиляция происходит в ЧЕТЫРЕ шага. Сначала просто xelatex компилирует файл и создаёт вспомогательные файлы. Затем утилита biber компилирует файл библиографии, затем надо ещё дважды прогнать xelatex. Да, с препроцессорами там всё сложно.
Пакет biblatex тоже настраивается. Но на первое время хватит того, что есть у меня в примерах.
Послесловие
-----------
Я получил удовольствие и от подготовки презентации, и от подготовки материалов к этой статье. Я надеюсь, если кто-то хотел, но не мог решиться начать использовать LaTeX в своей работе — я сломал этот барьер. Конечно, я не сделал пакетов, я не копал в глубину, я не упомянул важные темы рисования. Но я думаю, что это уже всё придёт, как только вы начнете пользоваться инструментом. Неплохие практические статьи есть и на Хабре по тегу [#latex](https://habr.com/ru/search/?q=%5Blatex%5D&target_type=posts).
Я надеюсь, что мои шаблоны кому-нибудь помогут на предстоящих конференциях. Возможно, кто-нибудь оформит те ошметки вспомогательного кода с подсветкой, которые годами валяются в интернете, в годный пакет. Дерзайте! | https://habr.com/ru/post/471352/ | null | ru | null |
# Level Up для новичков: gulp и requirejs
* [Вода](#water)
* [Gulp](#gulp)
* [Require.js](#requirejs)
Предисловие
-----------
Качество приложения зависит не только от того, какие задачи и с какой скоростью оно решает, но и от таких, казалось бы, второстепенных факторов как «красота кода».
Под красотой кода я (полагаю, и многие другие) понимаю:
* Читабельность
* Простоту изменения и дополнения
* Возможность другим разобраться, как это работает
Каждый на заре своего пути разработчика писал код, который был способен решить определённую (часто даже непростую) задачу, но при попытке что-то изменить или адаптировать под похожую задачу возникали проблемы.
Да и презентабельность такого кода вызывала сомнения.
Давайте разберёмся с двумя инструментами, которые не смотря на свою простоту повысят презентабельность исходников вашего приложения и наведут порядок в голове.
Gulp
----
Что есть gulp?
Это сборщик проектов.
Для чего он нужен?
Вопрос сложнее.
Не теряя удобства разработки на выходе вы получаете проект в том виде, в котором он должен быть:
* Оптимизированные картинки
* Минимизированные стили и скрипты
* Прочее
По сути вы получаете две копии приложения: рабочую, которая понятна вам, в которую удобно вносить правки и публичную (public), уже собранную из ваших кусочков и оптимизированную.
Говоря о собранном из кусочков проекте я имел в виду осуществление модульного подхода к программированию, который, на мой взгляд крайне полезен и является отправной точкой на пути повышения квалификации разработчика. Причины тому, очевидно: возможность легко интегрировать любой модуль в любой проект (не допиливая напильником), удобство тестирования и, главное, порядок в голове.
Gulp по сути является js скриптом (набором скриптов), который работает на сервере node.js.
Это вовсе не означает, что вам надо изучить nodejs, чтобы использовать gulp, но базовые знания его менеджера пакетов (npm) понадобятся.
Задача первая: поставить локально сервер [node.js](https://nodejs.org/).
Не буду заострять на этом внимание, слишком просто. После установки мы сможем использовать npm.
Задача вторая: установить (по сути скачать) gulp с помощью менеджера пакетов.
Для маководов это заключается в следующем: в терминале напишем
```
npm install gulp -g
```
Флаг -g означает, что мы устанавливаем его глобально, чтобы можно было запускать его в терминале командой
```
gulp
gulp task
```
Затем настроим окружение для нашего проекта, перейдя в консоли в нужную папку
```
mkdir assets public assets/js assets/img assets/css
touch gulpfile.js
npm init
npm i --save-dev gulp
```
По порядку:
* Создаем структуру папок
* Создаем файл настроек нашего сборщика
* Инициализируем npm, чтобы установить полезные в сборке модули
* Устанавливаем gulp с ключем "--save-dev", то есть в директории нашего проекта
Аналогично с последней строчкой установим все модули, нужные нам в сборке
```
npm i --save-dev gulp gulp-autoprefixer gulp-concat-css gulp-connect gulp-livereload gulp-minify-css gulp-sass gulp-rename gulp-uncss gulp-uglify gulp-imagemin imagemin-pngquant
```
**Кратко о них*** gulp-autoprefixer // Добавляет стили с префиксами для поддержки браузеров
* gulp-concat-css // Склеивает стили в один файл
* gulp-connect // Сервер
* gulp-livereload // Обновляет страницу в браузере после изменений кода
* gulp-minify-css // Минификация стилей
* gulp-sass // Без комментариев (пока не нужно)
* gulp-rename // Переименовывает файлы
* gulp-uncss // Удаляет лишние стили
* gulp-uglify // Минификация скриптов
* gulp-imagemin // Минификация изображений
* imagemin-pngquant // Минификация изображений
Примеры использования и подключения наипонятнейшим образом описаны [здесь](http://gulpjs.com/plugins/).
Теперь все, что нам нужно — это описать файл настроек, то как именно надо собирать наш проект.
Для этого в нашем файле настроек (gulpfile.js) создадим задачи (таски)
```
gulp.task('js',function(){ // Таск "js"
gulp.src('./assets/js/*.js') // С чем работаем
.pipe(uglify()) // Что именно делаем. В данном случае минифицируем
.pipe(gulp.dest('./public/js/')) // Куда складываем результат
.pipe(connect.reload()); // Обновляем страницу (не обязательно)
});
```
На самостоятельное изучение оставляю полный код моего
**gulpfile.js**var gulp = require('gulp');
var concatCss = require('gulp-concat-css');
var minifyCss = require('gulp-minify-css');
var rename = require(«gulp-rename»);
var autoprefixer = require('gulp-autoprefixer');
var livereload = require('gulp-livereload');
var connect = require('gulp-connect');
var sass = require('gulp-sass');
var uglify = require('gulp-uglify');
var imagemin = require('gulp-imagemin');
var pngquant = require('imagemin-pngquant');
// Основные
gulp.task('css', function () {
gulp.src('./assets/css/\*.css')
.pipe(concatCss(«style.min.css»))
.pipe(minifyCss({compatibility: 'ie8'}))
.pipe(autoprefixer({
browsers: ['last 10 versions'],
cascade: false
}))
.pipe(gulp.dest('./public/css/'));
gulp.src('./assets/css/fight/\*.css')
.pipe(concatCss(«fight.min.css»))
.pipe(minifyCss({compatibility: 'ie8'}))
.pipe(autoprefixer({
browsers: ['last 10 versions'],
cascade: false
}))
.pipe(gulp.dest('./public/css/'))
.pipe(connect.reload());
});
gulp.task('sass', function () {
gulp.src('./assets/sass/\*.ccss')
.pipe(sass(«style.css»))
.pipe(minifyCss(''))
.pipe(rename(«style.sass.min.css»))
.pipe(autoprefixer({
browsers: ['last 10 versions'],
cascade: false
}))
.pipe(gulp.dest('./public/css/'))
.pipe(connect.reload());
});
gulp.task('html',function(){
gulp.src('./assets/\*.html')
.pipe(gulp.dest('./public/'))
.pipe(connect.reload());
});
gulp.task('fonts',function(){
gulp.src('./assets/font/\*\*/\*')
.pipe(gulp.dest('./public/font/'))
.pipe(connect.reload());
});
gulp.task('js',function(){
gulp.src('./assets/js/\*.js')
.pipe(uglify())
.pipe(gulp.dest('./public/js/'))
.pipe(connect.reload());
});
gulp.task('jslibs',function(){
gulp.src('./assets/js/libs/\*.js')
.pipe(uglify())
.pipe(gulp.dest('./public/js/libs/'))
.pipe(connect.reload());
});
gulp.task('jsmods',function(){
gulp.src('./assets/js/modules/\*\*/\*.js')
.pipe(uglify())
.pipe(gulp.dest('./public/js/modules/'))
.pipe(connect.reload());
});
gulp.task('img',function(){
gulp.src('./assets/img/\*')
.pipe(imagemin({
progressive: true,
svgoPlugins: [{removeViewBox: false}],
use: [pngquant()]
}))
.pipe(gulp.dest('./public/img/'))
.pipe(connect.reload());
});
// Connect
gulp.task('connect', function() {
connect.server({
root: 'public',
livereload: true
});
});
// Watch
gulp.task('watch',function(){
gulp.watch("./assets/css/\*\*/\*.css", [«css»]);
gulp.watch("./assets/\*.html", [«html»]);
gulp.watch("./assets/js/\*.js", [«js»]);
gulp.watch("./assets/js/libs/\*.js", [«jslibs»]);
gulp.watch("./assets/js/modules/\*\*/\*.js", [«jsmods»]);
});
// Default
gulp.task('default', [«html», «css», «sass», «js»,«jslibs», «jsmods», «connect», «watch»]);
Заострю внимание лишь на паре вещей.
Любая из созданных задач (тасков) запускается из консоли по шаблону
```
gulp task
```
Если мы напишем просто «gulp», что запустится таск по умолчанию, то есть default.
Таск watch — встроенный таск для отслеживания изменений в файлах. Его настройка настолько очевидна (см приведенный код), что уверен, каждый справится. Этот таск позволяет не вызывать каждый раз процесс сборки проекта после любого изменения кода. Как только вы сохраните файл, gulp это увидит и пересоберет проект, а в данном случае еще и обновит страницу в браузере, и вам останется только перевести взгляд на нужный монитор, чтобы увидеть результат.
Чтобы собрать проект с вышеприведенными настройками просто введите в консоли (находясь в папке проекта)
```
gulp img
gulp
```
Работу с картинками вынес в отдельный таск для удобства (моего).
После этого не закрывайте консоль, у вас запущен watch'ер и сервер.
По сути вы можете писать в каждом отдельном файле маленькую js функцию, а сборщик соберет все это в один файл.
Тут мы вплотную подошли к вопросу модульности. Вышеприведенная ситуация очень похожа на модульный подход (издалека) — каждой функции (модулю) отдельный файл. Не запутаешься. Но что делать когда один модуль зависит от другого, от нескольких других, а те еще от других.
Да, тут уже посложнее, надо продумать правильный порядок подключения модулей. И тут нам на помощь приходит requirejs, который осуществляет AMD (Asynchronous module definition) подход (есть еще common.js, но о нем в следующей статье).
Require.js
----------
Require.js будем осваивать на живом примере. В [одной из предыдущих статей](http://habrahabr.ru/post/259907/) мы делали карточную игрушку. В результате у нас получилась просто [куча кода](https://github.com/seokirill/PlayingCardsMatreshka), которую сейчас и будем разгребать.
Для начала [скачаем reuirejs](http://requirejs.org/) и подключим в нашем index.html, это будет единственный скрипт, который мы подключим таким образом.
```
```
В параметре data-main передаем путь к точке входа нашего приложения (не указываем расширение).
Config.js в простейшем случае представляет собой список алиасов (хотя можно обойтись и без него)
**Config.js**
```
requirejs.config({
paths: {
"rClck" : "modules/disable_rclck",
"app" : "app",
"socket" : "modules/webSockets",
"Actions" : "modules/Actions",
"User" : "modules/User",
"userList" : "modules/userlist",
"Matreshka" : "libs/matreshka.min",
"Modal" : "modules/Modal",
"fight" : "modules/fight",
"jquery" : "libs/jquery",
"myCards" : "modules/myCards",
"opCards" : "modules/opCards",
"mana" : "modules/mana"
}
});
require(['app'],function(app){
app.menu();
});
```
Синтаксис requirejs прост — передаем массив зависимостей (допустимы как пути, так и алиасы, все без расширения js указывается), описываем функцию, которая срабатывает после удовлетворения зависимостей (не забываем в качестве аргументов передавать модули, от которых зависим).
```
require(['app'],function(app){
app.menu();
});
```
Подключили модуль app, после вызываем метод menu() этого модуля.
Описание модулей выглядит следующим образом: передаем массив зависимостей, пишем функцию-коллбэк, которая возвращает наш модуль.
```
define(['socket'],function(socket){ // Зависит от модуля socket
var app = {
menu: function(){
require(['Actions', 'Modal'],function(Actions, Modal){ // Выполняем функцию после удовлетворения зависимостей
if (socket.readyState === 1) {
Actions.exec('loginFailed','Введите желаемый логин (не менее 4 символов)');
}else{
Modal.box('Нет соединения с сервером');
}
});
}
}
return app; // Возвращаем объект модуля
})
```
Метод socket.readyState проверяет, есть ли соединение с сервером. Если да, то вызываем метод Actions.exec, если нет, модальное окно (Modal.box).
Actions, socket и Modal — отдельные самостоятельные модули наравне с модулем app. У них есть свои зависимости, своя логика, свои методы.
Все, что раньше у нас было в [одном файле](https://github.com/seokirill/PlayingCardsMatreshka/blob/master/js/fight.js), мы разбили на модули. Просто потому, что логически это разные куски кода, отвечающие за разные задачи, будь то соединение с сервером по WebSockets, манипулирование картами или «прочие задачи».
К прочим задачам я отношу то, что связывает все модули. Раньше у нас все это было в объекте Actions
**Actions**
```
var Actions = {
send: function(method, args){
console.log('send: ' + method);
args = args || '';
socketInfo.method = method;
socketInfo.args = args;
socket.send(JSON.stringify(socketInfo));
},
resume: function(){
User = JSON.parse(localStorage['PlayingCardsUser']);
this.send('reConnect',User.login);
},
setMotion: function(login){
console.log('setMotion: ' + login);
User.currentMotion = login;
this.motionMsg();
this.getCard();
this.setTimer();
}
...
```
Данные с сервера приходят в формате JSON в виде
`{'function': 'fooName', 'args': [массив/объект аргументов]}`
И раньше мы вызывали нужный метод так:
```
socket.onmessage = function (e){
if (typeof e.data === "string"){
var request = JSON.parse(e.data);
Actions[request.function](request.args);
};
}
```
Но по мере разрастания и усложнения нашего приложения объект Actions будет разрастаться до уровня, когда уже трудно будет держать его в памяти и ориентироваться в нем. Именно поэтому разобьем его на мелкие модули (простейшие единицы, выполняющие элементарную функцию. Эту идеологию я увидел в gulp, и она мне понравилась).
Для начала нам понадобится обертка вызова методов Actions
```
define(["socket"],function(socket){
// Config
var path = 'modules/Actions/';
var Actions = {
exec: function(){
var args = Array.prototype.slice.call(arguments);
var actionName = args.shift();
require([path + actionName],function(action){ // Подключаем модуль
action.run.apply(action,args); // Запускаем его
});
}
}
return Actions;
})
```
В метод exec модуля Actions в качестве первого аргумента принимаем название нашего действия (action), остальные аргументы передаем аргументами в этот модуль.
В простейшем случае модуль действия будет выглядеть так:
```
define(['myCards'],function(myCards){ // Зависит от модуля myCards
var action = {
run: function(card){ // Метод run() мы вызываем при подключении в Actions.js: action.run.apply(action,args);
myCards.hand.add(card); // Реализация модуля
}
}
return action; // Возвращаем объект модуля
})
```
Этот модуль является оберткой вызова метода добора карт
```
myCards.hand.add(card);
```
Это нужно для того, чтобы максимально изолировать модули друг от друга. Чтобы в любой момент можно было безболезненно переписать его, например, используя другой фреймворк.
Теоретически можно было бы сразу с сервера получать информацию о том, что надо запустить метод myCards.hand.add(), но мы же работаем с тем, что есть. Пытаемся понять, как разгрести кучу кода, которая уже есть, разложить по полочкам.
Итак, имея изначально один js файл, где описывалось все от и до, мы разделили его на модули, отвечающие за реализацию карт (на столе и в руке каждого игрока), websocket'ов и прочего. А так же давайте напишем новый модуль и внедрим его, чтобы лучше во всем разобраться. Это будет модуль, отвечающий за ману:
**mana.js**
```
define(['Matreshka'],function(Matreshka){ // Зависит от модуля Matreshka (js фреймворк)
// var diamond = $('#icons #diamond').html();
var diamond = '';
/////////// Карты в моей руке
var manaModel = Matreshka.Class({ // Модель списка
'extends': Matreshka.Object,
constructor: function(data){
this.jset(data);
this.on('render',function(){
this.bindNode('active', ':sandbox', Matreshka.binders.className( 'active' ));
});
}
});
var manaArray = Matreshka.Class({ // Класс списка
'extends': Matreshka.Array,
Model: manaModel,
itemRenderer: '-
',
constructor: function(){
this.bindNode('sandbox','#mana'); // Засовываем в песочницу
},
add: function(){
// Добавить активный кристалл
if (this.length >= 10) return;
this.push({active:true});
},
spend: function(num){
var num = num || 0;
var actives = this.filter(function(obj){
if (obj.active) return true;
return false;
});
if(actives.length < num) {
console.log('Недостаточно маны');
return false;
}
// Деактивировать num маны
for (var i = this.length - 1; i >= this.length - num; i--) {
this[i].active = false;
};
return true;
},
setAllActive: function(){
for (var i = this.length - 1; i >= 0; i--) {
this[i].active = true;
};
}
});
var mana = new manaArray; // Экземпляр класса списка
return mana;
})
```
Модуль представляет собой список (массив) кристаллов маны. Что он должен уметь?
* Добавлять кристалл на каждом ходу: add()
* Тратить полные (активные) кристаллы маны: spend()
* Пополнять (делать активными) кристаллы маны каждый ход: setAllActive()
Смысл в том, что другим модулям не нужно знать, как реализованы эти методы. Это необходимо все для той же возможности безболезненно переписать модуль. Главное, сохранить логику.
Давайте внедрим наш новый модуль в имеющуюся игрушку, пусть отныне учитывается стоимость карт.
Начнем с пополнения кристаллов маны каждый ход. Каждый ход начинается с вызова действия (модуля, вызываемого модулем Actions через наш метод exec) setMotion, который устанавливает то, какой игрок сейчас ходит.
**setMotion.js**
```
define(['Actions', 'User', 'myCards','mana'],function(Actions, User, myCards, mana){
var action = {
run: function(login){
User.currentMotion = login;
Actions.exec('motionMsg'); // Сообщение о том, чей сейчас ход
Actions.exec('setTimer'); // Установка таймера (ход длится 2 минуты)
if (User.meCurrent()) { // Если мой ход
myCards.arena.enableAll(); // Активируем мои карты на арене. Спящие просыпаются
Actions.exec('getCard'); // Добираем карту
mana.setAllActive(); // Делаем все кристаллы активными
mana.add(); // Добавляем кристалл маны
};
}
}
return action;
})
```
Как видите, внедрение первого шага оказалось несложным. Мы просто добавили вызов этого метода в нужный момент времени (в начале нашего хода). И если мы перепишем наш модуль, все будет работать как и работало. Главное не забыть реализовать ту же логику.
Как тратить ману? Очевидно, это происходит на этапе выкладывания карт из руки на стол. Внесем изменение в этот метод:
**Было**
```
this.on('click::sandbox',function(){ // Клик по карте в руке
if(!User.meCurrent() || myCards.arena.length >= 7) return; // Если хожу не я или на арене много карт - false
myCards.arena.push(this); // Добавляем карту на арену
myCards.hand.splice(myCards.hand.indexOf(this),1); // Убираем ее же из руки
Actions.exec('send', 'putCard',this.toJSON()); // Показываем это сопернику
});
```
**Стало**
```
this.on('click::sandbox',function(){ // Клик по карте в руке
if(!User.meCurrent() || myCards.arena.length >= 7) return;
if(!mana.spend(this.mana)) return; // Если не удается потратить нужное кол-во маны - false
myCards.arena.push(this);
myCards.hand.splice(myCards.hand.indexOf(this),1);
Actions.exec('send', 'putCard',this.toJSON());
});
```
Заключение
----------
Применив простые в освоении вещи, изучение которых не займет у вас более одного дня, мы совершили значительный скачек вперед на пути к качественному приложению.
Конечно, код еще далек от идеала, но гораздо читабельнее, презентабельнее и позволяет работать над ним дальше. Ведь проще заставить себя переписать маленький кусочек, чем огромный скрипт.
Мы будем продолжать улучшать эту игрушку в процессе изучения новых технологий. Чтобы набить руку, рекомендую взять какой-нибудь свой старый проект (не самый простой, чтоб было где шишек набить) и переделывать его вместе с нами.
Повторенье — мать ученья.
Ссылки
------
* [Что было](https://github.com/seokirill/PlayingCardsMatreshka)
* [Что стало](https://github.com/seokirill/ModulePlayingCards)
* (демо по техническим причинам пока недоступно) | https://habr.com/ru/post/264869/ | null | ru | null |
# Mantis + Subversion у себя на компьютере с Windows XP. Пошаговая инструкция для удобной организации работы с кодом
[](http://my.jetscreenshot.com/2/20100302-v8tx-15kb)
Исторически сложилось, что багтрекер в нашей команде – это [Mantis](http://www.mantisbt.org/). Для работы над ошибками очень хорошая и простая в обучении система. Буквально садись и работай. Но для удобной организации работы ей явно не хватает связки с Subversion. В связке Subversion+Mantis помогают организовать работу с кодом небольшой команды программистов. Более подробно про организацию работы у нас я описал в [прошлой статье](http://rrud.habrahabr.ru/blog/86065/).
А сейчас давайте поговорим, как установить Subversion у себя на компьютере и связать его с Mantis на сервере.
### 1. Качаем необходимый софт
Нам необходимо загрузить сам [сервер](http://subversion.tigris.org/servlets/ProjectDocumentList?folderID=91) и клиент для работы с ним. В качестве клиента рекомендую воспользоваться [tortoiseSVN](http://tortoisesvn.tigris.org/), в котором максимально быстро разберется новичок и. Кроме того, для этого клиента доступен русский язык.
Итак, качаем последнюю stable-версию сервера, клиент и русификацию к нему.
Это для самого Subversion. Дополнительно нам понадобится следующий софт:
* [No-IP Client](http://www.no-ip.com/downloads.php) – маленькая программка, которая позволит нам избавится от необходимости иметь выделенный IP адрес.
* [SVN + Mantis tools](http://www.icons4swrus.com/images/article-svn/svn-mantis-tools.rar), которые включают:
+ SVN+Mantis Shell – моя самописная программа, которая позволяет объединить работу Subvesion и Mantis.
+ SVNcheckin – модифицированный PHP скрипт из Mantis для тех же целей
+ post-commit – BAT файл, для орагинизации связи Mantis+Subvesion на Windows XP.
### 2. Регистрируемся на No-IP и устанавливаем No-IP Client
Если у Вас есть выделенный IP, то этого делать не надо. К Вам на компьютер можно попасть по нему, а если IP адрес хостер Вам формирует динамически, то без подобной программки не обойтись. Суть сервиса состоит в том, что Вы ставите у себя на компьютер программу, которая постоянно узнает Ваш IP адрес и в случае, если он меняется, отправляет данные на сервер. Обращение происходит через адрес, который Вы выбираете на сервере. Таким образом, к Вашему компьютеру происходит через постоянный «серверный адрес», который связан с Вашим реальным на данный момент IP адресом.
Заходим на <http://www.no-ip.com> и создаем там бесплатный аккаунт. В аккаунте нажимаем на Add Host. В качестве HostName вбиваем имя вашей компании. В выпадающем списке выбираем понравившееся имя домена. Например, no-ip.biz.
Ставим No-IP Client и вбиваем в него данные только что созданного аккаунта. Все, теперь для того, чтоб кто-то мог обратиться к Вашему компьютеру, достаточно вбить адрес вроде
`YourCompanyName.no-ip.biz`
### 3. Устанавливаем Subversion сервер и клиент
Установка проходит легко и непринужденно, везде достаточно нажимать “Next”. Сначала надо устанавливать сервер, потом клиент, затем, если надо, русификацию к клиенту. Я русификацией не пользуюсь. Мне не нравится.
Во время установки не меняйте стандартных путей, которые предлагает инсталлятор.
### 4. Создаем первый репозитарий (хранилище)
Создаем папочку C:\svn-store\
Заходим в консоль (Пуск->Выполнить, cmd) и пишем:
`svnadmin create c:/svn-store/my_project`
Обратите внимание на слеши! Они должны указываться именно так, на манер unix. В случае успешного создания репозитория никаких ошибок не появится.
Открываем файл C:/svn-store/my\_project/conf/svnserve.conf и раскомментируем строчки:
`anon-access = none`
Т.е. мы разрешаем скачивать/закачивать файлы из репозитория только зарегистрированным пользователям. Анонимные пользователи вообще не имеют доступа к репозиторию. Шароварщиками чаще всего используется именно такая политика. Данные о пользователях лежат в файле, который указывается в строчке (которую также нужно раскомментировать):
`password-db = passwd`
Т.е. так мы показываем, что в папке C:\svn-store\my\_project\conf лежит файл passwd c указанием логинов и паролей зарегистрированных пользователей.
Идем в C:\svn-store\my\_project\conf\passwd, открыв его любым текстовым редактором, и создаем учетные записи пользователей в секции users. Формат их таков:
`UserName1 = UserPassword1
UserName2 = UserPassword2`
### 5. Заполняем репозиторий исходными данными
Нам необходимо произвести импорт, начальное наполнение нашего репозитария. Для этого создаем папку C:\Repository, а в ней три пустые подпапки: trunk, branches и tags. Заходим в папку C:\Repository, щелкаем правой кнопкой мыши на свободном месте и выбираем TortoiseSVN->Import…
В качестве URL вводим:
`svn://YourCompanyName.no-ip.biz/my_project/`
Как видите, это тот УРЛ, который мы определили на втором шаге, плюс имя папки, где хранится репозиторий.
Нажимаем OK. У вас должны спросить логин и пароль. Указывайте те данные, которые внесли в C:\svn-store\my\_project\conf\passwd. Если вместо окошка для ввода логина и пароля вы не увидели, возвращайтесь к пунктам про правку C:\svn-store\my\_project\conf\svnserve.conf и C:\svn-store\my\_project\conf\passwd — вы либо не раскомментировали строчки, либо не указали логины/пароли.
В случае успешного заполнения вы увидите нечто подобное:
### 6. Настраиваем Subversion для работы с Mantis
1) Создайте временную папку C:\Temp. Выделите папку правой кнопкой мыши и в контекстном меню выберите SVN Checkout…
В качестве URL of repository введите svn:// YourCompanyName.no-ip.biz/my\_project/. Checkout directory должен быть равен C:\Temp. Других настроек не меняйте и нажмите OK. В результате в папке C:\Temp появится три папки, созданные на прошлом шаге, и служебная папка .svn. Не трогайте ее в будущем.
2) Нажимаем правой кнопкой мыши опять на C:\Temp и выбираем TortoiseSVN->Properties. В появившемся окне выставляем свойства так, как показано на рисунке. При этом **ОБЯЗАТЕЛЬНО** при добавлении каждого нового свойства выставляйте галочку «Apply property recursively»:
Теперь нажимаем правой кнопкой мыши на C:\Temp и выбираем SVN Commit…
После ввода комментария как на рисунке, нажимаем OK. TortoiseSVN ругнется, что мы не ввели номер ошибки. Игнорируем это.
3) Заливаем на сервер скрипт svncheckin.php. Он должен находится в подпапке core той папки, где установлен Mantis. В результате путь обращения к скрипту будет выглядеть как:
`URL-TO-MANTIS/core/svncheckin.php`
4) Идем в папку C:\svn-store\my\_project\hooks и копируем туда файлы
* post-commit.bat
* svn\_checkin\_shell.exe
* svn\_checkin\_shell.ini
Открываем svn\_checkin\_shell.ini и вставляем туда правильный путь к svncheckin.php. Проверяем другие пути в INI файле. Если Вы все делали, как я писал раньше, то ничего менять не надо. Если Вы меняли какие-то пути, то их также надо будет подправить в файле post-commit.bat.
5) Идем в Mаntis, логинимся в него под админом и создаем нового пользователя: “SVN Bot”. Назначаем ему права Developer-а и назначаем его НА ВСЕ активные проекты. Все автоматические комментарии теперь будут писаться от имени SVN Bot.
Также создаем в нашем проекте новый баг. Называем его, например, «Тестирование связки SVN + Mantis». Запоминаем номер бага.
### 7. Импортируем исходный код проекта в репозитарий
Процесс аналогичен шагу 5. 1) Идем в папку с проектом, щелкаем правой кнопкой мыши на свободном месте и выбираем TortoiseSVN->Import…
В качестве URL вводим:
`svn://YourCompanyName.no-ip.biz/my_project/trunk`
Обратите внимание, в конце указана папка trunk. Нажимаем ОК.
Теперь выполняется заливка данных в репозитарий. Если у Вас большой проект и много фалов, то скорее всего она займет много времени.
После того, как увидите надпись «Completed At revision…» можете вздохнуть с облегчением. Подготовительный этап работ закончился :).
Повседневная работа с tortoiseSVN
---------------------------------
Мы выполнили все необходимые действия. Теперь я вкратце расскажу, о рутине: повседневной работе.
Вся работа с кодом проходит в рабочих копиях проекта. У каждого из разработчиков своя рабочая копия. Поэтому первое, что должен сделать разработчик, для того, чтоб приступить к работе над проектом – это создать у себя локальную рабочую версию.
Затем, каждый раз перед тем, как начать работу над новой фичей или багом, программист обновляет рабочую копию (SVN Update). После того, как изменения кода закончены, разработчик делает SVN Commit. Если так делать, то над проектом спокойно могут работать несколько человек. Это очень кратко. Подробнее написано в электронной книге по tortoiseSVN. Ссылка на нее расположена в конце статьи.
Что ж, выполним одну итерацию для того, чтоб проверить, что все настроено правильно.
1. Создаем рабочую копию репозитория на локальном компьютере.
Создайте пустую папку и вызовите в ней по правой кнопке мыши “SVN Checkout…”. URL тот же:
`svn:// YourCompanyName.no-ip.biz/my_project/trunk`
Так вы загрузите в данную папку рабочую копию проекта из репозитария. Кроме файлов проекта в ней появится скрытая папка “.svn” — ее ни в коем случае не трогайте, она используется SVN во время фиксации (commit’a) изменений в репозитарий.
Сейчас все папки помечены зелеными галочками. Это значит, что ни один файл не был изменен. Когда мы внесем изменения в какой-то из файлов, он автоматически будет отмечен красным восклицательным знаком. Это очень удобно.
2. Вносим изменения в проект, чтоб убедится в правильности работы SVN
Вы можете делать хоть что (не считая папки .svn и ее содержимого, которые трогать нельзя) — создавать/править/удалять файлы проекта. Я ограничился изменением содержимого одного текстового файла.
Для записи изменений в репозитарий щелкните правой кнопкой мыши в папке и выберите “SVN Commit …”. Введите описание камита в поле Message и ОБЯЗАТЕЛЬНО номер тестовой багги, которую мы создали в Mantis.
Нажмите OK.
После того, как закончится добавление данных в репозитарий, откройте Mantis и зайдите в тестовый баг. Последним комментарием будет автоматически сгенерированный отчет о камите от SVN Bot. Будет что-то на подобии этого:
На этом все. Успехов Вам, уважемые хабрвчане. :)
P.S. Может кто знает, можно ли как-то еще в Mantis отправлять ФАКТИЧЕСКИЙ «срез» изменений в каждом камите. Что-то в духе того, как делает WebSVN, но только чтобы можно использовать, когда Subversion server у себя на ПК? | https://habr.com/ru/post/86083/ | null | ru | null |
# HTTP-заголовок Feature-Policy и контроль поведения веб-страниц в браузерах
Существует одна совершенно бесподобная методика, позволяющая держать производительность веб-проекта под контролем. Она заключается во внедрении в процесс разработки механизмов, результаты работы которых хорошо заметны. Эти механизмы нацелены на то, чтобы всегда напоминать программисту о важности производительности. В этом контексте есть кое-что, что мне очень нравится. Это — HTTP-заголовок [Feature-Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Feature-Policy).
[](https://habr.com/ru/company/ruvds/blog/490624/)
Этот заголовок — сравнительно новая возможность, которая позволяет разработчику сделать так, чтобы во время просмотра его сайта включались и отключались некоторые возможности браузера.
Например, можно сообщить браузеру о том, что он не должен позволять использовать API Geolocation, передав ему следующий заголовок:
```
Feature-Policy: geolocation 'none'
```
У использования заголовка `Feature-Policy` есть, с точки зрения безопасности и производительности, множество плюсов. Но мне сейчас особенно нравится то, как `Feature-Policy` можно использовать для того, чтобы сделать более заметными проблемы производительности сайтов, которые обычно легко проглядеть. Это можно сравнить с чем-то вроде «линтинга производительности». В частности, речь идёт о выявлении проблем с изображениями, используемыми в веб-проектах.
Политика oversized-images
-------------------------
Если браузеру передают изображение в формате, который он поддерживает, такое изображение будет выведено. Это — стандартное поведение браузера. Браузер, стремясь помочь тем, кто просматривает страницу, ещё и автоматически масштабирует подобные изображения. Поэтому они выглядят хорошо даже в том случае, если представлены огромными графическими файлами. В результате, если используются изображения, размеры которых больше размеров, нужных странице, то это, на первый взгляд, незаметно.
[Политика](https://github.com/w3c/webappsec-feature-policy/blob/master/policies/optimized-images.md#oversized-images) ([директива](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Feature-Policy)) `oversized-images` сообщает браузеру о том, что он не должен позволять использование изображений, размер которых превышает, в заданное количество раз, размер их контейнеров. Изображение, в соответствии со стандартным ограничением, не может быть более чем в 2 раза больше контейнера. Но это значение, если надо, можно переопределить.
Итак, если браузер получит следующий заголовок, он не позволит показывать изображения, взятые из любых источников (это задаётся благодаря `none`), размеры которых более чем в 2 раза превышают размеры их контейнеров (по ширине или по высоте).
```
Feature-Policy: oversized-images 'none';
```
Если нужно больше гибкости — можно сообщить браузеру о том, что он не должен выводить изображения, размеры которых более чем в 3 раза превышают размеры контейнеров:
```
Feature-Policy: oversized-images *(3) 'none';
```
В любом случае, если изображение не укладывается в заданные границы, вместо этого изображения будет выведена заглушка, а в консоль попадёт сообщение об ошибке.
*Если на сайте используется политика oversized-images, то большие изображения будут загружаться, но вместо них будет отображаться заглушка, а в консоль будет выводиться сообщение об ошибке*
Неоптимизированные изображения
------------------------------
Ещё одна распространённая проблема, связанная с графикой, заключается в использовании неоптимизированных изображений. Весьма часто можно столкнуться с изображениями, которые не были адекватным образом сжаты. Их размер, при этом, может быть подобран правильно. Так, к файлам с фотографиями, при их съёмке и создании, может быть добавлено много ненужных метаданных, которые часто остаются в файлах и при использовании их в браузерах. Один из особо раздражающих примеров подобного — это изображения, в метаданных которых содержатся их собственные миниатюры, предназначенные для предварительного просмотра. Много раз я видел, как встроенная в изображение миниатюра (о наличии которой дизайнеры и разработчики даже не знали), «весила» больше, чем само изображение!
Кроме всего прочего, тут можно вспомнить и обычное сжатие изображений, поддерживаемое многими форматами, которое позволяет достичь идеального баланса между качеством картинки и размером файла.
Политики [unoptimized-lossy-images](https://github.com/w3c/webappsec-feature-policy/blob/master/policies/optimized-images.md#unoptimized-%7Blossy,lossless%7D-images) и [unoptimized-lossless-images](https://github.com/w3c/webappsec-feature-policy/blob/master/policies/optimized-images.md#unoptimized-%7Blossy,lossless%7D-images) позволяют сообщить браузеру о том, чтобы он сопоставлял бы размер файла и размер изображения в пикселях.
```
Feature-Policy: unoptimized-lossy-images 'none';
Feature-Policy: unoptimized-lossless-images 'none';
```
Если показатель количества байт на пиксель (Byte-per-pixel, BPP) слишком высок, то браузер покажет вместо изображения заглушку и выведет в консоль сообщение об ошибке.
*Применение политик unoptimized-\* приводит к тому, что вместо неподходящих изображений выводится заглушка — так же, как и при использовании политики oversized-images*
Рекомендованный уровень BPP для изображений, сжатых с потерями, составляет 0.5, а для изображений, сжатых без потерь — 1. Кроме того, при анализе изображений допускается небольшое отклонение их общего размера от этих уровней. Сейчас это отклонение для изображений, сжатых с потерями, составляет 1 Кб, для изображений, сжатых без потерь — 10 Кб.
Например, предположим, что у нас имеется JPEG-изображение размером 200x200 пикселей. JPEG — это формат сжатия изображений с потерями, в результате рекомендованный для него уровень BPP составляет 0.5. При этом общий размер изображения может превышать рекомендованный размер всего на 1 Кб. Для выяснения того, какой размер должно иметь подобное изображение, устраивающее браузер, нужно умножить размеры сторон изображения в пикселях друг на друга и на BPP, после чего — прибавить к тому, что получится, разрешённое отклонение.
`(200 x 200 x .5) + 1024 = 21,024` байт, или `20.5` Кб
Если изображение сжато без потерь, то допускается отклонение от «идеального» размера, равное 10 Кб, при этом показатель BPP такого изображения будет равняться 1. В остальном вычисления выглядят точно так же:
`(200 x 200 x 1) + 10,240 = 50,240` байт, или `49.1` Кб
Размер разрешённого отклонения, вероятно, в будущем изменится. На самом деле, хотя Blink, по умолчанию, использует этот показатель для изображений, сжатых без потерь, равняющийся 10 Кб, уже ведутся эксперименты с политикой `unoptimized-lossless-images-strict`, которая меняет этот показатель, понижая его до уровня 1 Кб.
Медиа-материалы, размеры которых не указаны
-------------------------------------------
Новое — это хорошо забытое старое.
Долгое время использование атрибутов изображений `height` и `width` было более или менее распространено. Без этих атрибутов браузер не знал о том, какое пространство должно занимать изображение, до того момента, когда изображение будет загружено. Это вело к сдвигам в макетах страниц. Страница выводилась, а потом, после прибытия изображения, её содержимое сдвигалось. Браузеру приходилось лишний раз пересчитывать макет для того чтобы выделить место для изображения.
Когда пришла пора макетов, в которых размеры изображений должны были гибко меняться с помощью CSS, наличие или отсутствие этих атрибутов уже не играло особенной роли. В результате многие просто перестали использовать эти атрибуты.
Но благодаря [недавней работе](https://www.youtube.com/watch?v=4-d_SoCHeWE), инициированной Джен Симмонс, Firefox и Chrome могут вычислять соотношение сторон изображений, основываясь на их атрибутах `height` и `width`. Когда данный подход объединяется с применяемым к изображениям стилям, оказывается, что браузеры могут резервировать место для изображений в ходе начального прохода формирования макета.
Политика [unsized-media](https://github.com/w3c/webappsec-feature-policy/blob/master/policies/unsized-media.md) указывает браузеру на то, что все медиа-элементы должны иметь атрибуты, задающие размеры этих элементов. Если таких атрибутов нет — браузер должен использовать значения, принятые по умолчанию. Всё, на самом деле, немного сложнее, но суть тут в том, что если у изображения не заданы соответствующие атрибуты, браузер использует стандартное значение `300x150` пикселей.
```
Feature-Policy: unsized-media 'none';
```
Когда применяется эта политика, изображения будут выводиться, но если их размер в HTML не задан, разработчик быстро заметит, что изображения выводятся в размере, заданном по умолчанию. И, как обычно, в консоль попадёт сообщение об ошибке.
*Применение политики unsized-media приводит к тому, что изображения и видео без атрибутов height и width выводятся, но браузер устанавливает их размеры как 300x150 пикселей*
Вероятно, тут стоит сказать об одной особенности, которая поначалу показалась мне необычной. Она показывает себя при совместном использовании политик `unsized-media` и `oversized-images`. В такой ситуации не стоит удивляться появлению большего, чем раньше, количества сообщений о слишком больших изображениях. Дело в том, что из-за применения политики `unsized-media` браузер изменяет размер изображений, которые не имеют атрибутов `height` и `width`, до `300x150` пикселей. После чего именно этот размер используется браузером в качестве точки отсчёта для определения соответствия изображения его контейнеру.
Привлечение внимания к менее заметным проблемам
-----------------------------------------------
В политиках, связанных с изображениями, мне нравится то, что они, в процессе разработки проектов, позволяют сделать заметным то, что обычно скрыто. В результате разработчик узнаёт о том, что он не позаботился об оптимизации изображений, или о том, что забыл задать их атрибуты `height` и `width`. Все эти ошибки тут же отражаются на внешнем виде страниц. На самом деле, главный плюс использования вышеописанных политик заключается в том, что они позволяют разработчику быстро узнавать о проблемах с изображениями. В то время как политика `unsized-media` способна привести к уменьшению количества ситуаций, в которых происходят «сдвиги» макетов страниц, применение других политик не препятствует загрузке неподходящих изображений. В результате единственная сильная сторона применения этих политик заключается в том, что они привлекают внимание разработчиков к проблемам.
Есть ещё несколько политик, которые могут оказаться полезными с точки зрения анализа страниц на предмет влияния чего-либо на их производительность. Тут на ум приходят политики вроде [sync-script](https://featurepolicy.info/policies/sync-script) (эта политика блокирует выполнение синхронных скриптов), `sync-xhr` (блокирует синхронные AJAX-запросы) и `document-write` (блокирует вызовы `document.write`).
Эти политики — отличные инструменты, позволяющие контролировать определённые аспекты производительности страниц, но сами по себе они не дают разработчикам столь же заметной обратной связи, которую, в форме отсутствующих изображений, дают многие вышеописанные политики. Конечно, если на странице имеется синхронный скрипт, без которого она не выводится, то подобное нелегко не заметить (и подобные страницы не так уж и сложно найти). Но эти политики обычно указывают на ошибки в виде сообщений, выводимых в консоль. А я, если честно, подозреваю, что большинство разработчиков не уделяет консоли особенно много внимания (полагаю, нам всем стоит внимательнее относиться к консоли).
Но мы, тем не менее, можем сделать ошибки, выявляемые с помощью «невидимых» политик, гораздо более заметными, воспользовавшись API [ReportingObserver](https://developer.mozilla.org/en-US/docs/Web/API/ReportingObserver/ReportingObserver) для организации наблюдения за нарушениями и для вывода соответствующих уведомлений на странице. Такие уведомления можно сделать весьма заметными.
```
let reportingAlerts = document.createElement('ul');
reportingAlerts.setAttribute('id','reportingAlerts');
document.body.appendChild(reportingAlerts);
const alertBox = document.getElementById('reportingAlerts');
new ReportingObserver((reports, observer) => {
let fragment = document.createDocumentFragment();
Object.keys(reports).forEach(function(item) {
let li = document.createElement('li');
li.textContent = reports[item].body.message + ': ' + reports[item].body.featureId;
fragment.appendChild(li);
});
alertBox.appendChild(fragment)
}, {types: ['feature-policy-violation'], buffered: true}).observe();
```
Я набросал в CodePen [пример](https://codepen.io/tkadlec/pen/KKpgeRX) того, как это может выглядеть.
*Пример того, как можно выводить уведомления о нарушениях политик, задаваемых заголовком Feature-Policy. Подобные уведомления рассчитаны на вывод в окружении разработки, или там, где проект готовят к выводу в продакшн.*
Минус использования заголовка Feature-Policy
--------------------------------------------
Большой минус использования заголовка `Feature-Policy` заключается в его поддержке браузерами. По всей видимости, сейчас его поддерживают лишь браузеры, основанные на Blink (Opera, Edge, Chrome, Samsung). Браузеры Firefox и Safari поддерживают атрибут `allow`, предназначенный для элементов `iframe`. Но даже там, где `Feature-Policy` поддерживается, для обеспечения работоспособности многих из политик нужно включать флаг `Experimental Web Platform features` (найти его можно по адресу `about:flags`).
Как я пользуюсь заголовком Feature-Policy
-----------------------------------------
Тот минус заголовка `Feature-Policy`, о котором сказано выше, лично для меня особой проблемы не представляет. Я предпочитаю использовать политики, задаваемые этим заголовком, как браузерное средство проверки страниц. Поэтому мне не нужно стремиться к применению `Feature-Policy` в продакшне, или к тому, чтобы политики работали бы у всех моих пользователей. Они нужны только мне, а так же тем, кто занимается разработкой сайта. Я, в любом случае, в качестве основного браузера, использую в процессе разработки Chrome. Поэтому обеспечение работоспособности `Feature-Police` в моём рабочем окружении заключается во включении соответствующего флага. После этого политики работают без дополнительного вмешательства с моей стороны.
Я выяснил, что проще всего пользоваться заголовком `Feature-Policy` с помощью браузерного расширения [ModHeader](https://chrome.google.com/webstore/detail/modheader/idgpnmonknjnojddfkpgkljpfnnfcklj). Это расширение позволяет задавать собственные заголовки, передаваемые страницам при их просмотре.
*Расширение ModHeader позволяет настраивать варианты заголовка Feature-Policy. Их можно, по желанию, включать и отключать*
У меня есть три набора значений заголовка `Feature-Policy`, которыми я периодически пользуюсь:
* `oversized-images 'none'; unoptimized-lossy-images 'none'; unoptimized-lossless-images 'none';`
* `unsized-media 'none'; oversized-images 'none'; unoptimized-lossy-images 'none'; unoptimized-lossless-images 'none';`
* `script-sync 'none'; unsized-media 'none'; oversized-images 'none'; unoptimized-lossy-images 'none'; unoptimized-lossless-images 'none';`
Я часто держу включенным первый из них. Очень увлекательно путешествовать по веб-страницам, к которым применяются использованные в нём политики. Страшно смотреть на то, как велики некоторые изображения. В современном вебе очень много такого, что можно было бы улучшить.
Так, на страницах очень и очень часто срабатывает политика `unsized-media` (и я этим тоже грешу), поэтому её использование при обычной работе в интернете доставляет неудобства. Именно поэтому она у меня выделена в отдельную политику, которую я могу включать и выключать. То же самое касается и политики `sync-scripts`, применение которой «ломает» множество сайтов.
Некоторые команды, с которыми я работал, начали использовать описанные мной политики в ходе разработки. Это позволяет им быстро обращать внимание на ранее незаметные проблемы. Конечно, я рекомендую включать все политики `Feature-Policy` в среде разработки, что позволяет быстро выявлять и исправлять ошибки.
Итоги
-----
Надеюсь, что поддержка `Feature-Policy` появится, в итоге, не только в Chrome. Хотя это — мой основной браузер, мне приходится пользоваться и другими браузерами. Было бы полезно, если бы и они поддерживали `Feature-Policy`. Но тут, правда, мы видим ту редко встречающуюся ситуацию, когда даже экспериментальной поддержки некоей возможности достаточно для того, чтобы она могла бы принести реальную пользу.
Незаметные проблемы с производительностью — это тоже проблемы. И возможность сделать такие проблемы заметнее — это один из лучших методов, которым может воспользоваться разработчик для того, чтобы их выявлять и исправлять.
**Уважаемые читатели!** Планируете ли вы пользоваться заголовком Feature-Policy для выявления незаметных проблем веб-проектов?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/490624/ | null | ru | null |
# Микросервисный фронтенд — современный подход к разделению фронта
**[Микросервисная архитектура](https://ru.wikipedia.org/wiki/%D0%9C%D0%B8%D0%BA%D1%80%D0%BE%D1%81%D0%B5%D1%80%D0%B2%D0%B8%D1%81%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D1%85%D0%B8%D1%82%D0%B5%D0%BA%D1%82%D1%83%D1%80%D0%B0)** уже давно де-факто стала стандартом при разработке больших и сложных систем. Она имеет целый ряд преимуществ: это и строгое деление на модули, и слабая связность, и устойчивость к сбоям, и постепенность выхода в продакшн, и независимое версионирование компонентов.
Правда, зачастую, говоря о микросервисной архитектуре, упоминают только бэкенд-архитектуру, а фронтенд как был, так и остается монолитным. Получается, что мы сделали великолепный бэк, а фронт тянет нас назад.
Сегодня я расскажу вам, как мы делали микросервисный фронт в нашем SaaS-решении и с какими проблемами столкнулись.
Проблематика
------------
Изначально разработка в нашей компании выглядела так: есть много команд, занимающихся разработкой микросервисов, каждый из которых публикует свой API. И есть отдельная команда, которая занимается разработкой SPA для конечного пользователя, используя API разных микросервисов. При таком подходе все работает: разработчики микросервисов знают все об их реализации, а разработчики SPA знают все тонкости пользовательских взаимодействий. Но появилась проблема: теперь каждый фронтендер должен знать все тонкости всех микросервисов. Микросервисов становится все больше, фронтендеров становится все больше — и Agile начинает разваливаться, так как появляется специализация внутри команды, то есть исчезают взаимозаменяемость и универсальность.
Так мы пришли к следующему этапу — модульной разработке. Команда фронтенда поделилась на подкоманды. Каждая отвечала за свою часть приложения. Стало намного лучше, но со временем и этот подход исчерпал себя в силу ряда причин.
* Все модули разнородные, со своей спецификой. Для каждого модуля лучше подходят свои технологии. При этом выбор технологий — трудновыполнимая задача в условиях SPA.
* Так как приложение SPA (а в современном мире это означает компиляцию в единый бандл или как минимум сборку), то одновременно могут делаться только выдачи всего приложения. Риск каждой выдачи растет.
* Все сложнее заниматься управлением зависимостями. Разным модулям нужны разные (возможно, специфичные) версии зависимостей. Кто-то не готов перейти на обновленный API зависимости, а кто-то не может сделать фичу из-за баги в старой ветке зависимости.
* Из-за второго пункта релизный цикл у всех модулей должен быть синхронизирован. Все ждут отстающих.
Режем фронтенд
--------------
Наступил момент накопления критической массы, и фронтенд решили разделить на… фронтендные микросервисы. Давайте определим, что такое фронтендный микросервис:
* полностью изолированная часть UI, никоим образом не зависящая от других; радикальная изолированность; буквально разрабатывается как отдельное приложение;
* каждый фронтендный микросервис отвечает за некий набор бизнес-функций от начала до конца, то есть является полнофункциональным сам по себе;
* может быть написан на любых технологиях.
Но мы пошли дальше и ввели еще один уровень деления.
### Понятие фрагмента
Фрагментом мы называем некий бандл, состоящий из `js + css + дескриптора развертывания`. По сути, это независимая часть UI, которая должна выполнять набор правил разработки, для того чтобы его можно было использовать в общем SPA. Например, все стили должны быть максимально специфичны для фрагмента. Никаких попыток прямого взаимодействия с другими фрагментами быть не должно. Необходимо иметь специальный метод, которому можно передать DOM-элемент, где фрагмент должен отрисоваться.
Благодаря дескриптору мы можем сохранить информацию обо всех зарегистрированных фрагментах окружения, а затем иметь к ним доступ по ID.
Подобный подход позволяет разместить два приложения, написанных на разных фреймворках, на одной странице. Также это дает возможность написать универсальный код, который позволит динамически подгружать нужные фрагменты на страницу, инициализировать их и управлять жизненным циклом. Для большинства современных фреймворков достаточно соблюдать «правила гигиены», чтобы это стало возможным.
В тех случаях, когда фрагмент не имеет возможности «сожительствовать» с другими на одной странице, есть fallback-сценарий, при котором мы отрисовываем фрагмент в iframe (решение сопутствующих проблем остается за рамками данной статьи).
Все, что нужно сделать разработчику, желающему использовать существующий фрагмент на странице, — это:
1. Подключить скрипт микросервисной платформы на страницу.
2. Вызвать метод добавления фрагмента на страницу.
```
window.MUI.createFragment(
// fragment name
"hello-label",
// fragment model
{
text: "HelloLabelFragment text from run time"
},
// fragment position
{
selector: ".hello-label-placeholder",
position: "afterend"
})
.then(callback);
```
Также для общения фрагментов между собой есть шина, построенная на `Observable` и `rxjs`. Написана она на NativeJS. Кроме того, в SDK поставляются обертки для разных фреймворков, которые помогают использовать эту шину нативно. Пример для Angular 6 — утилитный метод, возвращающий `rxjs/Observable`:
```
import {fromEvent} from "@netcracker/mui-platform/angular2-factory/modules/shared/utils/event-utils"
fromEvent("");
fromEvent(EventClassType);
```
Кроме того, платформа предоставляет набор сервисов, которые часто используются разными фрагментами и являются базовыми в нашей инфраструктуре. Это такие сервисы, как локализация/интернационализация, авторизационный сервис, работа с кросс-доменными куками, local storage и многое другое. Для их использования в SDK также поставляются обертки для разных фреймворков.
Объединяем фронтенд
-------------------
Для примера можем рассмотреть такой подход в SPA админки (она объединяет разные возможные настройки с разных микросервисов). Содержимое каждой закладки мы можем сделать отдельным фрагментом, поставлять и разрабатывать который будет каждый микросервис по отдельности. Благодаря этому мы можем сделать простую «шапку», которая будет показывать соответствующий микросервис при клике на закладку.
Развиваем идею фрагмента
------------------------
Разработка одной закладки одним фрагментом далеко не всегда позволяет решить все возможные задачи. Часто бывает необходимо в одном микросервисе разработать некую часть UI, которая потом будет переиспользоваться в другом микросервисе.
И тут нам тоже помогают фрагменты! Так как все, что нужно фрагменту, — это DOM-элемент для отрисовки, мы выдаем любому микросервису глобальный API, через который он может разместить любой фрагмент внутри своего DOM-дерева. Для этого достаточно передать ID фрагмента и контейнер, в котором ему надо отрисоваться. Остальное сделается само!
Теперь мы можем строить «матрешку» любого уровня вложенности и переиспользовать целые куски UI без необходимости поддержки в нескольких местах.
Часто бывает так, что на одной странице находятся несколько фрагментов, которые должны менять свое состояние при изменении неких общих данных на странице. Для этого у них есть глобальная (NativeJS) шина событий, через которую они могут общаться и реагировать на изменения.
### Общие сервисы
В микросервисной архитектуре неизбежно появляются центральные сервисы, данные из которых нужны всем остальным. Например, сервис локализации, который хранит переводы. Если каждый микросервис в отдельности начнет лазить за этими данными на сервер, мы получим просто вал запросов при инициализации.
Для решения этой проблемы мы разработали реализации NativeJS сервисов, которые предоставляют доступ к таким данным. Это дало возможность не делать лишних запросов и кешировать данные. В некоторых случаях — даже заранее выводить такие данные на страницу в HTML, чтобы совсем избавиться от запросов.
Кроме того, были разработаны обертки над нашими сервисами для разных фреймворков с целью сделать их использование очень естественным (DI, фиксированный интерфейс).
Плюсы фронтендных микросервисов
-------------------------------
Самое важное, что мы получаем от разделения монолита на фрагменты, — возможность выбора технологий каждой командой в отдельности и прозрачное управление зависимостями. Но кроме того, это дает следующее:
* очень четко разделенные зоны ответственности;
* независимые выдачи: каждый фрагмент может иметь свой релизный цикл;
* повышение стабильности решения в целом, так как выдача отдельных фрагментов не влияет на другие;
* возможность легко откатывать фичи, выкатывать их на аудиторию частично;
* фрагмент легко помещается в голове каждого разработчика, что приводит к реальной
взаимозаменяемости членов команды; кроме того, каждый фронтендер может глубже понять все тонкости взаимодействия с соответствующим бэкендом.
Решение с микросерисным фронтендом выглядит неплохо. Ведь теперь каждый фрагмент (микросервис) может сам решать, как деплоиться: нужен ли просто nginx для раздачи статики, полноценный middleware для агрегации запросов к бэкам или поддержки websockets либо еще какая-нибудь специфика в виде бинарного протокола передачи данных внутри http. Кроме того, фрагменты могут сами выбирать способы сборки, методы оптимизации и прочее.
Минусы фронтендных микросервисов
--------------------------------
Никогда нельзя обойтись без ложки дегтя.
* Взаимодействие между фрагментами невозможно обеспечить стандартными ламповыми методами (DI, например).
* Как быть с общими зависимостями? Ведь размер приложения будет расти как на дрожжах, если их не выносить из фрагментов.
* За роутинг в конечном приложении все равно должен отвечать кто-то один.
* Что делать, если один из фрагментов недоступен / не может отрисоваться.
* Неясно, что делать с тем, что разные микросервисы могут находиться на разных доменах.
Заключение
----------
Наш опыт использования такого подхода доказал его жизнеспособность. Скорость вывода фич в продакшн увеличилась в разы. Количество неявных зависимостей между частями интерфейса свелось практически к нулю. Мы получили консистентный UI. Можно безболезненно проводить тесты фич, не привлекая к этому большое количество людей.
К сожалению, в одной статье очень сложно осветить весь спектр проблем и решений, которые можно встретить на пути повторения такой архитектуры. Но для нас плюсы явно перевешивают минусы. Если Хабр проявит интерес к раскрытию подробностей реализации этого подхода, мы обязательно напишем продолжение! | https://habr.com/ru/post/420753/ | null | ru | null |
# К чему приводят тестовые задания или как я реализовал Match-3 для терминала
Вы когда-нибудь играли в Match-3 в текстовом терминале? Вот и я бы не подумал, что поводом для этого, может стать очередное тестовое задание.
В разработке я уже около 10 лет и в последнее время начал задумываться, а не уйти ли мне в геймдев? Учитывая, что большую часть времени я посвятил разработке приложений на Unity, а 3D моделированием увлекаюсь ещё со школы.
И вот, после очередной порции откликов на интересующие вакансии. Я получаю ответ от компании X:
> Благодарим Вас за отклик на вакансию "Senior Unity C# Developer". Готовы ли Вы выполнить тестовое задание?
>
>
Как правило я игнорирую вакансии с обязательным выполнением тестового, но это только в том случае, если задача меня абсолютно не заинтересовала, и я не смогу найти проделанной работе полезного применения. Поэтому если и берусь, то делаю его так, как нравится мне самому. Может поэтому я и не дошёл до этапа собеседования?
ЗаданиеНаписать логику осыпания игрового поля Match 3
**Базовый функционал:**
* реализовать построение игрового поля из любого конфига (json, SO и т.д.);
* поле должно быть размером X на Y клеток и может иметь пустоты;
* клетки в первой строке сверху, при нажатии на пробел, должны генерировать фишки которые падая вниз заполнят всё поле.
**Продвинутый функционал:**
* фишки осыпаются с нарастающей задержкой относительно друг друга;
* если в каком-то столбце нет генератора (пустота сверху), фишки опавшие вертикально в соседних столбцах, начинают сверху осыпаться диагонально в образовавшиеся незаполненные клетки.
**Космос:**
* после осыпания всего поля можно нажать на любую фишку и эта фишка вместе со всеми соседями такого-же цвета уничтожатся, а образовавшаяся пустота так-же заполнится согласно правилам осыпания написанным выше.
В общем, задача показалась интересной. Было решено реализовать **космос**, добавив **продвинутого функционала**, и разбавив это всё **базовым**. Я бы и не подумал, что только алгоритмов заполнения игрового поля мне в голову придет 6 штук. Собственно, это и сподвигло меня реализовать гибкую систему с добавлением неограниченного числа алгоритмов заполнения поля, и возможностью менять их прямо во время игрового процесса.
Стоит добавить, что на всё про всё даётся 7 дней и тестовое не оплачивается.
> Выполнение тестового задания не оплачивается, мы не используем результаты тестовых заданий в коммерческих целях, поэтому автор может распоряжаться работой по своему усмотрению.
>
>
Спустя три вечера, на руках у меня был полноценный прототип Match-3 игры.
Получилось вполне сносно. Но давайте разберём более интересную часть, код и как это всё устроено.
Обратите внимание, что ниже рассматривается код из первой реализации, который можно найти в ветке [simple\_implementation](https://github.com/ChebanovDD/Match3-SDK/tree/simple_implementation). Финальный код можно найти в `main` ветке на [GitHub](https://github.com/ChebanovDD/Match3-SDK).
Основная магия происходит в классах реализующих интерфейс `IBoardFillStrategy`.
```
public interface IBoardFillStrategy
{
string Name { get; }
IEnumerable GetFillJobs(IGameBoard gameBoard);
IEnumerable GetSolveJobs(IGameBoard gameBoard, IEnumerable sequences);
}
```
`IJob` это любая работа которую необходимо выполнить после заполнения или изменения состояния игрового поля.
```
public interface IJob
{
int ExecutionOrder { get; }
UniTask ExecuteAsync(CancellationToken cancellationToken = default);
}
```
Свойство `ExecutionOrder` отвечает за порядок выполнения. Работы с одинаковым `ExecutionOrder` будут выполняться параллельно. В качестве работы может быть, например анимация элементов.
Вот так можно плавно показать элемент с анимацией масштабирования:
```
public class ItemsShowJob : Job
{
private const float ScaleDuration = 0.5f;
private readonly IEnumerable \_items;
public ItemsShowJob(IEnumerable items, int executionOrder = 0) : base(executionOrder)
{
\_items = items;
}
public override async UniTask ExecuteAsync(CancellationToken cancellationToken = default)
{
var itemsSequence = DOTween.Sequence();
foreach (var item in \_items)
{
item.SetScale(0);
item.Show();
\_ = itemsSequence.Join(item.Transform.DOScale(Vector3.one, ScaleDuration));
}
await itemsSequence.SetEase(Ease.OutBounce).WithCancellation(cancellationToken);
}
}
```
Использовать получившуюся анимацию можно при заполнении игрового поля:
```
public IEnumerable GetFillJobs(IGameBoard gameBoard)
{
var itemsToShow = new List();
for (var rowIndex = 0; rowIndex < gameBoard.RowCount; rowIndex++)
{
for (var columnIndex = 0; columnIndex < gameBoard.ColumnCount; columnIndex++)
{
var gridSlot = gameBoard[rowIndex, columnIndex];
if (gridSlot.State != GridSlotState.Empty)
{
continue;
}
var item = \_itemsPool.GetItem();
item.SetWorldPosition(\_gameBoardRenderer.GetWorldPosition(rowIndex, columnIndex));
gridSlot.SetItem(item);
itemsToShow.Add(item);
}
}
return new[] { new ItemsShowJob(itemsToShow) };
}
```
Обратите внимание, что для каждой строки, можно создать собственную работу, например для показа элементов построчно друг за другом.
Алгоритм для обработки последовательностей совпавших элементов будет ненамного сложнее:
```
public IEnumerable GetSolveJobs(IGameBoard gameBoard, IEnumerable sequences)
{
var itemsToHide = new List();
var itemsToShow = new List();
foreach (var solvedGridSlot in sequences.GetUniqueGridSlots())
{
var newItem = \_itemsPool.GetItem();
var currentItem = solvedGridSlot.Item;
newItem.SetWorldPosition(currentItem.GetWorldPosition());
solvedGridSlot.SetItem(newItem);
itemsToHide.Add(currentItem);
itemsToShow.Add(newItem);
\_itemsPool.ReturnItem(currentItem);
}
return new IJob[] { new ItemsHideJob(itemsToHide), new ItemsShowJob(itemsToShow) };
}
```
За формирование последовательностей элементов, которые передаются в стратегию, отвечает метод `Solve` интерфейса `IGameBoardSolver`.
```
public interface IGameBoardSolver
{
IReadOnlyCollection Solve(IGameBoard gameBoard, params GridPosition[] gridPositions);
}
```
Такой подход предоставляет возможность реализации абсолютно любой логики формирования последовательностей элементов, а также стратегии заполнения игрового поля, используя для этого различную анимацию. Плюс стратегии можно менять прямо во время игрового процесса.
Ожидая ответа по проделанной работе, я подумал, а что, если я захочу реализовать поддержку специальных блоков (лёд, камень и т.д.)? Как выяснилось, реализовать можно, но с некими ограничениями. Например, невозможность "красиво" получить специальные блоки в стратегиях заполнения, так как изначально в стратегию передавалась только последовательность совпавших элементов.
Было решено исправить это недоразумение и максимально упростить процесс добавления специальных блоков. После внесенных изменений, для добавления специального блока, достаточно просто реализовать интерфейс `ISpecialItemDetector` и передать его в `GameBoardSolver`.
Вот так, например можно реализовать поддержку блока камень:
```
public class StoneItemDetector : ISpecialItemDetector
{
private readonly GridPosition[] \_lookupDirections;
public StoneItemDetector()
{
\_lookupDirections = new[]
{
GridPosition.Up,
GridPosition.Down,
GridPosition.Left,
GridPosition.Right
};
}
public IEnumerable GetSpecialItemGridSlots(IGameBoard gameBoard,
IUnityGridSlot gridSlot)
{
foreach (var lookupDirection in \_lookupDirections)
{
var lookupPosition = gridSlot.GridPosition + lookupDirection;
if (gameBoard.IsPositionOnGrid(lookupPosition) == false)
{
continue;
}
var lookupGridSlot = gameBoard[lookupPosition];
if (lookupGridSlot.State.GroupId == (int) TileGroup.Stone)
{
yield return lookupGridSlot;
}
}
}
}
```
Для отслеживания состояний ячейки используется интерфейс `IStatefulSlot`.
```
public interface IStatefulSlot
{
bool NextState();
void ResetState();
}
```
Теперь, специальные блоки автоматически передаются в метод обработки совпавших последовательностей, после того как `NextState` вернет `false`.
```
public override IEnumerable GetSolveJobs(IGameBoard gameBoard,
SolvedData solvedData)
{
var itemsToHide = new List();
var itemsToShow = new List();
foreach (var solvedGridSlot in solvedData.GetUniqueSolvedGridSlots(true))
{
var newItem = \_itemsPool.GetItem();
var currentItem = solvedGridSlot.Item;
newItem.SetWorldPosition(currentItem.GetWorldPosition());
solvedGridSlot.SetItem(newItem);
itemsToHide.Add(currentItem);
itemsToShow.Add(newItem);
\_itemsPool.ReturnItem(currentItem);
}
foreach (var specialItemGridSlot in solvedData.GetSpecialItemGridSlots(true))
{
var item = \_itemsPool.GetItem();
item.SetWorldPosition(\_gameBoardRenderer.GetWorldPosition(specialItemGridSlot.GridPosition));
specialItemGridSlot.SetItem(item);
itemsToShow.Add(item);
}
return new IJob[] { new ItemsHideJob(itemsToHide), new ItemsShowJob(itemsToShow) };
}
```
Получившийся результат:
Следующая гениальная идея, которая посетила мою голову, а насколько универсальным получилось моё решение? Смогу ли я использовать этот код для реализации, например, такой же игры используя другой движок для визуализации? И вспомнив, что на днях наткнулся на [реализацию тетриса в терминале](https://github.com/semack/terminal-tetris) решил, а зачем вообще использовать какой-то движок?
Так как изначально логика была разделена на слои и не было жёсткой привязки к Unity, перенести удалось практически весь код, реализовав только логику отрисовки игрового поля в терминале. Для реализации асинхронности в Unity проектах я использую UniTask, а он помимо всех плюсов, которые я описал в своей [предыдущей статье](https://habr.com/ru/post/652483/), имеет ещё и .NET Core версию и доступен как [nuget](https://www.nuget.org/packages/UniTask/) пакет. Всё это вкупе, позволило реализовать версию для терминала всего за один вечер.
Вот так тот же уровень выглядит в терминале:
Эксперимент с терминалом показал, что в целом код получился довольно универсальным и его можно использовать. Но были моменты, которые можно было улучшить.
Например, обработка способа ввода. В начальной реализации вся логика была скрыта в классе `Match3Game`, который сам описывал логику взаимодействия с игровым полем получая интерфейс `IInputSystem`. Но если мы посмотрим на интерфейсы ввода с клавиатуры и мыши, то заметим, что у них мало общего.
```
public interface ITerminalInputSystem
{
event EventHandler KeyPressed;
event EventHandler Break;
void StartMonitoring();
void StopMonitoring();
}
```
```
public interface IUnityInputSystem
{
event EventHandler PointerDown;
event EventHandler PointerDrag;
event EventHandler PointerUp;
}
```
А так как логика в классе `Match3Game` опиралась на управление при помощи пальца или мыши, появились лишние проверки, которые при управлении с клавиатуры вовсе не нужны. Например, проверка и блокировка диагонального перемещения элементов, что с клавиатуры сделать невозможно. Конечно, можно и на базе `IUnityInputSystem` реализовать управление с клавиатуры, как я сначала и сделал, но выглядело это как костыль. В итоге было решено сделать класс `Match3Game` абстрактным и вообще выпилить из него интерфейс `IInputSystem`, предоставив возможность самому менять местами элементы игрового поля вызывав необходимый метод.
В итоге, как вы уже могли догадаться, всё это вылилось в разработку кроссплатформенной библиотеки, которую можно использовать для создания Match-3 игр.
Библиотека распространяется под [лицензией MIT](https://github.com/ChebanovDD/Match3-SDK/blob/main/LICENSE). Поэтому не стесняйтесь использовать её в своих проектах. А все исходники, примеры и документацию можно найти на [GitHub](https://github.com/ChebanovDD/Match3-SDK).
Ах да, чуть не забыл. Во время публикации пакета на площадке [OpenUPM](https://openupm.com/) выяснилось, что все пакеты собираются с использованием старой версии npm, отчего директория `Match3.Core` моей библиотеки, просто не попала в пакет. Но связавшись с автором он обновил npm до актуальной версии. Кто бы мог подумать, что простое тестовое может внести столько вклада в open source сообщество?
А как вы относитесь к тестовым заданиям? | https://habr.com/ru/post/663156/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.