Files
mtusi2026lab2/REPORT.md
T
ArtyomandClaude Opus 5.5 573220e12a Record level 4 evidence and fill in the report
evidence/level4.json: all 17 scenarios of levels 3 and 4 and the eight
invariants pass on 0b85edf; evidence/operator.txt shows the failed
registry, a replay to ready, a noop replay, an expired replay and the
DLQ. Smoke, topology, level3, persistence, failover, lab 4 scenarios,
limits, student tests and contract checks are refreshed on the same
commit. REPORT.md describes the variants, worker limits, jitter, lease
renewal, crash points, replay and retention, adds rows 4.1-4.4, the
level 4 failure experiments and the updated limitations.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-29 03:39:20 +03:00

391 lines
64 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# Отчёт — лабораторная 5
- Автор, группа: Костылев Артём, БПИ2303
- Целевая оценка: **5**; трек «5» — **трек 2 «Доказанная идемпотентность pipeline»**
- Commit/PR: ветка `solution/bpi2303-kostylev`, PR в репозиторий преподавателя
- Использованные источники, библиотеки и помощь ИИ: FastAPI, gunicorn + uvicorn-worker, dishka и
dishka-faststream, pydantic, structlog, asyncpg, argon2-cffi, redis-py, aiobotocore/botocore, Pillow,
FastStream 0.7 (`faststream[rabbit]`) поверх aio-pika, pytest, ruff, ty (версии — `evidence/environment.txt` и
`uv.lock`); RabbitMQ docs (Reliability Guide, Consumer Acknowledgements and Publisher Confirms, Quorum Queues,
Dead Lettering, Access Control, Definitions), документация FastStream 0.7 через context7 (ack policy, `Channel`,
`RabbitQueue(declare=False)`, publisher confirms), Pillow (`ImageOps.exif_transpose`, режимы и альфа-канал),
Docker Compose (secrets, `depends_on`, healthcheck). Заготовки брокера, compose-фрагмент, хуки и suite
сценариев — из моей подготовки `.prep/lab5`. Решение перенесено из моей лабы 4 и выполнено с помощью Claude
Code; код, стенд и отказы проверены прогонами, перечисленными ниже.
## Запуск из чистого clone
Требуются Docker с Compose v2, `make`, системный Python 3.9+ (публичные проверки и сценарии) и `uv` (собственные
тесты). Образы сторонних сервисов закреплены версией и digest, приложение собирается из исходников.
```sh
git clone <repo> && cd mtusi2026lab5 && git checkout solution/bpi2303-kostylev
make secrets # secrets/*: PostgreSQL, Valkey, ключ курсора, root/API/worker-ключи S3, пароли и URL брокера,
# rabbitmq_users.json с хешами паролей; .env из .env.example (существующее не перезаписывает)
docker compose --env-file .env config --quiet
make up # build, затем up -d --wait: postgres, valkey, s3, broker → migrate, s3-init → api ×2, relay, worker → lb
make test # публичный smoke через балансировщик, http://localhost:8080
make test-persistence ACTION_SCRIPT=scripts/restart.sh
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
make restore # вернуть остановленную реплику и дождаться её в ротации LB
make suite-preflight && make level3 # сценарии уровня «3» и инварианты → evidence/level3.json
make level4 # сценарии уровней «3» и «4» и инварианты → evidence/level4.json (~8 мин)
make failed # реестр failed-заданий (python -m messenger.admin failed)
make replay ID=<attachment_id> # явный replay failed → queued с audit; ready → noop
make dlq # просмотр DLQ без извлечения (rabbitmqadmin, ack_requeue_true)
make pipeline-evidence # worker остановлен: 202, 409, задание в очереди, SIGTERM relay/worker
make topology # очереди, consumer с prefetch, права, пользователи брокера → evidence/topology.txt
make worker-stop / make worker-start / make broker-restart / make queues # ручная демонстрация защиты
make down # безопасная остановка: контейнеры удаляются, volumes pgdata, valkeydata, s3data, broker-data остаются
make reset-data # НАМЕРЕННОЕ удаление учебных данных, включая байты вложений и очередь: docker compose down -v
```
`make up` ждёт `healthy` всех долгоживущих сервисов и кода 0 одноразовых `migrate` (миграции под advisory lock)
и `s3-init` (bucket, анонимный доступ `private`, политики и пользователи API и worker, lifecycle). Топологию
брокера (vhost, exchanges, quorum-очереди, привязки, политики) и пользователей узел RabbitMQ импортирует из
`/etc/rabbitmq/definitions.d` на каждой загрузке; повторный `make up`, `restart.sh` и `broker.sh restart` проходят
без изменений состояния. Наружу публикуются только порты `lb` (`LB_HTTP_PORT` 8080, `LB_STATS_PORT` 8404) и UI
брокера (`BROKER_MANAGEMENT_PORT` 15672), все на `127.0.0.1`. На машине, где выполнялась работа, параллельно
работали стенды других лаб, поэтому в локальном `.env` стояли `LB_HTTP_PORT=18085`, `LB_STATS_PORT=25085`,
`BROKER_MANAGEMENT_PORT=25672`, а проверки запускались с `BASE_URL=http://localhost:18085`. Доказательства уровня
«3» впервые сняты на стенде, поднятом после `make reset-data` (пустые volumes), на коммите `fe26938`; доказательства
уровней «3» и «4» в `evidence/` обновлены на коммите `0b85edf` (стенд пересобран `make up`, volumes сохранены).
Собственные проверки и тулчейн:
```sh
make install # uv sync --group dev (Python 3.14 и зависимости из uv.lock)
make lint # ruff check + ruff format --check (src, student-tests, Python-скрипты стенда) + ty check
make student-test # собственные тесты; поднимают одноразовые PostgreSQL, Valkey, RustFS и RabbitMQ тех же образов
make check # офлайн-проверка skeleton
make validate PYTHON=<venv с requirements-dev.txt>/bin/python # полная валидация OpenAPI и jobs.schema.json
make stack-evidence / make persistence-evidence / make failover-evidence # как в лабах 3–4
```
**Версии и стенд:** Python 3.14.7 в образе `python:3.14-slim-trixie@sha256:51dafde8…`,
`rabbitmq:4.1.8-management-alpine@sha256:54ef5ff5…` (RabbitMQ 4.1.8), `rustfs/rustfs:1.0.4@sha256:ed9210d6…`,
`rustfs/rc:v0.1.36@sha256:ab024bfe…`, `haproxy:3.2.26-alpine@sha256:58938405…`,
`postgres:17.11-alpine@sha256:266d3c25…`, `valkey/valkey:8.1.11-alpine@sha256:2602ace2…`; FastStream 0.7.8,
aio-pika 10.2.1, aiormq 7.2.4, dishka-faststream 0.7.0, Pillow 13.0.0; Docker 28.3.2, Compose 2.38.2. Машина —
Apple M4 Max, 16 CPU, 48 ГБ RAM, macOS 15.1; VM Docker Desktop — 16 CPU, 7.65 ГиБ (`evidence/environment.txt`).
## Архитектура и решения
```
┌─ api ×2 (gunicorn) ─ upload: проверка → PUT staging/<id> ──────────────▶ s3: RustFS
клиент ─HTTP─▶ lb (HAProxy) ─────┤ одна транзакция: attachments(queued) + jobs + outbox + job_events ──▶ postgres
127.0.0.1:8080 └─ 202 снимок queued; GET метаданных/контента читает PostgreSQL и S3 (источник истины)
relay ── SELECT outbox … FOR UPDATE SKIP LOCKED ─▶ publish (confirm, mandatory, persistent) ─▶ broker: RabbitMQ
└─ UPDATE published_at; возврат истёкших аренд; staging у ready и у failed после retention quorum attachments.process
worker ◀── FastStream subscriber, prefetch = WORKER_CONCURRENCY, manual ack ───────────────────────┘ DLX → .dlq
└─ claim (lease_token) → продление аренды → GET staging → процесс рендера: thumbnail, crop, optimized
→ CopyObject originals/<id>, PUT variants/<id>/1/… → COMMIT (fencing, ON CONFLICT DO NOTHING,
published_version < v) → ack
admin (python -m messenger.admin, только PostgreSQL) ── failed: реестр; replay: failed → queued + outbox + audit
сеть edge: lb, broker (UI на 127.0.0.1) ─── сеть backend (internal): все сервисы
```
**Источник истины.** PostgreSQL — для всего, что знает система о вложении и задании: статус, ключи staging и
оригинала, опубликованная версия, варианты, попытки, аренда, намерение публикации и журнал переходов. S3 — только
для байтов (`staging/<id>`, `originals/<id>`, `variants/<id>/<версия>/<имя>-<sha256[:16]>.jpg`). Брокер —
транспорт и будильник: сообщение несёт только идентификаторы по `jobs.schema.json`, worker берёт ключи хранилища
из БД. Потерянное сообщение восстанавливается из PostgreSQL (outbox, возврат аренды), лишнее гасится захватом
задания.
**Перенесено из лабы 4 без изменения поведения:** зоны `identity`, `messaging`, `attachments`, порты и адаптеры,
UoW, шина событий с журналом аудита, ASGI-конвейер, Basic → Bearer, Argon2id, сессии в PostgreSQL с кэшем в
Valkey, `X-Instance-Id`, `Idempotency-Key`, HAProxy с проверкой готовности, RustFS с приватным bucket, порядок
проверок upload (лимит тела по маршруту, членство, `filename`, `Content-Type`, слоты, поток со счётчиком,
проверка изображения по заголовку), компенсация и уборка намерений `pending` по grace period, хуки, сценарии и
проверки уровня «4» лабы 4. **Изменено:** upload отвечает `202 queued`, оригинал пишется в `staging/`, вместо
`ready` строка-намерение переходит в `queued` вместе с заданием и outbox; метаданные и `/content` показывают
статусы и варианты; `messaging` отказывает `409` на `failed`-вложение; новые процессы `relay` и `worker`, сервис
`broker`, миграция `0004`; `restart.sh` перезапускает ещё брокер, relay и worker; сценарии лабы 4 ждут `ready`.
**Процессы и границы зон.** Три долгоживущих процесса из одного образа: `api` (`messenger.main:create_app()`),
`relay` (`python -m messenger.relay`), `worker` (`python -m messenger.worker`), и одноразовая CLI оператора
`python -m messenger.admin`. `relay.py`, `worker.py` и `admin.py` — сборки процессов рядом с `main.py`; они знают
только зону `attachments` и `shared`. Вся логика pipeline — в зоне `attachments`: домен заданий (`Job` и его
сообщение, `Lease`, `Claim`, `RetryPolicy` с jitter, `FailureCode`, `Outcome`, `ReplayResult`, `FailedJob`, `Variant`,
`fit`), обработчики `ProcessJob`, `PublishOutbox`, `RecoverExpiredLeases`, `CleanStaging`, `ReplayAttachment`, порты
`JobPublisher`, `VariantRenderer`, `Faults`, `Jitter`, расширенные `ObjectStorage`, UoW и `AttachmentDirectory`,
адаптеры FastStream (`infrastructure/rabbitmq.py`), Pillow и пула процессов рендера (`infrastructure/images.py`),
PostgreSQL, `FAULT_POINT` и jitter, точки входа FastStream-подписчика, циклов relay и CLI оператора.
Ядро `shared/` не импортирует ни веб-фреймворк, ни FastStream, ни aio-pika; dishka-контейнер worker и relay
собирается из тех же `PlatformProvider` и адаптеров, что у API, через интеграцию `dishka-faststream`. Вопрос
`messaging` «есть ли среди вложений `failed`» — порт `AttachmentStates` зоны `messaging`, адаптер которого над
`AttachmentDirectory` собирает `main.py`. Правила проверяет `student-tests/api/test_bounded_contexts.py`.
**Схема** (`0004_jobs.sql`, expand): у `attachments` статусы `pending/queued/processing/ready/failed`,
`staging_key`, `original_key`, `published_version`, `error_code` (CHECK: `invalid_image`, `processing_failed`,
`retry_exhausted`); `object_key` лабы 4 перенесён в новые колонки и оставлен nullable до contract-миграции. Новые
таблицы: `attachment_variants` с PK `(attachment_id, pipeline_version, name)` — ключ эффекта — и уникальным
`object_key`; `jobs` (`UNIQUE (attachment_id, pipeline_version)`, `attempt`, `claims`, `lease_token`,
`lease_until`, `next_attempt_at`, `last_error`); `outbox` (`payload jsonb`, `available_at`, `published_at`);
`job_events` (журнал переходов). Частичные индексы: `outbox_pending_idx (available_at, id) WHERE published_at IS
NULL` — выборка relay, `jobs_lease_idx (lease_until) WHERE status = 'processing'` — истёкшие аренды,
`attachments_staged_idx (updated_at) WHERE staging_key IS NOT NULL` — уборка staging (`ready` и `failed` после
retention). `0005_failed_registry.sql` (expand, только индекс): `jobs_failed_idx (updated_at DESC) WHERE status =
'failed'` — реестр оператора `ORDER BY updated_at DESC LIMIT n`.
**Upload и что сохранено в момент `202`.** Лимиты и проверки лабы 4 не изменились. После проверки изображения:
`INSERT attachments (pending, staging_key)` и `COMMIT` → `PutObject staging/<id>` → одна транзакция:
`UPDATE attachments SET status='queued' WHERE status='pending'`, `INSERT jobs (pipeline_version=1, attempt=1)`,
`INSERT outbox (payload по jobs.schema.json)`, `INSERT job_events ('enqueued')` → `202`. Ответ — снимок объекта
из памяти (`queued`, `variants=[]`, `error_code=null`), не перечитанный после фиксации. К моменту `202` устойчиво
сохранены полный проверенный оригинал в S3, метаданные, задание и намерение его публикации. API не строит
вариантов и не подключается к брокеру: недоступный worker или брокер не влияет на upload.
**Outbox и relay.** Раз в `OUTBOX_POLL_SECONDS` (1 с) relay в транзакции берёт до 50 строк `WHERE published_at IS
NULL AND available_at <= now() ORDER BY available_at, id FOR UPDATE SKIP LOCKED`, публикует каждую через
`RabbitBroker.publish` (exchange `attachments` без объявления, routing key `attachment.process.v1`,
`persist=True`, `mandatory=True`, `message_id = job_id`, `type = attachment.process.v1`, тело — ровно `payload`)
и той же транзакцией ставит `published_at`. Канал открыт с `publisher_confirms=True` и `on_return_raises=True`:
unroutable-сообщение, `basic.nack` или обрыв соединения — ошибка, строка остаётся неопубликованной и
повторяется. Publisher confirm — подтверждение брокера, что сообщение записано в quorum queue; обработку он не
подтверждает. Раз в `SWEEP_INTERVAL_SECONDS` (5 с) relay возвращает задания `processing` с истёкшей арендой
(`queued`, `attempt + 1`, новая строка outbox, событие `lease_expired`; на пределе попыток — `failed`) и удаляет
staging-объекты `ready`-вложений (у worker нет права `DeleteObject`).
**Worker: захват, фиксация, `ack`.** FastStream `RabbitBroker` (`logger=None`: журнал только через порт `Logger`),
подписчик на `RabbitQueue("attachments.process", declare=False, quorum)` без привязки к exchange,
`Channel(prefetch_count=WORKER_CONCURRENCY)`, `AckPolicy.MANUAL`, `graceful_timeout` 5 с. Сообщение не по схеме
(pydantic-модель с `extra="forbid"`) — `reject(requeue=False)` в DLX. Дальше:
1. *Захват* — `UPDATE jobs SET status='processing', lease_token=<новый uuid>, lease_until=now()+JOB_TIMEOUT_SECONDS,
claims=claims+1 WHERE job_id=$1 AND attachment_id=$2 AND pipeline_version=$3 AND ((status='queued' AND
next_attempt_at наступил) OR (status='processing' AND lease_until < now()))`, вложение `queued → processing`,
событие `claimed`. Нет строки — задание уже `done`/`failed`, держится живой арендой или повтор ещё не наступил:
событие `duplicate_noop` и `ack`. `attempt` из сообщения информационный, захват идёт по `job_id`.
2. *Побочные эффекты под арендой* — сначала продление аренды (`UPDATE jobs SET lease_until = now() + JOB_TIMEOUT_SECONDS
WHERE job_id AND lease_token AND status='processing'`), затем задачей: чтение `staging/<id>`, рендер трёх вариантов
в процессе рендера, `CopyObject staging → originals/<id>`, `PutObject variants/<id>/1/<имя>-<sha256[:16]>.<jpg|webp>`;
пока задача идёт, аренда продлевается раз в `JOB_TIMEOUT_SECONDS / 3`. Продление не удалось (аренду забрали или
задание уже вернули в очередь) — задача отменяется вместе с процессом рендера, событие `fenced`, `ack`. Ключ
содержит хеш: повтор с другими байтами не перезапишет объект, на который уже ссылается БД.
3. *Фиксация* — одна транзакция: `UPDATE jobs SET status='done' … WHERE status='processing' AND lease_token=$2`
(0 строк — аренду перехватили: событие `fenced`, ничего не публикуется); `INSERT attachment_variants … ON
CONFLICT DO NOTHING`; `UPDATE attachments SET status='ready', published_version=$v, original_key … WHERE
published_version < $v` (0 строк — опубликована более новая версия: задание `superseded`); событие `done`.
4. *`ack` — только после `COMMIT`.* Ошибка PostgreSQL до или во время фиксации — `nack(requeue=True)` через 1 с;
если аренда уже взята, задание вернёт relay по её истечении.
**Повторы, jitter и классификация ошибок.** Временная ошибка — `Unavailable` от S3 или PostgreSQL, падение процесса
рендера по внешней причине (`BrokenProcessPool`, например OOM killer), точка `transient_error` — возвращает задание
и вложение в `queued` (не `failed` — smoke падает на первом `failed`) с тем же `job_id`, `attempt + 1` и новой
строкой outbox. Задержка — equal jitter: `d = min(JOB_BACKOFF_CAP_SECONDS=60, JOB_BACKOFF_BASE_SECONDS · 2^(n−1))`,
задержка `d/2 + U(0, d/2)` (`RetryPolicy.delay(attempt, spread)`, `spread` — порт `Jitter`, адаптер на
`secrets.SystemRandom`); `next_attempt_at` и `available_at` считает PostgreSQL (`now() + make_interval`), задержка
пишется в `job_events.detail.delay_seconds`. Full jitter не выбран: все пять попыток могли бы уложиться в доли
секунды и короткий отказ S3 превратился бы в `retry_exhausted`; нижняя граница `d/2` держит суммарное окно 15–30 с
при базе 2 с. После `JOB_MAX_ATTEMPTS` (5) попыток — `failed` с `retry_exhausted`. Постоянные ошибки — сразу
`failed`, без повторов: не декодируется или больше `MAX_IMAGE_PIXELS` по заголовку — `invalid_image`; превышены
время или память рендера, оригинал больше `MAX_UPLOAD_BYTES`, оригинала нет в хранилище, непредвиденная ошибка —
`processing_failed`. В `error_code` — короткий код, в `jobs.last_error` — имя класса ошибки без текста. Все переходы
— с fencing по `lease_token` и не трогают вложение в `ready`.
**Варианты.** Одно декодирование на задание (`render_variants`): проверка байтов (`MAX_UPLOAD_BYTES`) и пикселей по
заголовку (`MAX_IMAGE_PIXELS`) до декодирования → для JPEG `draft()` до размера optimized (libjpeg сразу уменьшает в
2/4/8 раз) → `ImageOps.exif_transpose(in_place=True)` до расчёта размеров → 16-битные режимы масштабируются в `L`,
палитра с прозрачностью, `LA`, `RGBA` компонуются на белый фон, прочее — `convert("RGB")` → три
`resize(LANCZOS, reducing_gap=3)`. Размеры — от размеров после ориентации по заголовку, целочисленно вниз:
| Вариант | Геометрия | Кодирование | Fixture 320×200 |
| --- | --- | --- | --- |
| `thumbnail` | вписан в 256×256, без увеличения, вниз, минимум 1 px | JPEG `quality=85`, `optimize=True` | 256×160 |
| `crop` | `ImageOps.fit` в 128×128 по центру (`centering=(0.5, 0.5)`), увеличение разрешено | JPEG `quality=85`, `optimize=True` | 128×128 |
| `optimized` | вписан в 1280×1280, без увеличения, вниз, минимум 1 px | WebP с потерями `quality=80`, `method=4` | 320×200 |
Метаданные (EXIF, ICC, XMP) в варианты не пишутся: кодеры Pillow 13 берут их только из явных параметров `save`,
а мы их не передаём (`student-tests/unit/test_renderer.py` проверяет и `getexif()`, и `info`). Альфа в `optimized`
тоже на белом — один источник для трёх вариантов; уменьшения каждого маленького файла WebP не обещает. Примеры:
17×1000 → thumbnail 4×256, optimized 17×1000; 3000×2 → 256×1 и 1280×1; JPEG 4000×3000 → 256×192 и 1280×960; EXIF 6
400×200 → 128×256 и 200×400. `ready` выставляет та же транзакция, что пишет строки трёх вариантов: частичного
набора в API не бывает (`test_partial_variant_set_is_never_published`).
**Пределы worker.** Рендер — адаптер `ProcessVariantRenderer` порта `VariantRenderer`: `WORKER_CONCURRENCY` слотов,
слот — `ProcessPoolExecutor(max_workers=1, max_tasks_per_child=RENDER_TASKS_PER_CHILD=100)` (forkserver), в
процессе рендера `RLIMIT_AS = RENDER_MEMORY_MB` (448 MiB). Ожидание результата — `asyncio.wait_for(…,
RENDER_TIMEOUT_SECONDS=30)`; таймаут → `kill_workers()` этого слота и новый процесс, `processing_failed`;
`MemoryError` в процессе рендера → `processing_failed`; процесс убит снаружи → временная ошибка; отменённый рендер
(потеря аренды, остановка) тоже убивает свой процесс. Слот на процесс, а не общий пул: убийство по таймауту не
задевает соседнее задание. Замеры в образе: процесс рендера после импорта Pillow — 46 МБ адресного пространства,
рендер трёх вариантов 8000×5000 — пик 258 МБ (RGB) и 398 МБ (RGBA); с пределом 300 МБ RGBA-рендер получает
`MemoryError`. Поэтому `RENDER_MEMORY_MB=448` покрывает любое 8-битное изображение до 40 Мпикс, а предел контейнера
`WORKER_MEMORY=1g ≥ 2 × 448 MiB + ~120 MiB` самого worker. Prefetch канала = `WORKER_CONCURRENCY` = число слотов:
в полёте у процесса не больше двух заданий.
**Чтение.** `GET /attachments/{id}` отдаёт любой статус, кроме внутреннего `pending`, с вариантами опубликованной
версии одним запросом (`jsonb_agg` по PK вариантов). `/content`: посторонний — `404`; не `ready` — `409 conflict`
для любого `variant`, включая `original`; `original` — `original_key` с типом оригинала; `thumbnail` — вариант;
`thumbnail`, `crop`, `optimized` — варианты опубликованной версии; варианта нет у опубликованной версии (вложение,
ставшее `ready` в лабе 4) — `404`; иное значение `variant` — `400`. Сообщение со ссылкой на `failed` —
`409`, на `queued`/`processing` — `201`; повтор по `Idempotency-Key` возвращает исходный ответ, даже если
вложение потом стало `failed`.
**Готовность и SIGTERM.** `/health/ready` реплик API зависит только от PostgreSQL, как в лабе 4: брокер развязан
outbox-ом, а при недоступном S3 upload и скачивание отвечают `503` от приложения, тексты работают. Relay и worker
проверяются heartbeat-файлом, который обновляется, пока жив цикл событий и брокер отвечает на ping (от PostgreSQL и
S3 не зависит — иначе worker не стартовал бы при временно недоступном S3). SIGTERM: worker отменяет consumer, ждёт
задачи до 5 с, закрывает канал (неподтверждённые сообщения возвращаются в очередь); relay завершает циклы и
закрывает соединение; оба выходят с кодом 0 за 0,5 с (`evidence/pipeline-stand.txt`).
**Окна отказа** (`contracts/attachment-states.md`). Точки падения задаёт `FAULT_POINT` только в
`infra/compose.faults.yaml` (там же `restart: "no"`, аренда 5 с, база backoff 1 с); падение — `os._exit(137)` после
сброса журналов, без какой-либо дальнейшей работы; порт `Faults` вызывается в обработчиках зоны:
| Окно | Точка `FAULT_POINT` (процесс) | Что лежит после сбоя | Кто восстанавливает | Сценарий |
| --- | --- | --- | --- | --- |
| 1: после staging, до записи задания | — (API) | невидимая строка `pending` и объект `staging/`, `202` не отдан | компенсация сразу; уборка намерений лабы 4 после grace | `make upload-faults` (лаба 4) |
| 2: после `COMMIT`, до publish | `after_commit_before_publish` (relay: строка взята `FOR UPDATE`, publish не отправлен) | строка outbox без `published_at`, очередь пуста, вложение `queued` | relay после рестарта, тот же `job_id` | `crash_commit_publish` |
| 3: после publish, до confirm/`published_at` | `after_publish_before_confirm` (relay: confirm получен, `published_at` не записан) | сообщение в очереди, строка не помечена | relay публикует повторно, вторая копия — `duplicate_noop` | `crash_publish_confirm` |
| — после захвата, до побочных эффектов | `after_claim_before_side_effect` (worker) | `processing`, живая аренда, S3 пуст | redelivery видит живую аренду → `ack`; relay возвращает задание по истечении аренды | трек 2 |
| 4: после записи S3, до `COMMIT` результата | `after_s3_write_before_commit` (worker) | объекты трёх вариантов и оригинала, строк вариантов нет | relay возвращает аренду, попытка 2 пишет те же ключи и фиксирует | `crash_after_s3_before_commit` |
| 5: после `COMMIT`, до `ack` | `after_commit_before_ack` (worker) | `ready`, сообщение не подтверждено | redelivery видит `done` → `duplicate_noop` и `ack` | `crash_after_commit_before_ack` |
| зависший держатель | `stall_after_claim` (worker: один раз спит `FAULT_STALL_SECONDS`=15 с без продления) | аренда истекает | relay возвращает задание, вторая попытка → `ready`; проснувшийся держатель не продлевает аренду → `fenced` | `lease_expiry_fencing` |
Окно 3 воспроизводится состоянием, а не моментом: FastStream ждёт confirm внутри `publish`, поэтому процесс падает
уже после confirm, но до записи `published_at`; для системы это то же — брокер знает о сообщении, PostgreSQL нет.
At-least-once доставки + идемпотентный эффект по ключу `(attachment_id, pipeline_version, variant)` + fencing по
`lease_token` = один опубликованный результат. Это не exactly-once: окна 3 и 5 дают повторные доставки, их гасит
эффект, а не брокер.
**Топология брокера** (`infra/rabbitmq/definitions.json`, импорт на каждой загрузке): vhost `messenger`
(`default_queue_type: quorum`); exchange `attachments` (direct) → `attachments.process` (quorum, durable);
`attachments.dlx` (fanout) → `attachments.process.dlq` (quorum); политика `attachments-process`:
`dead-letter-exchange=attachments.dlx`, `dead-letter-strategy=at-least-once`, `overflow=reject-publish`,
`delivery-limit=10`; DLQ — `max-length=100000`. DLX и delivery-limit заданы политикой, поэтому клиенты делают
только пассивный declare и не получают `PRECONDITION_FAILED`. Права (`evidence/topology.txt`): `messenger-api`
(relay) — только запись в `attachments`, `messenger-worker` — только чтение `attachments.process`,
`messenger-ops` — оператор; `guest` нет. В `rabbitmq.conf`: `consumer_timeout` 300 с (больше аренды 60 с),
`vm_memory_high_watermark` 256 MiB, запрет transient-очередей и global QoS.
**Роли и сервисы** (`compose.yaml`; сети `edge` и `backend` с `internal: true`):
| Роль | Сервис | Версия / digest | Health / readiness | Volume | Сеть / порт | Credentials |
| --- | --- | --- | --- | --- | --- | --- |
| load_balancer | `lb` | `haproxy:3.2.26-alpine@sha256:58938405…`, uid 99, `read_only` | `/healthz` :8404; реплики — `GET /health/ready` | нет | `edge` + `backend`; `127.0.0.1:${LB_HTTP_PORT:-8080}`, `127.0.0.1:${LB_STATS_PORT:-8404}` | нет |
| api ×`API_REPLICAS` | `api` | сборка из `Dockerfile`, uid 10001, `read_only` | `GET /health/ready` (PostgreSQL) | нет | `backend`, без портов | `database_url`, `cache_url`, `cursor_secret`, ключ API S3 через `*_FILE`; брокера нет |
| broker | `broker` | `rabbitmq:4.1.8-management-alpine@sha256:54ef5ff5…`, uid 100, `hostname: broker`, `read_only`, `cap_drop: ALL` | `rabbitmq-diagnostics -q check_port_connectivity` | `broker-data:/var/lib/rabbitmq` | `backend` + `edge`; AMQP 5672 внутри; UI `127.0.0.1:${BROKER_MANAGEMENT_PORT:-15672}` | definitions с хешами паролей — secret `rabbitmq_users`; пароль оператора — `rabbitmq_ops_password` |
| outbox relay | `relay` | образ приложения, `python -m messenger.relay`, `init`, `read_only` | heartbeat `/tmp/heartbeat` моложе 30 с | нет | `backend`, без портов | `database_url`, `broker_url` ← `broker_url_api`, ключ API S3 |
| worker | `worker` | образ приложения, `python -m messenger.worker`, `init`, `read_only` | heartbeat `/tmp/heartbeat` моложе 30 с | нет | `backend`, без портов | `database_url`, `broker_url` ← `broker_url_worker`, ключ worker S3 |
| postgres | `postgres` | `postgres:17.11-alpine@sha256:266d3c25…`, uid 70 | `pg_isready` | `pgdata` | `backend` | `postgres_password` через `POSTGRES_PASSWORD_FILE` |
| s3 | `s3` | `rustfs/rustfs:1.0.4@sha256:ed9210d6…`, uid 10001, консоль выключена | `curl /health/ready` | `s3data` | `backend`, :9000 без публикации | root-ключи через `RUSTFS_*_FILE` |
| bootstrap S3 | `s3-init` | `rustfs/rc:v0.1.36@sha256:ab024bfe…` | код выхода 0 | нет | `backend` | root-ключи, ключи API и worker (создаёт пользователей) |
| bootstrap схемы | `migrate` | образ приложения, `restart: "no"` | код выхода 0 | нет | `backend` | `database_url` |
| сессии (кэш) | `valkey` | `valkey/valkey:8.1.11-alpine@sha256:2602ace2…`, uid 999 | `valkey-cli ping` | `valkeydata` (AOF) | `backend` | `valkey.conf` |
| CLI S3 и нагрузка | `s3-cli` (профиль `tools`), `k6` (профиль `bench`) | как в лабе 4 | нет | нет | `backend` / `edge` | как в лабе 4 |
Bootstrap: схема — `migrate` (advisory lock, повтор без изменений); bucket, политики `messenger-api`
(`infra/s3/api-policy.json`) и `messenger-worker` (`infra/s3/worker-policy.json`: чтение `staging/`, `originals/`,
`variants/`, запись `originals/` и `variants/`), пользователи и lifecycle — `s3-init` (`--ignore-existing`, повтор
без изменений, самопроверка политик); топология и пользователи брокера — definitions на загрузке узла
(идемпотентный импорт; ротация пароля — удалить `secrets/rabbitmq_<роль>_password` и `broker_url_<роль>`,
`make secrets`, `docker compose up -d broker relay worker`). Лимиты: broker 1/512m, relay 0.5/192m, worker
2/1g (два процесса рендера по 448 MiB и сам worker), остальное как в лабе 4; `make limits` проверяет политику секретов, volumes, сетей и портов
(`evidence/limits.txt`).
**Соответствие `.env.example` реальной конфигурации:**
| `.env.example` | В решении | Комментарий |
| --- | --- | --- |
| `APP_*`, `SESSION_*`, `DATABASE_URL_FILE`, `CACHE_URL_FILE`, `API_REPLICAS`, `IDEMPOTENCY_TTL_SECONDS`, `S3_*`, `MAX_UPLOAD_BYTES`, `MAX_IMAGE_PIXELS` | как в лабе 4 | |
| `BROKER_URL_FILE=/run/secrets/broker_url` | тот же у `relay` и `worker` | разные secrets: `broker_url_api` и `broker_url_worker`; у API нет |
| `WORKER_CONCURRENCY=2` | тот же | prefetch канала consumer и параллельные рендеры одного worker |
| `JOB_MAX_ATTEMPTS=5` | тот же | предел попыток; последняя неудача — `retry_exhausted` |
| `JOB_TIMEOUT_SECONDS=60` | тот же | аренда захваченного задания; меньше `consumer_timeout` 300 с |
| `STAGING_RETENTION_SECONDS=86400` | тот же (настройка relay) | staging `ready`-вложения relay удаляет сразу после публикации, `failed` — через `STAGING_RETENTION_SECONDS` после перехода в `failed` (до этого возможен replay) |
| — | `BROKER_MANAGEMENT_PORT`, `JOB_BACKOFF_BASE_SECONDS`, `OUTBOX_POLL_SECONDS`, `SWEEP_INTERVAL_SECONDS`, `WORKER_CPUS`, `WORKER_MEMORY`, `PIPELINE_DB_POOL_MAX_SIZE` | UI брокера; база backoff 2 с; опрос outbox 1 с; возврат аренд и уборка staging 5 с; лимиты worker; пул PostgreSQL relay и worker |
| — | `RENDER_TIMEOUT_SECONDS=30`, `RENDER_MEMORY_MB=448`, `RENDER_TASKS_PER_CHILD=100`, `WORKER_MEMORY=1g` | время рендера (процесс убивается), адресное пространство процесса рендера, задач на процесс; `WORKER_MEMORY ≥ WORKER_CONCURRENCY · RENDER_MEMORY_MB` + ~120 MiB |
| — | `FAULT_POINT`, `FAULT_STALL_SECONDS`, `FAULT_RENDER_TIMEOUT_SECONDS`, `FAULT_RENDER_MEMORY_MB`, `FAULT_STAGING_RETENTION_SECONDS` | только в `infra/compose.faults.yaml` (короткие аренда и backoff, `restart: "no"`), никогда в основном стенде; suite переводит relay и worker в этот режим и возвращает обратно |
| — | прочие `LB_*`, `API_*`, `PG_*`, `UPLOAD_*`, `S3_*_TIMEOUT_SECONDS`, `MALLOC_MMAP_THRESHOLD_` | как в лабе 4 |
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | `make test BASE_URL=http://localhost:18085` | `PASS: lab5 public API scenario` (upload → `202 queued`, сразу сообщение `text=""` с вложением → `201`, `ready` от bob, оригинал побайтно `image/png`, eve `404`, один вариант `thumbnail` 256×160, настоящий JPEG той же длины и SHA-256, весь минимум lab2–lab4) | `evidence/smoke.txt` |
| `make check` / `make validate` / `make lint` | `make check`; `make validate` в venv с `requirements-dev.txt`; `make lint` | `PASS: offline skeleton structure…`; `PASS: full OpenAPI 3.1 and JSON Schema validation`; ruff, формат, ty — `All checks passed!` | `evidence/contract-checks.txt` |
| Собственные тесты | `make student-test` | `417 passed, 1 skipped` (предел `RLIMIT_AS` — только Linux; 15 проверок стенда под маркером `stack` — отдельно): pipeline против PostgreSQL, восстановление после внедрённых падений, продление аренды, replay и retention, пул процессов рендера, три варианта, jitter, CLI оператора, адаптеры против RabbitMQ и RustFS, контракт сообщения, архитектура | `evidence/student-tests.txt` |
| **3.1** `202` только после устойчивого staging и сохранения задания; остановка API после ответа не теряет работу | `make level3` (`worker_down_broker_restart`), `make pipeline-evidence`; тесты `test_attachments.py`, `test_upload_consistency.py`, `test_pipeline.py` | ответ — снимок `queued`, в БД ключ `staging/<id>`, задание и строка outbox; отказ фиксации после записи staging → `503`, нет ни строки, ни задания, ни объекта; после `202` перезапущены обе реплики API и relay — задание одно в очереди и доходит до `ready` | `evidence/level3.json`, `evidence/pipeline-stand.txt`, `evidence/student-tests.txt` |
| **3.2** Отдельные broker и worker в общем стенде; durable, at-least-once, подтверждение после эффекта | `make topology`; `make pipeline-evidence`; `test_rabbitmq.py` | `attachments.process` и `.dlq` — `quorum`, `durable`, политики применены; один consumer `ack_required=true`, `prefetch_count=2`; сообщение в очереди: `delivery_mode: 2`, `message_id` = `job_id`, тело — ровно 7 полей `jobs.schema.json`; `ack` только после `COMMIT` (ошибка обработки → `nack` → повторная доставка до успеха); сообщение не по схеме → DLQ; учётка worker не может публиковать | `evidence/topology.txt`, `evidence/pipeline-stand.txt`, `evidence/student-tests.txt` |
| **3.2** Недоступность worker не заставляет API делать resize синхронно | `make pipeline-evidence`, `worker_down_broker_restart` | worker остановлен: upload `202 queued`, `/content` (`original` и `thumbnail`) → `409`, сообщение с вложением `201`, текст и история работают, вложение остаётся `queued`, задание лежит в очереди (`messages_ready=1`) | `evidence/pipeline-stand.txt`, `evidence/level3.json` |
| **3.3** Состояния `queued/processing/ready/failed`; оригинал неизменен, thumbnail по контракту | `make test`, `smoke_pipeline`, `test_pipeline.py`, `test_renderer.py` | переходы видны в API и `job_events` (`enqueued → claimed → done`); оригинал из `originals/<id>` побайтно равен загруженному; thumbnail 256×160 JPEG, длина и SHA-256 равны метаданным; инвариант `bytes_match_metadata` — PASS | `evidence/smoke.txt`, `evidence/level3.json`, `evidence/student-tests.txt` |
| **3.4** Ограниченный retry, финальное `failed` с безопасным `error_code` | `retry_exhausted`, `s3_outage_recovers` (`make level3`); `test_pipeline.py` | точка `transient_error`: задание `failed`, `attempt = 5 = JOB_MAX_ATTEMPTS`, `error_code = retry_exhausted`, `/content` и сообщение со ссылкой → `409`; S3 остановлен во время обработки → вложение `queued` с `attempt = 2`, после возврата S3 — `ready`; нечитаемый оригинал → `invalid_image` с `attempt = 1`; следующая попытка отложена на базу backoff; инвариант `bounded_attempts` — PASS | `evidence/level3.json`, `evidence/student-tests.txt` |
| **3.4** Повтор одной job не создаёт второго набора вариантов | `duplicate_after_ready`; `test_pipeline.py` | копия сообщения после `ready` → `duplicate_noop`, метаданные и строки вариантов до и после равны; две копии одновременно → один `done` и один `duplicate_noop`, одна строка варианта, `claims = 1`; опоздавший держатель аренды → `fenced`, вариантов не добавил; инвариант `single_effect` — PASS | `evidence/level3.json`, `evidence/student-tests.txt` |
| **3.5** Демонстрация: worker остановлен → upload `202` → сообщение → рестарт API → worker → `ready`; задание переживает рестарт broker с volume | `make level3` (`worker_down_broker_restart`) | хронология с ID без токенов: worker остановлен 22:20:24.58; upload `202 queued` (`01a18499-a689…`); `/content` `409`; сообщение `201` (`01a18499-a698…`); в очереди `[1, 0]`; обе реплики API и relay перезапущены; broker перезапущен с volume — в очереди снова `[1, 0]`; worker запущен 22:20:49.24, `ready` с `thumbnail` 22:20:49.42 | `evidence/level3.json` |
| **3.5** Минимум lab4: persistence | `make persistence-evidence` | `PASS: persistence …`; `StartedAt` у `lb`, обеих `api`, `relay`, `worker`, `postgres`, `valkey`, `s3`, `broker` новее, контейнеры те же, hostname брокера `broker` | `evidence/persistence.txt` |
| **3.5** Минимум lab4: failover | `make failover-evidence` | `PASS: failover …`: 2 реплики до отказа, 134 записи, 0 ошибок, первая запись через 2,85 с; цель `db66b246dcf8` в `exited`, в её журнале сигнал, окно readiness `503`, выход; `make restore` вернул реплику | `evidence/failover.txt` |
| Минимум lab4: download через другую реплику, недоступный S3, приватность, негативный suite, политика | `make scenario SCENARIO=failover-upload`, `SCENARIO=s3-outage`, `make s3-check`, `make upload-faults`, `make limits` | upload принят `db66b246dcf8`, после `ready` и её остановки — скачивание через `6f688eb249b1` за 2,87 с, SHA-256 равен; S3 остановлен: upload и `/content` `503` за 4,5–4,7 с, метаданные, текст и readiness работают; `RESULT: PASS`; 5 проверок стенда, 0 × `5xx`; политика портов, секретов и сетей — PASS | `evidence/failover-upload.json`, `evidence/s3-outage.json`, `evidence/s3-security.txt`, `evidence/upload-faults.txt`, `evidence/limits.txt` |
| Инварианты suite уровня «3» | `make suite-preflight && make level3` | 6/6 сценариев PASS; `terminal`, `single_effect`, `no_ready_rollback`, `monotonic_publication`, `bytes_match_metadata`, `bounded_attempts`, `no_orphans` (очереди пусты, outbox опубликован, staging `ready` убран, лишних писем в DLQ нет), `no_lost_202` — PASS | `evidence/level3.json` |
| **4.1** Crop 128×128 и optimized WebP по контракту, параметры качества и удаления метаданных | `make level4` (`image_matrix`, `smoke_pipeline`), `test_renderer.py`, `test_attachments.py` | 17 изображений матрицы (RGB, RGBA, палитра с tRNS, серые 8/16 бит, CMYK, EXIF 6 и 3, 1×1, 3000×2, 4000×3000, ровно 10 MiB) → `ready` с `crop`, `optimized`, `thumbnail`; у каждого варианта реальные размеры из SOF/VP8 равны метаданным и manifest, длина и SHA-256 равны отдаваемым байтам; fixture: 256×160, 128×128, 320×200; в вариантах нет EXIF, ICC, XMP; частичный набор не публикуется | `evidence/level4.json`, `evidence/student-tests.txt` |
| **4.1** Пределы по байтам, пикселям, времени и памяти worker | `make level4` (`image_matrix`, `worker_limits`), `test_render_pool.py`, `test_renderer.py` | вход: 10 485 761 B, 8001×5000 и 10000×5000 → `413`, битые и не-изображения → `415`; worker: PNG 8000×5000 при `RENDER_TIMEOUT_SECONDS=0,5` и при `RENDER_MEMORY_MB=200` → `failed processing_failed` с `attempt 1`, контейнер worker `running`; со штатными пределами тот же файл → `ready`, пик `memory.peak` 379 MiB при `memory.max` 1024 MiB; в тестах таймаут убивает процесс и освобождает слот, падение процесса рендера — временная ошибка, `MemoryError` — постоянная | `evidence/level4.json`, `evidence/student-tests.txt` |
| **4.2** Transactional outbox; crash между `COMMIT` и publish, восстановление без нового задания | `make level4` (`crash_commit_publish`, `crash_publish_confirm`), `test_recovery.py` | relay с `after_commit_before_publish` → exit 137, строка outbox `published=false`, очередь `[0, 0]`, вложение `queued`; relay перезапущен без точки → `ready` с тем же `job_id`, outbox опубликован; `after_publish_before_confirm` → exit 137, строка не помечена, после рестарта повторная публикация, вторая копия — `duplicate_noop` | `evidence/level4.json`, `evidence/student-tests.txt` |
| **4.3** Backoff с jitter, постоянные и временные ошибки | `make level4` (`retry_backoff_jitter`, `s3_outage_recovers`, `poison_image`, `retry_exhausted`), `test_pipeline_domain.py`, `test_pipeline.py` | задержки попыток 2–5 при базе 1 с: 0,69; 1,74; 2,83; 7,55 с — доли верхней границы 0,69; 0,87; 0,71; 0,94 в `[0,5; 1]` (`make replay` в `evidence/operator.txt`: 0,55; 1,71; 2,20; 4,25 с); S3 остановлен → `queued`, затем `ready`; таймаут/память рендера и пропавший оригинал → `processing_failed`, нечитаемое изображение → `invalid_image`, оба с `attempt 1`; 200 случайных задержек лежат в `[d/2, d)` | `evidence/level4.json`, `evidence/student-tests.txt` |
| **4.3** DLQ, реестр `failed` и безопасный явный replay; повтор не исполняет дубль успешной job | `make level4` (`replay_failed`, `malformed_message_dead_lettered`, `failed_retention`); `make failed`, `make replay ID=…`, `make dlq`; `test_recovery.py` | `retry_exhausted` → `replay` → `{"result": "replayed"}` → `ready` (журнал `… failed, replayed, claimed, done`); повторный replay `ready` → `{"result": "noop"}`, снимок вариантов равен, событие `replay_noop`; staging `failed` хранится до retention, после него replay → `expired`; сообщение не по схеме → DLQ, видно `make dlq` без извлечения | `evidence/level4.json`, `evidence/operator.txt` |
| **4.4** Остановка worker после записи объекта, но до `ack`; повтор завершает тот же результат | `make level4` (`crash_after_s3_before_commit`, `crash_after_commit_before_ack`), `test_recovery.py` | `after_s3_write_before_commit` → exit 137, вложение `processing`, строк вариантов 0; после запуска worker — `ready` на попытке 2, те же ключи объектов; `after_commit_before_ack` → exit 137, вложение уже `ready`; redelivery → `duplicate_noop`, строки вариантов до и после равны | `evidence/level4.json`, `evidence/student-tests.txt` |
| **4.4** Timeout/lease для зависшего `processing`, ограниченная конкуренция/prefetch, очистка staging после фиксации | `make level4` (`lease_expiry_fencing`), `make topology`, инвариант `no_orphans`; `test_recovery.py` | `stall_after_claim` (15 с при аренде 5 с): журнал `claimed(1), lease_expired(2), claimed(2), done(2), fenced(1)`, снимок результата до и после пробуждения равен; долгий рендер (2,5 с при аренде 1 с) продлевает аренду и не возвращается relay; consumer `prefetch_count=2` = `WORKER_CONCURRENCY` = слоты рендера; staging `ready` убран (`staging_left` пуст), `failed` — по retention | `evidence/level4.json`, `evidence/topology.txt` |
| Инварианты suite уровня «4» | `make suite-preflight && make level4` | 17/17 сценариев PASS за 6 мин 14 с; `terminal`, `single_effect`, `no_ready_rollback`, `monotonic_publication`, `bytes_match_metadata` (28 `ready`), `bounded_attempts`, `no_orphans` (очередь `[0, 0]`, в DLQ ровно ожидаемое письмо), `no_lost_202` (33 из 33) — PASS | `evidence/level4.json` |
| Сценарий защиты п. 4 | `make level4` или по одному: `pipeline_suite.py --only crash_after_commit_before_ack,crash_commit_publish,replay_failed` | crash после side effect до `ack`, разрыв `COMMIT`/publish и replay `failed` — строки 4.2–4.4 | `evidence/level4.json` |
| Трек 2 | — | заполняется изменением трека 2: versioned pipeline, fault-injection suite одной командой, инварианты | — |
## Эксперименты и отказы
Стенд: 2 реплики `api` (1 CPU, 512 MiB), worker 2 CPU / 1 GiB, relay 0.5 CPU / 192 MiB, RabbitMQ 1 CPU /
512 MiB, RustFS 1 CPU / 512 MiB, PostgreSQL 2 CPU / 1 GiB; Docker Desktop VM 16 CPU, 7.65 ГиБ, параллельно
работали стенды других лаб. Данные — синтетические пользователи и fixture `sample.png` (111 817 B). Сценарии
suite идут с `infra/compose.faults.yaml` у relay и worker (аренда 5 с, база backoff 1 с, опрос outbox 0,5 с).
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| Worker остановлен, upload и сообщение | `202 queued`, `409` на `/content`, сообщения работают, задание в очереди | так и есть; `messages_ready=1` | `ready` через 0,2 с после запуска worker; потерь нет |
| Рестарт обеих реплик API и relay после `202` | задание не теряется и не дублируется | в очереди одна копия до и после | потерь нет |
| `scripts/broker.sh restart` при остановленном worker | durable сообщение переживает рестарт | `[1, 0]` до и после, имя узла `rabbit@broker` неизменно | брокер healthy за ~9 с; потерь нет |
| Повторная доставка выполненной job (`rabbitmqadmin publish` той же копии) | no-op с `ack`, результат не меняется | `duplicate_noop`, снимок вариантов равен | — |
| S3 остановлен во время обработки | временная ошибка, `queued`, повтор | `attempt 2`, статус `queued`; после возврата S3 — `ready` | сценарий 13,8 с; потерь нет |
| Каждая попытка — временная ошибка (`FAULT_POINT=transient_error`) | ровно 5 попыток, `failed retry_exhausted` | `attempt 5`, `retry_exhausted`, `409` на `/content` и в сообщении | 22,9 с до `failed`; бесконечного повтора нет |
| Битый PNG (обрезан после IDAT) | `415` на входе или `invalid_image` без повторов | `415` на входе (API проверяет файл до `202`); с подменой staging в тесте — `invalid_image`, `attempt 1` | — |
| Сообщение не по `jobs.schema.json` | в DLQ, worker жив | DLQ +1, очередь пуста (`test_rabbitmq.py`) | — |
| Аренда истекла, старый держатель пытается зафиксировать | relay возвращает задание, старый — `fenced` | `queued`, `attempt 2`, затем `ready`; старая фиксация → `fenced`, вариантов не добавила (`test_pipeline.py`) | следующий проход relay (5 с) |
| Брокер не подтвердил публикацию | строка outbox остаётся | `published_at IS NULL`, после восстановления публикуется (`test_pipeline.py`) | следующий опрос; потерь нет |
| SIGTERM worker и relay | выход ≤10 с, код 0, unacked в очередь | 0,5 с, код 0 | — |
| Перезапуск LB, API, relay, worker, PostgreSQL, Valkey, S3, broker с volumes | данные, сессия, вложение и байты на месте | `PASS: persistence …`, все `StartedAt` новее (повтор на `0b85edf`) | хранилища 00:33:04, relay и worker 00:33:22; потерь нет |
| Остановка реплики API под записью | запись ≤10 с, без дублей | 3,0 с, 133 записи, 0 ошибок (повтор на `0b85edf`) | ≤3 с; потерь нет |
| **4** Relay падает после взятия строки outbox, до publish (`after_commit_before_publish`) | exit 137, строка не опубликована, очередь пуста; после рестарта relay — `ready` без нового задания | exit 137, `published=false`, `[0, 0]`, `queued`; после запуска relay — `ready`, тот же `job_id` | сценарий 17,5 с вместе с рестартом; потерь нет |
| **4** Relay падает после publish, до записи `published_at` | повторная публикация, дубль гасится | exit 137, строка не помечена; журнал `enqueued, claimed, done, duplicate_noop` | 15,7 с; потерь и второго эффекта нет |
| **4** Worker падает после записи объектов в S3, до `COMMIT` | строк нет; повтор пишет те же ключи и фиксирует | exit 137, `processing`, 0 строк вариантов; `ready` на попытке 2, варианты совпадают с метаданными | 23,1 с (аренда 5 с + проход relay); потерь нет |
| **4** Worker падает после `COMMIT`, до `ack` | `ready` уже есть; redelivery — no-op | exit 137, `ready`; redelivery → `duplicate_noop`, строки вариантов равны | 17,5 с; потерь нет |
| **4** Worker завис после захвата на 15 с при аренде 5 с | relay возвращает задание, вторая попытка → `ready`, старый держатель — `fenced` | `claimed(1), lease_expired(2), claimed(2), done(2), fenced(1)`; снимок до и после пробуждения равен | 40,0 с (включая ожидание пробуждения); перезаписи нет |
| **4** Рендер 40 Мпикс при `RENDER_TIMEOUT_SECONDS=0,5` и при `RENDER_MEMORY_MB=200` | `failed processing_failed` без повторов, worker жив | оба — `processing_failed`, `attempt 1`, контейнер `running`; со штатными пределами — `ready`, пик 379 MiB из 1024 MiB | 27,8 с на три загрузки |
| **4** Каждая попытка — временная ошибка, задержки | задержки в `[d/2, d]`, разные доли | 0,69; 1,74; 2,83; 7,55 с при базе 1 с | 35,2 с до `failed` |
| **4** Replay `failed`, затем повторный replay | `failed → queued → ready`; повтор для `ready` — `noop` без публикации | `replayed` → `ready` за <6 с; `noop`, событие `replay_noop`, варианты не изменились | 44,6 с вместе с исчерпанием попыток |
| **4** Retention staging `failed` (1 с в сценарии) | staging хранится до retention, затем удаляется; replay → `expired` | staging был, удалён, `{"result": "expired"}`, статус `failed` не изменился | 41,8 с вместе с исчерпанием попыток |
## Ограничения и следующие шаги
- Один Docker-host: RabbitMQ — один узел quorum-очереди без репликации, PostgreSQL и RustFS — единственные точки
отказа; это не HA. Отказы — остановка и `SIGKILL` процессов и контейнеров, не сеть и не диск.
- Это не exactly-once: брокер доставляет повторно (окна 3 и 5, redelivery после рестарта), дубли гасит захват
задания и ключ эффекта. Publisher confirm подтверждает запись в очередь, consumer ack — устойчивый результат.
- Relay держит транзакцию outbox на время публикации пачки; при недоступном брокере он каждую секунду ждёт
таймаут соединения, API это не затрагивает, outbox растёт. LISTEN/NOTIFY не введён: опроса раз в секунду хватает
бюджету smoke.
- Ошибка PostgreSQL на захвате возвращает сообщение в очередь; после 10 возвратов оно уходит в DLQ, а задание
остаётся `queued` с опубликованной строкой outbox. Replay работает только для `failed` (для `queued` — `noop`):
такое сообщение оператор видит `make dlq` и возвращает из DLQ средствами брокера; автоматической
переопубликации «застрявших» `queued` нет.
- Задание, прерванное SIGTERM посреди рендера, вернётся только по истечении аренды (до 60 с): аренда при штатной
остановке не освобождается. Эффекта и дубля нет, только задержка.
- `RLIMIT_AS` применяется только в Linux: в собственных тестах на macOS проверяются таймаут, падение процесса рендера
и `MemoryError`, а сам предел памяти — сценарием `worker_limits` на стенде.
- Replay сбрасывает `attempt` в 1: оператор может повторять неудачную работу сколько угодно раз, каждый раз с записью
`replayed` и именем оператора в журнале.
- `optimized` теряет прозрачность (компоновка на белый, как у остальных вариантов).
- `object_key` лабы 4 в `attachments` оставлен nullable до contract-миграции.
- Нестабильность, найденная прогоном: проверка лабы 2 `test_valkey_restart_keeps_cache_and_revocations` один раз
увидела на 1 ключ меньше после рестарта Valkey (между подсчётами истёк TTL кэшированной сессии); повтор — PASS.
- Подтверждено прогонами: всё в таблице доказательств уровней «3» и «4». Трек 2 — следующее изменение.