# Отчёт — лабораторная 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 && 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= # явный 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=/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/ ──────────────▶ 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/, PUT variants//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/`, `originals/`, `variants//<версия>/<имя>-.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/` → одна транзакция: `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/`, рендер трёх вариантов в процессе рендера, `CopyObject staging → originals/`, `PutObject variants//1/<имя>-.`; пока задача идёт, аренда продлевается раз в `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/`, задание и строка 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/` побайтно равен загруженному; 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 — следующее изменение.