исправление

This commit is contained in:
2026-10-26 19:40:34 +03:00
parent a591243d80
commit aaab3ac8b2
37 changed files with 1749 additions and 389 deletions
+6 -2
View File
@@ -17,14 +17,14 @@ export BASE_URL_TTL
balancing idempotency failover persistence failover-metrics rolling-update load-profile check-stack report-tables \
attachments attachment-failover failure-s3 s3-checks upload-memory cleanup s3-bootstrap \
worker-stop worker-start worker-outage redelivery outbox-crash worker-crash retry-replay lease concurrency \
staging-cleanup imaging-test jobs failed job replay queues
staging-cleanup cleanup-race imaging-test jobs failed job replay queues
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@echo "secrets/up/down/ps/logs/restore: stand; student-test, race, expiry, failure-valkey, failure-postgres, failure-valkey-pause, db-test, explain, demo, cache-stats: own checks (lab2)"
@echo "balancing, idempotency, failover, persistence, failover-metrics, rolling-update, load-profile, check-stack, report-tables: own checks (lab3)"
@echo "attachments, attachment-failover, failure-s3, s3-checks, upload-memory, cleanup, s3-bootstrap: own checks (lab4)"
@echo "worker-stop, worker-start, worker-outage, redelivery, outbox-crash, worker-crash, retry-replay, lease, concurrency, staging-cleanup, imaging-test: own checks (lab5)"
@echo "worker-stop, worker-start, worker-outage, redelivery, outbox-crash, worker-crash, retry-replay, lease, concurrency, staging-cleanup, cleanup-race, imaging-test: own checks (lab5)"
@echo "jobs, failed, job ID=..., replay ID=..., queues: operator commands (lab5)"
check:
@@ -222,6 +222,10 @@ concurrency:
staging-cleanup:
$(PYTHON) student-tests/staging_cleanup.py
# Замечание к MR: уборщик не удаляет текущую работу — replay, загрузка и обработка во время уборки.
cleanup-race:
$(PYTHON) student-tests/cleanup_race.py
# Варианты картинок и лимиты worker — проверки внутри образа (там Pillow).
imaging-test:
docker compose --profile tools run --rm imaging-test
+29 -17
View File
@@ -2,7 +2,7 @@
- Автор, группа: Гаджиев Нухбала, БВТ2303
- Целевая оценка; выбранный трек 5, если нужен: 4, трек 5 не выбран
- Commit/PR: TODO после публикации
- Commit/PR: https://gitea.privcloud.tech/mtusi2026/mtusi2026lab5/pulls/4
- Использованные источники, библиотеки и помощь ИИ: всё из lab4 (FastAPI, uvicorn, pydantic, psycopg 3, argon2-cffi, valkey-py, boto3, Pillow 13.0.0, HAProxy 3.2, PostgreSQL 17, Valkey 8.1, SeaweedFS 4.44) и новое: RabbitMQ 4.2.9 (брокер), pika 1.4.4 (клиент RabbitMQ), simplejpeg 1.9.0 и numpy 2.3.5 (строгая проверка JPEG через libjpeg-turbo). Документация: RabbitMQ (Reliability Guide, Consumer Acknowledgements and Publisher Confirms, Quorum Queues, Dead Letter Exchanges, Configuration), pika (BlockingConnection, add_callback_threadsafe), PostgreSQL (SELECT … FOR UPDATE SKIP LOCKED), Pillow (draft, resize с reducing_gap, ImageOps.exif_transpose), спецификация PNG (блоки, фильтры строк, Adam7). ИИ использовался только как вспомогательный ресурс: для оценки решения, написания комментариев к коду и составления текстовых документов.
## Запуск из чистого clone
@@ -25,11 +25,11 @@ make restore PYTHON=python
make test-persistence ACTION_SCRIPT=scripts/restart.cmd PYTHON=python # Linux/macOS: scripts/restart.sh
```
Свои проверки lab5: `make worker-outage`, `redelivery`, `outbox-crash`, `worker-crash`, `retry-replay`, `lease`, `concurrency`, `staging-cleanup`, `imaging-test`, `db-test` (на Windows с `PYTHON=python`). Проверки lab2–lab4 остались: `make student-test`, `attachments`, `attachment-failover`, `failure-s3`, `s3-checks`, `failover`, `persistence`, `check-stack` и др. Все HTTP-проверки идут через балансировщик `http://127.0.0.1:8080`.
Свои проверки lab5: `make worker-outage`, `redelivery`, `outbox-crash`, `worker-crash`, `retry-replay`, `lease`, `concurrency`, `staging-cleanup`, `cleanup-race`, `imaging-test`, `db-test` (на Windows с `PYTHON=python`). Проверки lab2–lab4 остались: `make student-test`, `attachments`, `attachment-failover`, `failure-s3`, `s3-checks`, `failover`, `persistence`, `check-stack` и др. Все HTTP-проверки идут через балансировщик `http://127.0.0.1:8080`.
Bootstrap. Схему БД создаёт одноразовый `migrate` (миграции 001–006), bucket — одноразовый `s3-init`. Пользователя, пароль, vhost и права RabbitMQ брокер берёт из файла-секрета `secrets/rabbitmq_credentials.conf` при первом запуске с пустым volume; exchange и очереди объявляют relay и worker при подключении (повторное объявление с теми же параметрами ничего не меняет). Всё повторяемо: `docker compose run --rm migrate`, `make s3-bootstrap`. Действие оператора одно: один раз создать секреты.
Остановить worker для демонстрации: `make worker-stop`, запустить: `make worker-start`. Команды оператора: `make jobs` (сколько заданий в каждом состоянии), `make failed` (реестр failed), `make job ID=<attachment_id>` (задание, журнал, outbox, варианты), `make replay ID=<attachment_id>`, `make queues` (очереди брокера и DLQ), `make cleanup ARGS=--dry-run`.
Остановить worker для демонстрации: `make worker-stop`, запустить: `make worker-start`. Команды оператора: `make jobs` (сколько заданий в каждом состоянии), `make failed` (реестр failed), `make job ID=<attachment_id>` (задание, журнал, outbox, варианты), `make replay ID=<attachment_id>`, `make queues` (очереди брокера и DLQ), `make cleanup ARGS=--dry-run` (или `ARGS="--attachment <id>"` — только одно вложение).
Безопасная остановка: `make down` (volumes `pgdata`, `s3data`, `rabbitmqdata` остаются). Намеренное удаление учебных данных: `docker compose down -v`, затем `rm -rf secrets` и снова `sh scripts/init-secrets.sh` (пароль RabbitMQ задаётся только при первом запуске, поэтому секреты и volume удаляются вместе).
@@ -61,9 +61,9 @@ migrate, s3-init — одноразовые; сети: edge (lb <-> api), backen
Приём (`src/messenger/attachments.py`) и что сохранено в момент 202:
1. Проверки как в lab4: токен, участник чата, `filename`, `Content-Type`, размер до и во время чтения, тип по первым байтам, пиксели по заголовку до распаковки.
2. Структура файла без декодирования пикселей (`images.py`): у PNG — блоки, CRC, палитра, tRNS, ничего после IEND, распаковка IDAT порциями по 1 МиБ с подсчётом байт и проверкой типа фильтра строк; у JPEG — маркеры, один кадр SOF, непустые сканы, EOI. Заведомо битые — 415.
2. Структура файла без декодирования пикселей (`images.py`): у PNG — блоки, CRC, палитра, tRNS, ничего после IEND, распаковка IDAT порциями по 1 МиБ с подсчётом байт и проверкой типа фильтра строк. У JPEG — всё, что строгий декодер worker (libjpeg-turbo) проверяет по маркерам и заголовкам: известные маркеры и длины сегментов, кадр SOF, таблицы DQT/DHT (коды Хаффмана помещаются в свою длину), каждый компонент скана SOS есть в SOF и не повторяется, параметры сканов, порядок и число маркеров RST, версия JFIF, код Adobe, схема субдискретизации, которую понимает декодер, EOI. Заведомо битые — 415. В worker остаются только ошибки внутри сжатых данных скана: их не найти без декодирования каждого блока (failed, `invalid_image`).
3. PUT оригинала в `staging/<id>` (ключ назначает сервер).
4. Одна транзакция: вложение `queued` + задание `attempt=1` + строка outbox (тело сообщения) + запись в журнал. После COMMIT — 202 `queued`. Сам ответ не ждёт брокера.
4. Одна транзакция: вложение `queued` + задание `attempt=1` + строка outbox (тело сообщения) + запись в журнал. После COMMIT — 202 `queued`. Сам ответ не ждёт брокера. Шаги 3–4 идут под advisory-блокировкой ID вложения: пока загрузка не закоммичена, уборщик её staging не трогает.
Outbox (`relay.py`, поток в каждой реплике API). Relay берёт неотправленные строки с `FOR UPDATE SKIP LOCKED` (реплики не мешают друг другу), публикует в брокер с publisher confirm и только потом ставит `published_at`. Если API упал после COMMIT, строку отправит relay другой реплики или этой после перезапуска. Если relay упал после подтверждения брокера, строка уйдёт ещё раз (дубль, это нормально при at-least-once). Брокер недоступен — загрузки по-прежнему 202, строки ждут в PostgreSQL. Поэтому брокер не входит в readiness, а S3 входит: без S3 не принять файл в staging.
@@ -73,7 +73,7 @@ Worker (`worker.py`). Проверяет сообщение по схеме (н
Состояния (наружу как есть): `queued` → `processing` (lease) → `ready` / `failed`; временная ошибка или истёкший lease → снова `queued` со следующей попыткой; `failed` → `queued` только по replay оператора. Ключ эффекта `(attachment_id, pipeline_version, variant)` — первичный ключ `attachment_variants` и он же ключ объекта в S3: повтор не создаёт второй набор. Ready не откатывается назад: все переходы обновляют вложение только из `queued`/`processing`.
Повторы и ошибки. Постоянные (`invalid_image`, `image_too_large`, `source_missing`, `source_corrupted`) — failed сразу, сообщение в DLQ. Временные (`storage_unavailable`, `processing_timeout`, `worker_crashed`, `lease_expired`, `processing_failed`) — следующая попытка через backoff с jitter: пауза случайная в [d/2, d], d = min(60 с, 2 с · 2^(n−1)). Всего попыток `JOB_MAX_ATTEMPTS=5`, потом failed с `retry_exhausted` и DLQ. Реестр failed — таблица `attachment_jobs` (`make failed`), журнал — `job_events`. Replay (`make replay ID=...`) переводит только failed в queued с новой попыткой и записью в журнале (кто и что было). Для ready или ещё идущего задания он ничего не делает. Если staging уже удалён (прошло `STAGING_RETENTION_SECONDS`), replay отказывает.
Повторы и ошибки. Постоянные (`invalid_image`, `image_too_large`, `source_missing`, `source_corrupted`) — failed сразу, сообщение в DLQ. Временные (`storage_unavailable`, `processing_timeout`, `worker_crashed`, `lease_expired`, `processing_failed`) — следующая попытка через backoff с jitter: пауза случайная в [d/2, d], d = min(60 с, 2 с · 2^(n−1)). Всего попыток `JOB_MAX_ATTEMPTS=5`, потом failed с `retry_exhausted` и DLQ. Реестр failed — таблица `attachment_jobs` (`make failed`), журнал — `job_events`. Replay (`make replay ID=...`) переводит только failed в queued с новой попыткой и записью в журнале (кто и что было). Для ready или ещё идущего задания он ничего не делает. Если staging уже удалён (прошло `STAGING_RETENTION_SECONDS`), replay отказывает (`source_missing`, тоже с записью в журнале). Всё это одна транзакция под блокировкой строк задания и вложения — тех же, что берёт уборщик.
Lease (`jobs.py`). Захват — жетон и срок `JOB_LEASE_SECONDS=30`. Пока worker жив, он продлевает аренду каждые 10 с, поэтому долгая задача не теряет её. Зависший или мёртвый worker не продлевает, и через 30 с фоновая проверка (`reap`, раз в 5 с) засчитывает попытку как неудачную и назначает следующую. Результат принимается, только если жетон совпадает (fencing): опоздавший worker ничего не перезапишет, а обнаружив потерю lease, бросает работу. Если lease держит прежний запуск того же контейнера (Docker его перезапустил), попытка засчитывается сразу, без ожидания 30 с. Попытка не дольше `JOB_TIMEOUT_SECONDS=60`: дочерний процесс убивается.
@@ -81,9 +81,13 @@ Lease (`jobs.py`). Захват — жетон и срок `JOB_LEASE_SECONDS=30
Лимиты worker. Байты: объект из staging не больше 10 MiB и совпадает с размером и SHA-256 в БД. Пиксели: не больше 40 млн, проверяются до декодирования. Сжатые данные JPEG проверяются строго (libjpeg-turbo, предупреждение = ошибка): Pillow битый скан молча «дорисовывает» серым. Память: дочерний процесс с `RLIMIT_AS = WORKER_MEMORY_LIMIT_MB = 640` МиБ (нехватка → `image_too_large`), контейнер — 1 ГиБ. Время: `JOB_TIMEOUT_SECONDS=60`, потом SIGKILL. Параллельно `WORKER_CONCURRENCY=2` задания, prefetch брокера тоже 2.
Уборка (`cleanup.py`, поток worker раз в 5 мин и `make cleanup`). Нужные объекты: оригиналы и варианты ready, staging заданий в работе, staging failed моложе 24 ч. Остальное удаляется, только если старше grace 15 мин: staging готового (если worker не успел удалить), staging failed после retention, объекты без строки в БД. Есть dry-run.
Уборка (`cleanup.py`, поток worker раз в 5 мин и `make cleanup`). Нужные объекты: оригиналы и варианты ready, ВСЕ объекты вложений в работе (queued, processing: worker может прямо сейчас писать оригинал и варианты), все объекты failed-вложения моложе 24 ч (replay запишет их заново в те же ключи), staging загрузки, которая ещё не закоммичена. Остальное удаляется, только если старше grace 15 мин: staging готового (если worker не успел удалить), объекты failed после retention, объекты без строки в БД. Есть dry-run и уборка одного вложения (`--attachment`). Как уборщик не удаляет текущую работу (замечание к MR): список объектов и снимок ссылок только отбирают кандидатов, а решение по каждому вложению принимается заново под блокировками (`store.cleanup_attachment`): advisory-блокировка ID вложения без ожидания (её держит идущая загрузка — тогда вложение пропускается), затем строки задания и вложения (`FOR NO KEY UPDATE`, тот же порядок, что у worker и replay). У failed-вложения после retention в той же транзакции помечается, что исходника нет (`staging_key = NULL`, запись `staging_expired` в журнале): replay, который ждал блокировку или пришёл позже, безопасно отказывает. Из S3 объекты удаляются уже после COMMIT и только те, что больше никогда не понадобятся, поэтому медленный S3 не держит блокировки, а оборванная сессия БД не открывает окно для гонки.
Что перенесено из lab4: весь код, миграции 001–005, свои тесты, Dockerfile, конфиги HAProxy/Valkey, SeaweedFS и `s3-init`, скрипты. Что изменено: сервисы `broker` и `worker`, volume `rabbitmqdata`, секреты RabbitMQ, миграция 006 (задания, outbox, варианты, журнал), модули `broker.py`, `relay.py`, `jobs.py`, `worker.py`, `sandbox.py`, `imaging.py`, `faults.py`; загрузка 201 → 202; `images.py` — вместо полного декодирования проверка структуры (PNG по спецификации, JPEG по маркерам); `/health/ready` проверяет и S3; уборщик переехал в worker и знает про staging и варианты; hook перезапуска перезапускает ещё брокер и worker.
Что перенесено из lab4: весь код, миграции 001–005, свои тесты, Dockerfile, конфиги HAProxy/Valkey, SeaweedFS и `s3-init`, скрипты. Что изменено: сервисы `broker` и `worker`, volume `rabbitmqdata`, секреты RabbitMQ, миграция 006 (задания, outbox, варианты, журнал), модули `broker.py`, `relay.py`, `jobs.py`, `worker.py`, `sandbox.py`, `imaging.py`, `faults.py`; загрузка 201 → 202; `images.py` — вместо полного декодирования проверка структуры (PNG по спецификации, JPEG по правилам строгого декодера); `/health/ready` проверяет и S3; уборщик переехал в worker и знает про staging и варианты; hook перезапуска перезапускает ещё брокер и worker.
Исправления по замечаниям к MR:
1. Структурно повреждённый JPEG (SOS ссылается на компонент 250, которого нет в SOF) принимался с 202 и только потом становился failed. Причина: у скана проверялась длина, но не связь с кадром. Теперь `images.py` повторяет все проверки заголовков строгого декодера worker (список — в п. 2 «Приёма»), такой файл получает 415. Совпадение с декодером проверено в образе: 800 случайных повреждений заголовков и 8208 комбинаций субдискретизации без расхождений (`make imaging-test`).
2. Уборщик мог удалить staging уже принятого replay: удалял по снимку ссылок без согласования с изменением состояния. Теперь решение принимается под блокировками по текущему состоянию, replay — одна транзакция под теми же блокировками, а staging сначала помечается удалённым в БД (подробно — в абзаце «Уборка»). Тем же механизмом закрыты ещё два окна, которые видны при grace = 0: загрузка между PUT в staging и COMMIT и объекты worker до COMMIT результата. Проверки: `make db-test` (барьеры в настоящей PostgreSQL) и `make cleanup-race` (то же на стенде с точками-паузами).
Переменные (новые; остальные как в lab4, см. `.env.example`):
@@ -123,6 +127,7 @@ Lease (`jobs.py`). Захват — жетон и срок `JOB_LEASE_SECONDS=30
| 3: демонстрация worker остановлен → … → ready; задание переживает рестарт брокера | make worker-outage | 202 → сообщение с вложением → перезапуск API и брокера → worker → ready, thumbnail доступен | evidence/worker-outage.txt |
| 4: crop 128×128 и optimized WebP, параметры качества и удаления метаданных | make attachments; make imaging-test | crop JPEG 128×128, optimized WebP ≤1280; ориентация EXIF, белый фон под прозрачностью; в вариантах нет EXIF/XMP/ICC | evidence/student-test.txt, imaging-test.txt |
| 4: лимиты по байтам, пикселям, времени и памяти worker | make imaging-test; make attachments | 36 Мп RGBA в лимите 640 МиБ — ok, в лимите 200 МиБ — image_too_large; таймаут — процесс убит; лимит пикселей до декодирования; битый скан JPEG — invalid_image; ровно 10 MiB и 40 млн px — ready, на 1 больше — 413 | evidence/imaging-test.txt, student-test.txt |
| Контракт: заведомо повреждённые JPEG — 415 (замечание к MR 1) | make student-test; make imaging-test | пример из замечания (байт i+5 первого SOS = 250) и ещё 26 повреждений заголовков — 415; корректные progressive и с маркерами RST — ready; проверка API совпадает со строгим декодером на 800 случайных повреждениях и 8208 схемах субдискретизации | evidence/student-test.txt, imaging-test.txt |
| 4: transactional outbox, crash между COMMIT и publish, ready без ручного задания | make outbox-crash; make db-test | A: API упал после COMMIT; B: relay упал до publish; C: relay упал после publish — во всех ready, одна попытка, один набор вариантов; D: брокер остановлен — 202, строка ждёт, потом ready | evidence/outbox-crash.txt, db-test.txt |
| 4: backoff с jitter, постоянные и временные ошибки | make retry-replay; make db-test | паузы в [d/2, d] при d = 2, 4, 8, 16 с; битый JPEG — invalid_image сразу, попытка 1 | evidence/retry-replay.txt, db-test.txt |
| 4: DLQ / реестр failed и безопасный явный replay | make retry-replay | failed → DLQ +1 и `jobs failed`; replay failed → ready с записью в журнале; replay ready — noop, нового сообщения нет | evidence/retry-replay.txt |
@@ -130,6 +135,7 @@ Lease (`jobs.py`). Захват — жетон и срок `JOB_LEASE_SECONDS=30
| 4: timeout/lease для зависшего processing | make lease | долгая задача продлевает lease; замороженный worker теряет его, задание забирает второй worker, проснувшийся ничего не перезаписывает | evidence/lease.txt |
| 4: ограниченная конкуренция и prefetch | make concurrency | одновременно не больше 2 заданий в processing и 2 сообщений без ack, остальные ждут в очереди | evidence/concurrency.txt |
| 4: очистка staging после безопасной фиксации | make staging-cleanup | staging удаляется сразу после COMMIT; остатки и «сироты» — после grace; staging failed хранится до retention; dry-run и повтор безопасны | evidence/staging-cleanup.txt |
| Уборка не удаляет текущую работу (замечание к MR 2) | make cleanup-race; make db-test | grace 0: снимок → replay → уборщик: staging не удалён, потом ready (было failed/source_missing); уборщик уже пометил staging удалённым и держит блокировку → replay ждёт её и отказывает source_missing, задание failed; загрузка до COMMIT — пропущена (занято); объекты worker до COMMIT — не удалены | evidence/cleanup-race.txt, db-test.txt |
| Свойства lab4: S3 приватный, права, bootstrap; S3 недоступен | make s3-checks; make failure-s3 | анонимно 403, ключ API не может создать, удалить или открыть bucket; в сообщении брокера только ID; S3 остановлен — реплики не готовы, балансировщик отвечает 503, после запуска файл цел | evidence/s3-checks.txt, failure-s3.txt |
| Выбранный трек 5 | — | не выбран | — |
@@ -152,17 +158,20 @@ Lease (`jobs.py`). Захват — жетон и срок `JOB_LEASE_SECONDS=30
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| `docker compose stop worker`, upload | 202, queued, API работает | 202, queued, /content 409, текст 201 | после `start worker` ready за 3,2 с; потерь нет |
| `docker compose stop worker`, upload | 202, queued, API работает | 202, queued, /content 409, текст 201 | после `start worker` ready за 3,8 с; потерь нет |
| Перезапуск API и брокера с volumes, worker остановлен | задание не теряется | строка outbox отправлена один раз до перезапуска, после запуска worker — ready | потерь нет |
| API падает после COMMIT, до 202 | работа принята | клиент получил 502, вложение ready (строку отправил relay другой реплики) | сразу; потерь нет |
| relay падает до / после publish | задание доходит до ready | до: строка отправлена после перезапуска; после: дубль, duplicate_ignored | секунды (перезапуск контейнера Docker); потерь нет |
| брокер остановлен | загрузки 202, задания ждут | строка outbox не отправлена, после запуска брокера — ready | ready через 6,4 с после запуска брокера |
| брокер остановлен | загрузки 202, задания ждут | строка outbox не отправлена, после запуска брокера — ready | ready через 11,8 с после запуска брокера |
| worker падает после записи в S3 до ack | тот же результат | попытка 2, те же ключи и SHA-256 | секунды (прежний запуск того же контейнера) |
| worker заморожен (`docker pause`) | задание переходит к другому worker | lease истёк, второй worker сделал ready, проснувшийся бросил работу | 31 с после заморозки (JOB_LEASE_SECONDS=30) |
| временная ошибка 2 раза / всегда | повтор с паузой / failed | ready на попытке 3 / failed retry_exhausted после 5 попыток | паузы 1,84 / 2,45 / 6,81 / 15,37 с (диапазоны 1–2, 2–4, 4–8, 8–16 с) |
| `docker compose stop s3` | реплики не готовы, 503 | реплики вне балансировки через 1,0 с, live 200, ready 503, балансировщик отвечает 503 | после `start s3` реплики вернулись через 23,7 с, файл цел |
| остановка одной реплики API (`make failover`) | запросы идут на другую | 119 и 125 успешных записей, 0 ошибок | 5,1 и 5,5 с до первого успешного запроса |
| перезапуск всего стенда (`make persistence`) | данные, файл и токен сохраняются | всё на месте | 44,6 с вместе с ожиданием готовности |
| worker заморожен (`docker pause`) | задание переходит к другому worker | lease истёк, второй worker сделал ready, проснувшийся бросил работу | 33 с после заморозки (JOB_LEASE_SECONDS=30) |
| временная ошибка 2 раза / всегда | повтор с паузой / failed | ready на попытке 3 / failed retry_exhausted после 5 попыток | паузы 1,96 / 2,31 / 5,86 / 13,62 с (диапазоны 1–2, 2–4, 4–8, 8–16 с) |
| `docker compose stop s3` | реплики не готовы, 503 | реплики вне балансировки через 0,9 с, live 200, ready 503, балансировщик отвечает 503 | после `start s3` реплики вернулись через 18,0 с, файл цел |
| остановка одной реплики API (`make failover`) | запросы идут на другую | по 124 успешных записи, 0 ошибок | 4,5 и 4,6 с до первого успешного запроса |
| перезапуск всего стенда (`make persistence`) | данные, файл и токен сохраняются | всё на месте | 49,6 с вместе с ожиданием готовности |
| уборщик прочитал ссылки, затем replay (`make cleanup-race` A) | staging нужен текущей работе | уборщик перепроверил под блокировкой: удалено 0, staging на месте | после запуска worker — ready; потерь нет |
| уборщик решил удалить staging (пометил в БД, COMMIT ещё нет), в это время replay (B) | безопасный отказ replay | replay ждал блокировку 8,0 с (пауза уборщика в тесте), отказ source_missing, задание failed, журнал: staging_expired → replay_refused | работа не потеряна: её и не было (retention истёк) |
| уборка во время загрузки, до COMMIT (C) и во время обработки, до COMMIT (D) | ничего не удаляется | C: вложение пропущено как занятое; D: 4 объекта оставлены (processing) | загрузка — 202 → ready; обработка — ready, SHA-256 совпадают |
## Ограничения и следующие шаги
@@ -170,7 +179,10 @@ Lease (`jobs.py`). Захват — жетон и срок `JOB_LEASE_SECONDS=30
- At-least-once, а не exactly-once: дубли бывают, и это нормально (relay упал после publish, worker упал до ack). Защита — состояние задания в БД, ключ эффекта и жетон lease.
- Readiness зависит от S3: пока S3 недоступен, не работает и текстовая часть API (как при отказе PostgreSQL). Это сознательный выбор: без S3 нельзя принять файл в staging, а это обязательный путь. Брокер и worker на readiness не влияют.
- После падения worker задание ждёт до 30 с (срок lease), если упал не прежний запуск того же контейнера, а другой worker. Меньший lease быстрее восстанавливает работу, но чаще отбирает задание у медленного worker.
- Точки отказа (`faults.py`) включены только на учебном стенде (`FAULTS_ENABLED=1`) и срабатывают по файлу внутри контейнера; в рабочей среде переменной нет.
- Точки отказа и точки-паузы (`faults.py`) включены только на учебном стенде (`FAULTS_ENABLED=1`) и срабатывают по файлу внутри контейнера; в рабочей среде переменной нет.
- JPEG со схемами субдискретизации, которых не понимает декодер worker (TurboJPEG): например, 4:4:1 или CMYK 4:2:2 — отклоняются 415 как неподдерживаемые, хотя формально корректны. Поддерживаются 4:4:4, 4:2:2, 4:2:0, 4:4:0, 4:1:1 и оттенки серого.
- Загрузка держит соединение с БД, пока пишет файл в staging (до 6 с, лимит операции S3). Replay ждёт блокировку вложения до 20 с (её коротко берут уборщик и worker), потом отвечает busy.
- Остатки неудачной попытки failed-вложения (оригинал и варианты в S3) лежат до конца retention (24 ч): раньше их удалять нельзя, иначе replay может потерять только что записанные объекты.
- Цветовой профиль ICC в варианты не переносится. Анимированные PNG обрабатываются по первому кадру. JPEG с данными после маркера конца принимается (так устроены многие фото с телефона), варианты из него делаются заново.
- Вложения lab4 (ready без вариантов) остаются ready, их варианты — 404. Переобработка старых вложений новой версией pipeline — это трек 2 на «5».
- Пользователь RabbitMQ один на API и worker (права только на `attachments*`). Отдельные пользователи и mTLS — lab7.
- Пользователь RabbitMQ один на API и worker (права только на `attachments*`). Отдельные пользователи и mTLS — lab7.
+24 -24
View File
@@ -1,29 +1,29 @@
python student-tests/attachment_failover.py
uploaded 111817 bytes -> 202 queued, sha256 99ea7533c441f79c..., served by api replica b0db3e40abfe
uploaded 111817 bytes -> 202 queued, sha256 99ea7533c441f79c..., served by api replica 48dc392933dc
SERVICE CONTAINER STATE STARTED AT (UTC)
api b0db3e40abfe running (healthy) 2026-10-25T18:23:36.991
api ef44b0d4c0a1 running (healthy) 2026-10-25T18:23:36.756
broker 9f909ed7ecea running (healthy) 2026-10-25T18:23:53.670
lb 8be67a2e86b7 running (healthy) 2026-10-25T18:20:04.043
migrate e6c2c825d38d exited 2026-10-25T18:28:07.167
postgres d2bfd48385f1 running (healthy) 2026-10-25T18:19:54.204
s3 892c7ca290f2 running (healthy) 2026-10-25T18:19:54.206
s3-init 08c2e7925d67 exited 2026-10-25T18:28:07.169
valkey 4e223cb9301e running (healthy) 2026-10-25T18:19:54.202
worker d9eced386d93 running (healthy) 2026-10-25T18:28:09.870
stopped b0db3e40abfe (docker stop) right after 202; HAProxy: api1 DOWN, api2 UP
api 48dc392933dc running (healthy) 2026-10-26T16:18:45.196
api c1b7e1ab5673 running (healthy) 2026-10-26T16:18:45.657
broker 9f909ed7ecea running (healthy) 2026-10-26T16:19:00.163
lb 8be67a2e86b7 running (healthy) 2026-10-26T16:15:42.154
migrate a5a9934b4d6b exited 2026-10-26T16:23:38.842
postgres d2bfd48385f1 running (healthy) 2026-10-26T16:15:17.840
s3 892c7ca290f2 running (healthy) 2026-10-26T16:15:17.826
s3-init deab1aa2b022 exited 2026-10-26T16:23:38.843
valkey 4e223cb9301e running (healthy) 2026-10-26T16:15:17.820
worker 292a36c54a41 running (healthy) 2026-10-26T16:23:41.416
stopped 48dc392933dc (docker stop) right after 202; HAProxy: api1 UP, api2 DOWN
the worker finished the job without that replica: status ready, variants ['thumbnail', 'crop', 'optimized']
downloaded 4 times through ['ef44b0d4c0a1']: same SHA-256 as uploaded
restored b0db3e40abfe; HAProxy: api1 UP, api2 UP
downloaded 4 times through ['c1b7e1ab5673']: same SHA-256 as uploaded
restored 48dc392933dc; HAProxy: api1 UP, api2 UP
SERVICE CONTAINER STATE STARTED AT (UTC)
api b0db3e40abfe running (healthy) 2026-10-25T18:28:33.999
api ef44b0d4c0a1 running (healthy) 2026-10-25T18:23:36.756
broker 9f909ed7ecea running (healthy) 2026-10-25T18:23:53.670
lb 8be67a2e86b7 running (healthy) 2026-10-25T18:20:04.043
migrate e6c2c825d38d exited 2026-10-25T18:28:07.167
postgres d2bfd48385f1 running (healthy) 2026-10-25T18:19:54.204
s3 892c7ca290f2 running (healthy) 2026-10-25T18:19:54.206
s3-init 08c2e7925d67 exited 2026-10-25T18:28:07.169
valkey 4e223cb9301e running (healthy) 2026-10-25T18:19:54.202
worker d9eced386d93 running (healthy) 2026-10-25T18:28:09.870
api 48dc392933dc running (healthy) 2026-10-26T16:24:32.726
api c1b7e1ab5673 running (healthy) 2026-10-26T16:18:45.657
broker 9f909ed7ecea running (healthy) 2026-10-26T16:19:00.163
lb 8be67a2e86b7 running (healthy) 2026-10-26T16:15:42.154
migrate a5a9934b4d6b exited 2026-10-26T16:23:38.842
postgres d2bfd48385f1 running (healthy) 2026-10-26T16:15:17.840
s3 892c7ca290f2 running (healthy) 2026-10-26T16:15:17.826
s3-init deab1aa2b022 exited 2026-10-26T16:23:38.843
valkey 4e223cb9301e running (healthy) 2026-10-26T16:15:17.820
worker 292a36c54a41 running (healthy) 2026-10-26T16:23:41.416
PASS: the replica that accepted the upload was stopped right after 202; the job still became ready and another replica returned the same bytes (the original lives in S3, not on the replica)
+14
View File
@@ -0,0 +1,14 @@
python student-tests/cleanup_race.py
A. failed b2299717-daa4-4704-afd1-19efe898e821 (retention expired); the janitor read the references and stopped
operator replay while the janitor waits -> {'result': 'queued', 'attempt': 2, 'previous_error': 'retry_exhausted'}
janitor continued: deleted 0, re-checked under the lock -> kept {'current_work': 1}; staging/b2299717... is still in S3
B. failed 6c7228dc-9d9f-4b3c-9f3d-aa6692124418 (retention expired); the janitor holds the lock: staging marked deleted, no COMMIT yet
replay waited 8.0 s for the lock -> refused (source_missing); job stays failed; journal: staging_expired -> replay_refused
A: worker started -> ready with ['thumbnail', 'crop', 'optimized'] (before the fix: failed / source_missing)
C. upload e0578869-000a-4a70-b43b-ab12f6d5ff49: staging written, no row in the database yet (API paused before COMMIT)
janitor (grace 0): skipped_busy 1, deleted 0 — the upload holds the attachment lock
upload -> 202, then ready with 3 variants
D. d4abfa4b-af5e-4208-8d4e-f69a1783891b: worker wrote the original and 3 variants, COMMIT not yet (status processing)
janitor (grace 0): the snapshot marked the original and 3 variants as unreferenced; re-checked under the lock -> kept {'current_work': 4}, deleted 0
worker committed -> ready; the original and all variants download with the same SHA-256
PASS: the janitor re-checks the state under the attachment lock before deleting: a replay accepted after its snapshot keeps the staging (A), a replay after the janitor's decision is refused safely (B), an upload in progress (C) and objects of a job in processing (D) are not deleted
+10 -10
View File
@@ -1,13 +1,13 @@
python student-tests/concurrency.py
time s | processing (DB) | unacked (broker) | waiting in queue
2.5 | 2 | 0 | 0
7.1 | 2 | 2 | 4
10.4 | 2 | 2 | 2
13.4 | 2 | 2 | 2
16.1 | 2 | 2 | 2
20.5 | 2 | 2 | 0
23.3 | 2 | 2 | 0
26.5 | 2 | 2 | 0
29.4 | 0 | 0 | 0
peak: 2 jobs in processing, 2 unacknowledged messages, up to 4 waiting in the queue; all 6 ready after 29.4 s
2.4 | 2 | 0 | 0
5.0 | 2 | 2 | 4
7.6 | 2 | 2 | 4
11.6 | 2 | 2 | 4
14.3 | 2 | 2 | 2
17.1 | 2 | 2 | 2
19.7 | 2 | 2 | 0
23.8 | 2 | 2 | 0
26.5 | 0 | 2 | 0
peak: 2 jobs in processing, 2 unacknowledged messages, up to 4 waiting in the queue; all 6 ready after 26.5 s
PASS: at most WORKER_CONCURRENCY=2 jobs run at once and the broker gives the worker at most prefetch=2 messages; the rest wait in the durable queue
+30 -12
View File
@@ -2,8 +2,26 @@ docker compose --profile tools run --rm db-test
Container mtusi-lab5-postgres-1 Running
Container mtusi-lab5-postgres-1 Waiting
Container mtusi-lab5-postgres-1 Healthy
Container mtusi-lab5-db-test-run-436c3e33e3cf Creating
Container mtusi-lab5-db-test-run-436c3e33e3cf Created
Container mtusi-lab5-db-test-run-dcea39c16e25 Creating
Container mtusi-lab5-db-test-run-dcea39c16e25 Created
test_1_replay_after_snapshot_keeps_staging (test_cleanup.CleanupRaceTest.test_1_replay_after_snapshot_keeps_staging) ...
snapshot -> replay (queued) -> cleanup: kept [('staging/224e34a0-91da-415f-acc4-ecc686b36842', 'current_work')], nothing deleted
ok
test_2_cleanup_first_then_replay_waits_and_refuses (test_cleanup.CleanupRaceTest.test_2_cleanup_first_then_replay_waits_and_refuses) ...
cleanup marked the staging deleted, holds the lock -> replay waited 1 s+ -> refused (source_missing); job stays failed; journal: staging_expired, replay_refused
ok
test_3_replay_first_then_cleanup_waits_and_keeps (test_cleanup.CleanupRaceTest.test_3_replay_first_then_cleanup_waits_and_keeps) ... ok
test_4_upload_in_progress_is_skipped (test_cleanup.CleanupRaceTest.test_4_upload_in_progress_is_skipped)
replay holds the lock -> cleanup waited -> kept [('staging/34b4b519-0cbc-4edb-baab-e86b337fdf38', 'current_work')]
...
upload between PUT and COMMIT -> cleanup skipped it (busy); after COMMIT -> current work, kept
ok
test_5_objects_of_processing_job_are_kept (test_cleanup.CleanupRaceTest.test_5_objects_of_processing_job_are_kept) ... ok
test_6_regular_cleanup_still_works (test_cleanup.CleanupRaceTest.test_6_regular_cleanup_still_works) ...
processing job (worker writes the original and variants before COMMIT) -> all 3 objects kept
orphan, staging after ready, objects of a failed attachment after retention -> deleted; published original and variants, a failed attachment within retention -> kept; dry-run deletes nothing
ok
test_backoff_bounds (test_jobs.JobsIntegrationTest.test_backoff_bounds) ... ok
test_claim_once_and_concurrent_claims (test_jobs.JobsIntegrationTest.test_claim_once_and_concurrent_claims) ...
10 concurrent claims of one job: 1 claimed, 9 in_progress
@@ -15,29 +33,29 @@ test_permanent_error_fails_at_once (test_jobs.JobsIntegrationTest.test_permanent
test_replay_rules (test_jobs.JobsIntegrationTest.test_replay_rules) ... ok
test_retry_backoff_then_exhausted (test_jobs.JobsIntegrationTest.test_retry_backoff_then_exhausted) ... ok
test_upload_creates_job_and_outbox_in_one_transaction (test_jobs.JobsIntegrationTest.test_upload_creates_job_and_outbox_in_one_transaction) ... ok
test_concurrent_registration_has_one_winner (test_store.StoreIntegrationTest.test_concurrent_registration_has_one_winner) ... ok
test_concurrent_same_idempotency_key_creates_one_row (test_store.StoreIntegrationTest.test_concurrent_same_idempotency_key_creates_one_row) ...
test_concurrent_registration_has_one_winner (test_store.StoreIntegrationTest.test_concurrent_registration_has_one_winner) ...
20 параллельных create_user: 1 создан, 19 получили Conflict (409)
ok
test_create_chat_rolls_back_when_failing_midway (test_store.StoreIntegrationTest.test_create_chat_rolls_back_when_failing_midway) ...
test_concurrent_same_idempotency_key_creates_one_row (test_store.StoreIntegrationTest.test_concurrent_same_idempotency_key_creates_one_row) ...
20 одновременных add_message с одним ключом: 1 строка, 1 новое + 19 повторов с тем же сообщением
ok
test_create_chat_rolls_back_when_failing_midway (test_store.StoreIntegrationTest.test_create_chat_rolls_back_when_failing_midway) ... ok
test_database_rejects_message_from_non_member (test_store.StoreIntegrationTest.test_database_rejects_message_from_non_member) ...
чат с несуществующим участником: транзакция откатилась, строк chats/chat_members не осталось
ok
test_database_rejects_message_from_non_member (test_store.StoreIntegrationTest.test_database_rejects_message_from_non_member) ...
INSERT сообщения от не-участника напрямую в БД: ForeignKeyViolation
ok
test_migrations_rerun_is_noop (test_store.StoreIntegrationTest.test_migrations_rerun_is_noop) ...
test_migrations_rerun_is_noop (test_store.StoreIntegrationTest.test_migrations_rerun_is_noop) ... ok
test_old_version_insert_without_key_still_works (test_store.StoreIntegrationTest.test_old_version_insert_without_key_still_works) ...
schema_migrations: ['001_core', '002_sessions', '003_text_as_bytes', '004_message_idempotency', '005_attachments', '006_jobs']; повторный migrate() ничего не применил
ok
test_old_version_insert_without_key_still_works (test_store.StoreIntegrationTest.test_old_version_insert_without_key_still_works) ...
INSERT как в lab2 (без ключа) после миграции 004 работает: старая версия совместима со схемой
ok
test_same_key_other_body_is_conflict (test_store.StoreIntegrationTest.test_same_key_other_body_is_conflict) ...
тот же ключ с другим телом: Conflict (409), в базе по-прежнему одна строка
ok
----------------------------------------------------------------------
Ran 16 tests in 0.624s
Ran 22 tests in 2.833s
OK
+47 -47
View File
@@ -1,64 +1,64 @@
python student-tests/run_failover.py
hook: scripts/stop-one.cmd; api replicas: ['b0db3e40abfe', 'ef44b0d4c0a1']
hook: scripts/stop-one.cmd; api replicas: ['48dc392933dc', 'c1b7e1ab5673']
=== run 1: containers before (HAProxy: api1 UP, api2 UP)
SERVICE CONTAINER STATE STARTED AT (UTC)
api b0db3e40abfe running (healthy) 2026-10-25T18:28:33.999
api ef44b0d4c0a1 running (healthy) 2026-10-25T18:23:36.756
broker 9f909ed7ecea running (healthy) 2026-10-25T18:23:53.670
lb 8be67a2e86b7 running (healthy) 2026-10-25T18:20:04.043
migrate e6c2c825d38d exited 2026-10-25T18:28:07.167
postgres d2bfd48385f1 running (healthy) 2026-10-25T18:19:54.204
s3 892c7ca290f2 running (healthy) 2026-10-25T18:29:00.995
s3-init 08c2e7925d67 exited 2026-10-25T18:28:07.169
valkey 4e223cb9301e running (healthy) 2026-10-25T18:19:54.202
worker d9eced386d93 running (healthy) 2026-10-25T18:28:09.870
api 48dc392933dc running (healthy) 2026-10-26T16:24:32.726
api c1b7e1ab5673 running (healthy) 2026-10-26T16:18:45.657
broker 9f909ed7ecea running (healthy) 2026-10-26T16:19:00.163
lb 8be67a2e86b7 running (healthy) 2026-10-26T16:15:42.154
migrate a5a9934b4d6b exited 2026-10-26T16:23:38.842
postgres d2bfd48385f1 running (healthy) 2026-10-26T16:15:17.840
s3 892c7ca290f2 running (healthy) 2026-10-26T16:24:57.683
s3-init deab1aa2b022 exited 2026-10-26T16:23:38.843
valkey 4e223cb9301e running (healthy) 2026-10-26T16:15:17.820
worker 292a36c54a41 running (healthy) 2026-10-26T16:23:41.416
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.␍
{"observed_instances_before": 2, "successful_writes": 119, "failed_attempts": 0, "first_recovery_seconds": 5.11}␍
{"observed_instances_before": 2, "successful_writes": 124, "failed_attempts": 0, "first_recovery_seconds": 4.531}␍
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
containers after (HAProxy: api1 UP)
SERVICE CONTAINER STATE STARTED AT (UTC)
api b0db3e40abfe running (healthy) 2026-10-25T18:28:33.999
api ef44b0d4c0a1 exited 2026-10-25T18:23:36.756
broker 9f909ed7ecea running (healthy) 2026-10-25T18:23:53.670
lb 8be67a2e86b7 running (healthy) 2026-10-25T18:20:04.043
migrate e6c2c825d38d exited 2026-10-25T18:28:07.167
postgres d2bfd48385f1 running (healthy) 2026-10-25T18:19:54.204
s3 892c7ca290f2 running (healthy) 2026-10-25T18:29:00.995
s3-init 08c2e7925d67 exited 2026-10-25T18:28:07.169
valkey 4e223cb9301e running (healthy) 2026-10-25T18:19:54.202
worker d9eced386d93 running (healthy) 2026-10-25T18:28:09.870
the hook stopped ef44b0d4c0a1 (X-Instance-Id of that replica = container ID); other api containers, postgres, valkey, s3 and lb kept running
restored: docker start ef44b0d4c0a1 -> healthy and back in HAProxy (api1 UP, api2 UP)
api 48dc392933dc exited 2026-10-26T16:24:32.726
api c1b7e1ab5673 running (healthy) 2026-10-26T16:18:45.657
broker 9f909ed7ecea running (healthy) 2026-10-26T16:19:00.163
lb 8be67a2e86b7 running (healthy) 2026-10-26T16:15:42.154
migrate a5a9934b4d6b exited 2026-10-26T16:23:38.842
postgres d2bfd48385f1 running (healthy) 2026-10-26T16:15:17.840
s3 892c7ca290f2 running (healthy) 2026-10-26T16:24:57.683
s3-init deab1aa2b022 exited 2026-10-26T16:23:38.843
valkey 4e223cb9301e running (healthy) 2026-10-26T16:15:17.820
worker 292a36c54a41 running (healthy) 2026-10-26T16:23:41.416
the hook stopped 48dc392933dc (X-Instance-Id of that replica = container ID); other api containers, postgres, valkey, s3 and lb kept running
restored: docker start 48dc392933dc -> healthy and back in HAProxy (api1 UP, api2 UP)
=== run 2: containers before (HAProxy: api1 UP, api2 UP)
SERVICE CONTAINER STATE STARTED AT (UTC)
api b0db3e40abfe running (healthy) 2026-10-25T18:28:33.999
api ef44b0d4c0a1 running (healthy) 2026-10-25T18:30:14.430
broker 9f909ed7ecea running (healthy) 2026-10-25T18:23:53.670
lb 8be67a2e86b7 running (healthy) 2026-10-25T18:20:04.043
migrate e6c2c825d38d exited 2026-10-25T18:28:07.167
postgres d2bfd48385f1 running (healthy) 2026-10-25T18:19:54.204
s3 892c7ca290f2 running (healthy) 2026-10-25T18:29:00.995
s3-init 08c2e7925d67 exited 2026-10-25T18:28:07.169
valkey 4e223cb9301e running (healthy) 2026-10-25T18:19:54.202
worker d9eced386d93 running (healthy) 2026-10-25T18:28:09.870
api 48dc392933dc running (healthy) 2026-10-26T16:25:57.020
api c1b7e1ab5673 running (healthy) 2026-10-26T16:18:45.657
broker 9f909ed7ecea running (healthy) 2026-10-26T16:19:00.163
lb 8be67a2e86b7 running (healthy) 2026-10-26T16:15:42.154
migrate a5a9934b4d6b exited 2026-10-26T16:23:38.842
postgres d2bfd48385f1 running (healthy) 2026-10-26T16:15:17.840
s3 892c7ca290f2 running (healthy) 2026-10-26T16:24:57.683
s3-init deab1aa2b022 exited 2026-10-26T16:23:38.843
valkey 4e223cb9301e running (healthy) 2026-10-26T16:15:17.820
worker 292a36c54a41 running (healthy) 2026-10-26T16:23:41.416
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.␍
{"observed_instances_before": 2, "successful_writes": 125, "failed_attempts": 0, "first_recovery_seconds": 5.531}␍
{"observed_instances_before": 2, "successful_writes": 124, "failed_attempts": 0, "first_recovery_seconds": 4.594}␍
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
containers after (HAProxy: api2 UP)
SERVICE CONTAINER STATE STARTED AT (UTC)
api b0db3e40abfe exited 2026-10-25T18:28:33.999
api ef44b0d4c0a1 running (healthy) 2026-10-25T18:30:14.430
broker 9f909ed7ecea running (healthy) 2026-10-25T18:23:53.670
lb 8be67a2e86b7 running (healthy) 2026-10-25T18:20:04.043
migrate e6c2c825d38d exited 2026-10-25T18:28:07.167
postgres d2bfd48385f1 running (healthy) 2026-10-25T18:19:54.204
s3 892c7ca290f2 running (healthy) 2026-10-25T18:29:00.995
s3-init 08c2e7925d67 exited 2026-10-25T18:28:07.169
valkey 4e223cb9301e running (healthy) 2026-10-25T18:19:54.202
worker d9eced386d93 running (healthy) 2026-10-25T18:28:09.870
the hook stopped b0db3e40abfe (X-Instance-Id of that replica = container ID); other api containers, postgres, valkey, s3 and lb kept running
restored: docker start b0db3e40abfe -> healthy and back in HAProxy (api1 UP, api2 UP)
api 48dc392933dc running (healthy) 2026-10-26T16:25:57.020
api c1b7e1ab5673 exited 2026-10-26T16:18:45.657
broker 9f909ed7ecea running (healthy) 2026-10-26T16:19:00.163
lb 8be67a2e86b7 running (healthy) 2026-10-26T16:15:42.154
migrate a5a9934b4d6b exited 2026-10-26T16:23:38.842
postgres d2bfd48385f1 running (healthy) 2026-10-26T16:15:17.840
s3 892c7ca290f2 running (healthy) 2026-10-26T16:24:57.683
s3-init deab1aa2b022 exited 2026-10-26T16:23:38.843
valkey 4e223cb9301e running (healthy) 2026-10-26T16:15:17.820
worker 292a36c54a41 running (healthy) 2026-10-26T16:23:41.416
the hook stopped c1b7e1ab5673 (X-Instance-Id of that replica = container ID); other api containers, postgres, valkey, s3 and lb kept running
restored: docker start c1b7e1ab5673 -> healthy and back in HAProxy (api1 UP, api2 UP)
PASS: public failover test passed 2 times; every api replica was stopped once and restored
+29 -29
View File
@@ -1,36 +1,36 @@
python student-tests/failure_s3.py
=== s3 stopped
SERVICE CONTAINER STATE STARTED AT (UTC)
api b0db3e40abfe running (healthy) 2026-10-25T18:28:33.999
api ef44b0d4c0a1 running (healthy) 2026-10-25T18:23:36.756
broker 9f909ed7ecea running (healthy) 2026-10-25T18:23:53.670
lb 8be67a2e86b7 running (healthy) 2026-10-25T18:20:04.043
migrate e6c2c825d38d exited 2026-10-25T18:28:07.167
postgres d2bfd48385f1 running (healthy) 2026-10-25T18:19:54.204
s3 892c7ca290f2 exited 2026-10-25T18:19:54.206
s3-init 08c2e7925d67 exited 2026-10-25T18:28:07.169
valkey 4e223cb9301e running (healthy) 2026-10-25T18:19:54.202
worker d9eced386d93 running (healthy) 2026-10-25T18:28:09.870
both api replicas are out of the balancer after 1.0 s: api1 DOWN, api2 DOWN
replica b0db3e40abfe: /health/live 200, /health/ready 503
replica ef44b0d4c0a1: /health/live 200, /health/ready 503
GET /health/ready -> 503 unavailable in 0.00 s (answered by the balancer)
POST /api/v1/chats/6f457b5b-fe8c-45c4-a569-dcb9e04b2539/attachments -> 503 unavailable in 0.00 s (answered by the balancer)
GET /api/v1/attachments/9605875a-7999-471f-8e6b-500c0d99ccb6/content -> 503 unavailable in 0.00 s (answered by the balancer)
GET /api/v1/chats/6f457b5b-fe8c-45c4-a569-dcb9e04b2539/messages -> 503 unavailable in 0.00 s (answered by the balancer)
api 48dc392933dc running (healthy) 2026-10-26T16:24:32.726
api c1b7e1ab5673 running (healthy) 2026-10-26T16:18:45.657
broker 9f909ed7ecea running (healthy) 2026-10-26T16:19:00.163
lb 8be67a2e86b7 running (healthy) 2026-10-26T16:15:42.154
migrate a5a9934b4d6b exited 2026-10-26T16:23:38.842
postgres d2bfd48385f1 running (healthy) 2026-10-26T16:15:17.840
s3 892c7ca290f2 exited 2026-10-26T16:15:17.826
s3-init deab1aa2b022 exited 2026-10-26T16:23:38.843
valkey 4e223cb9301e running (healthy) 2026-10-26T16:15:17.820
worker 292a36c54a41 running (healthy) 2026-10-26T16:23:41.416
both api replicas are out of the balancer after 0.9 s: api1 DOWN, api2 DOWN
replica 48dc392933dc: /health/live 200, /health/ready 503
replica c1b7e1ab5673: /health/live 200, /health/ready 503
GET /health/ready -> 503 unavailable in 0.05 s (answered by the balancer)
POST /api/v1/chats/c3165ff5-5952-4666-84df-aa7e4dab7fb9/attachments -> 503 unavailable in 0.00 s (answered by the balancer)
GET /api/v1/attachments/bfbc3aa5-81f0-46d0-a26d-f901b8d9ee86/content -> 503 unavailable in 0.00 s (answered by the balancer)
GET /api/v1/chats/c3165ff5-5952-4666-84df-aa7e4dab7fb9/messages -> 503 unavailable in 0.02 s (answered by the balancer)
=== s3 started
replicas are back in the balancer after 23.7 s: api1 UP, api2 UP
replicas are back in the balancer after 18.0 s: api1 UP, api2 UP
the file uploaded before the outage is intact (sha256 99ea7533c441f79c...)
new upload -> 202 -> ready (cd112988-40ba-4267-951d-033ea82b1ca3)
new upload -> 202 -> ready (59e03ee4-d3ff-40e9-b1e6-6a1d6fee4720)
SERVICE CONTAINER STATE STARTED AT (UTC)
api b0db3e40abfe running (healthy) 2026-10-25T18:28:33.999
api ef44b0d4c0a1 running (healthy) 2026-10-25T18:23:36.756
broker 9f909ed7ecea running (healthy) 2026-10-25T18:23:53.670
lb 8be67a2e86b7 running (healthy) 2026-10-25T18:20:04.043
migrate e6c2c825d38d exited 2026-10-25T18:28:07.167
postgres d2bfd48385f1 running (healthy) 2026-10-25T18:19:54.204
s3 892c7ca290f2 running (healthy) 2026-10-25T18:29:00.995
s3-init 08c2e7925d67 exited 2026-10-25T18:28:07.169
valkey 4e223cb9301e running (healthy) 2026-10-25T18:19:54.202
worker d9eced386d93 running (healthy) 2026-10-25T18:28:09.870
api 48dc392933dc running (unhealthy) 2026-10-26T16:24:32.726
api c1b7e1ab5673 running (unhealthy) 2026-10-26T16:18:45.657
broker 9f909ed7ecea running (healthy) 2026-10-26T16:19:00.163
lb 8be67a2e86b7 running (unhealthy) 2026-10-26T16:15:42.154
migrate a5a9934b4d6b exited 2026-10-26T16:23:38.842
postgres d2bfd48385f1 running (healthy) 2026-10-26T16:15:17.840
s3 892c7ca290f2 running (starting) 2026-10-26T16:24:57.683
s3-init deab1aa2b022 exited 2026-10-26T16:23:38.843
valkey 4e223cb9301e running (healthy) 2026-10-26T16:15:17.820
worker 292a36c54a41 running (healthy) 2026-10-26T16:23:41.416
PASS: S3 down -> replicas not ready (live 200, ready 503), the balancer answers 503 in the contract format, no 500 and no hanging; after S3 is back the original is intact and uploads work again
+10 -4
View File
@@ -1,6 +1,6 @@
docker compose --profile tools run --rm imaging-test
Container mtusi-lab5-imaging-test-run-522cead2dfe0 Creating
Container mtusi-lab5-imaging-test-run-522cead2dfe0 Created
Container mtusi-lab5-imaging-test-run-7b65aee97073 Creating
Container mtusi-lab5-imaging-test-run-7b65aee97073 Created
test_alpha_is_white_in_jpeg_and_kept_in_webp (test_imaging.ImagingTest.test_alpha_is_white_in_jpeg_and_kept_in_webp) ... ok
test_broken_jpeg_scan_is_invalid (test_imaging.ImagingTest.test_broken_jpeg_scan_is_invalid) ... ok
test_exif_orientation_is_applied (test_imaging.ImagingTest.test_exif_orientation_is_applied) ...
@@ -10,14 +10,20 @@ test_fixture_variants (test_imaging.ImagingTest.test_fixture_variants) ...
fixture 320×200 -> thumbnail JPEG 256×160, crop JPEG 128×128, optimized WebP 320×200
ok
test_geometry (test_imaging.ImagingTest.test_geometry) ... ok
test_jpeg_header_check_matches_strict_decoder (test_imaging.ImagingTest.test_jpeg_header_check_matches_strict_decoder) ...
800 random header mutations: {'both accept': 318, 'both reject': 427, 'accepted, entropy error in worker': 55}
ok
test_limits_in_child_process (test_imaging.ImagingTest.test_limits_in_child_process) ...
36 Mpx RGBA in a child process: ok in 3.78 s with 640 MiB; MemoryError -> image_too_large with 200 MiB; timeout 0.2 s -> killed after 0.21 s; 1000 px limit -> image_too_large
36 Mpx RGBA in a child process: ok in 3.93 s with 640 MiB; MemoryError -> image_too_large with 200 MiB; timeout 0.2 s -> killed after 0.21 s; 1000 px limit -> image_too_large
ok
test_metadata_is_stripped (test_imaging.ImagingTest.test_metadata_is_stripped) ... ok
test_modes (test_imaging.ImagingTest.test_modes) ... ok
test_same_input_same_bytes (test_imaging.ImagingTest.test_same_input_same_bytes) ... ok
test_subsampling_rule_matches_turbojpeg (test_imaging.ImagingTest.test_subsampling_rule_matches_turbojpeg) ...
8208 sampling-factor combinations: API and TurboJPEG agree on every one
ok
----------------------------------------------------------------------
Ran 9 tests in 5.420s
Ran 11 tests in 6.036s
OK
+5 -5
View File
@@ -1,9 +1,9 @@
python student-tests/lease_takeover.py
1. long job (35 s > lease 30 s) on d9eced386d93/507dfab2: lease_until moved forward 2 times: 18:26:08 -> 18:26:10 -> 18:26:20
2. worker B 3b645a26424d started (the job is still held by A's lease)
worker A d9eced386d93 frozen (docker pause): no more renewals
lease expired -> attempt 2 -> ready 31 s after the freeze; result committed by worker-3b645a26424d/a5b5d050
1. long job (35 s > lease 30 s) on 292a36c54a41/4b7735c2: lease_until moved forward 2 times: 16:21:03 -> 16:21:13 -> 16:21:23
2. worker B fa1bafe61888 started (the job is still held by A's lease)
worker A 292a36c54a41 frozen (docker pause): no more renewals
lease expired -> attempt 2 -> ready 33 s after the freeze; result committed by worker-fa1bafe61888/279ac631
events: queued(1) -> claimed(1) -> lease_expired(1) -> retry_scheduled(1) -> claimed(2) -> ready(2)
3. worker A unpaused: Задание cd53da75-5133-44f3-a33f-038d4dbfd6ca: lease забрал другой worker — работа брошена
3. worker A unpaused: Задание d08bfc08-1460-4633-bbfd-6b3f69088ca3: lease забрал другой worker — работа брошена
still exactly one result: status ready, attempt 2, 3 variant rows, metadata unchanged
PASS: a running worker keeps its lease by renewing it; a frozen one loses it, the job moves to another worker, and the stale worker cannot overwrite the result (fencing token)
+12 -12
View File
@@ -1,19 +1,19 @@
python student-tests/outbox_crash.py
A. api_after_commit: the client got 502 instead of 202, but the attachment 44f59913-f920-4d36-82d5-fea3d61ce5b7 and its outbox row were committed before the crash
ready without creating a new job by hand; api restarted by Docker: ['ef44b0d4c0a1']
outbox: row 41 published 2026-10-25T18:23:23.278264+00:00 by relay-b0db3e40abfe
A. api_after_commit: the client got 502 instead of 202, but the attachment 68ccecb0-ae64-4a1d-a235-63219f66c403 and its outbox row were committed before the crash
ready without creating a new job by hand; api restarted by Docker: ['48dc392933dc']
outbox: row 130 published 2026-10-26T16:18:31.010950+00:00 by relay-c1b7e1ab5673
events: queued -> claimed -> ready
B. relay_before_publish: upload -> 202 (0d6338d9-fa65-459d-9d54-53cc385700d4); every relay that takes the row crashes before publishing
crashed and restarted: ['b0db3e40abfe', 'ef44b0d4c0a1']; after restart the row was published once -> ready
outbox: row 42 published 2026-10-25T18:23:32.331225+00:00 by relay-ef44b0d4c0a1
B. relay_before_publish: upload -> 202 (780f7bd8-df89-4c70-84fa-9d90f35879fa); every relay that takes the row crashes before publishing
crashed and restarted: ['48dc392933dc', 'c1b7e1ab5673']; after restart the row was published once -> ready
outbox: row 131 published 2026-10-26T16:18:40.873234+00:00 by relay-48dc392933dc
events: queued -> claimed -> ready
C. relay_after_publish: upload -> 202 (cf7c7e33-78ee-48c1-9bc5-7acefbf49d40); the broker confirms, the relay crashes before marking the row
crashed and restarted: ['b0db3e40abfe', 'ef44b0d4c0a1']; the same message was delivered again 1 time(s): duplicate_ignored
outbox: row 43 published 2026-10-25T18:23:40.297286+00:00 by relay-ef44b0d4c0a1
C. relay_after_publish: upload -> 202 (87559a9a-a61c-4a10-999c-516b5e1f481a); the broker confirms, the relay crashes before marking the row
crashed and restarted: ['48dc392933dc', 'c1b7e1ab5673']; the same message was delivered again 1 time(s): duplicate_ignored
outbox: row 132 published 2026-10-26T16:18:48.678466+00:00 by relay-48dc392933dc
events: queued -> claimed -> ready -> duplicate_ignored
still one set of variants: 3 rows, 3 objects
D. broker stopped: upload -> 202 (094e50ca-898e-4c19-9d39-1b80721409ab), after 5 s status queued, outbox row 44 not published yet (it waits in PostgreSQL)
broker started: the relay published the row, ready 6.4 s later
outbox: row 44 published 2026-10-25T18:24:08.645165+00:00 by relay-ef44b0d4c0a1
D. broker stopped: upload -> 202 (87e3efc2-e44b-4260-8129-7fadffec4811), after 5 s status queued, outbox row 133 not published yet (it waits in PostgreSQL)
broker started: the relay published the row, ready 11.8 s later
outbox: row 133 published 2026-10-26T16:19:07.785521+00:00 by relay-48dc392933dc
events: queued -> claimed -> ready
PASS: a crash between COMMIT and publish (A, B) loses nothing — the outbox row is published later and the job becomes ready without manual action; a crash after publish (C) only causes a duplicate delivery, which the worker acknowledges without a second set of variants; while the broker is down (D) uploads are still accepted and the jobs wait in the outbox
+29 -29
View File
@@ -2,36 +2,36 @@ python student-tests/run_persistence.py
hook: scripts/restart.cmd
=== containers before
SERVICE CONTAINER STATE STARTED AT (UTC)
api b0db3e40abfe running (healthy) 2026-10-25T18:30:40.428
api ef44b0d4c0a1 running (healthy) 2026-10-25T18:30:14.430
broker 9f909ed7ecea running (healthy) 2026-10-25T18:23:53.670
lb 8be67a2e86b7 running (healthy) 2026-10-25T18:20:04.043
migrate e6c2c825d38d exited 2026-10-25T18:28:07.167
postgres d2bfd48385f1 running (healthy) 2026-10-25T18:19:54.204
s3 892c7ca290f2 running (healthy) 2026-10-25T18:29:00.995
s3-init 08c2e7925d67 exited 2026-10-25T18:28:07.169
valkey 4e223cb9301e running (healthy) 2026-10-25T18:19:54.202
worker d9eced386d93 running (healthy) 2026-10-25T18:28:09.870
api 48dc392933dc running (healthy) 2026-10-26T16:25:57.020
api c1b7e1ab5673 running (healthy) 2026-10-26T16:26:21.371
broker 9f909ed7ecea running (healthy) 2026-10-26T16:19:00.163
lb 8be67a2e86b7 running (healthy) 2026-10-26T16:15:42.154
migrate a5a9934b4d6b exited 2026-10-26T16:23:38.842
postgres d2bfd48385f1 running (healthy) 2026-10-26T16:15:17.840
s3 892c7ca290f2 running (healthy) 2026-10-26T16:24:57.683
s3-init deab1aa2b022 exited 2026-10-26T16:23:38.843
valkey 4e223cb9301e running (healthy) 2026-10-26T16:15:17.820
worker 292a36c54a41 running (healthy) 2026-10-26T16:23:41.416
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.␍
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
=== containers after (test took 44.6 s: hook + waiting for readiness + data checks)
=== containers after (test took 49.6 s: hook + waiting for readiness + data checks)
SERVICE CONTAINER STATE STARTED AT (UTC)
api b0db3e40abfe running (healthy) 2026-10-25T18:31:28.449
api ef44b0d4c0a1 running (healthy) 2026-10-25T18:31:28.805
broker 9f909ed7ecea running (healthy) 2026-10-25T18:30:56.986
lb 8be67a2e86b7 running (healthy) 2026-10-25T18:31:31.925
migrate e6c2c825d38d exited 2026-10-25T18:31:11.567
postgres d2bfd48385f1 running (healthy) 2026-10-25T18:30:55.983
s3 892c7ca290f2 running (healthy) 2026-10-25T18:31:10.564
s3-init 08c2e7925d67 exited 2026-10-25T18:31:26.062
valkey 4e223cb9301e running (healthy) 2026-10-25T18:30:56.073
worker d9eced386d93 running (healthy) 2026-10-25T18:31:28.448
api ef44b0d4c0a1: same container, start time 18:30:14 -> 18:31:28
api b0db3e40abfe: same container, start time 18:30:40 -> 18:31:28
broker 9f909ed7ecea: same container, start time 18:23:53 -> 18:30:56
lb 8be67a2e86b7: same container, start time 18:20:04 -> 18:31:31
postgres d2bfd48385f1: same container, start time 18:19:54 -> 18:30:55
s3 892c7ca290f2: same container, start time 18:29:00 -> 18:31:10
valkey 4e223cb9301e: same container, start time 18:19:54 -> 18:30:56
worker d9eced386d93: same container, start time 18:28:09 -> 18:31:28
api 48dc392933dc running (healthy) 2026-10-26T16:27:12.404
api c1b7e1ab5673 running (healthy) 2026-10-26T16:27:12.751
broker 9f909ed7ecea running (healthy) 2026-10-26T16:26:35.888
lb 8be67a2e86b7 running (healthy) 2026-10-26T16:27:16.490
migrate a5a9934b4d6b exited 2026-10-26T16:26:50.586
postgres d2bfd48385f1 running (healthy) 2026-10-26T16:26:34.837
s3 892c7ca290f2 running (healthy) 2026-10-26T16:26:49.628
s3-init deab1aa2b022 exited 2026-10-26T16:27:10.098
valkey 4e223cb9301e running (healthy) 2026-10-26T16:26:34.974
worker 292a36c54a41 running (healthy) 2026-10-26T16:27:12.399
api 48dc392933dc: same container, start time 16:25:57 -> 16:27:12
api c1b7e1ab5673: same container, start time 16:26:21 -> 16:27:12
broker 9f909ed7ecea: same container, start time 16:19:00 -> 16:26:35
lb 8be67a2e86b7: same container, start time 16:15:42 -> 16:27:16
postgres d2bfd48385f1: same container, start time 16:15:17 -> 16:26:34
s3 892c7ca290f2: same container, start time 16:24:57 -> 16:26:49
valkey 4e223cb9301e: same container, start time 16:15:17 -> 16:26:34
worker 292a36c54a41: same container, start time 16:23:41 -> 16:27:12
PASS: api replicas, worker, postgres, valkey, s3, broker and lb were restarted (same containers and volumes, new start time); data, the attachment bytes and the existing token survived
+2 -2
View File
@@ -1,8 +1,8 @@
python student-tests/redelivery.py
1. attachment a8404f7e-b179-4332-a562-4508d5a31ee5 ready: 3 variant rows, objects ['variants/a8404f7e-b179-4332-a562-4508d5a31ee5/v1/crop.jpg', 'variants/a8404f7e-b179-4332-a562-4508d5a31ee5/v1/optimized.webp', 'variants/a8404f7e-b179-4332-a562-4508d5a31ee5/v1/thumbnail.jpg']
1. attachment 0e1796c4-b771-4b97-a8d6-27f3d24d5dd4 ready: 3 variant rows, objects ['variants/0e1796c4-b771-4b97-a8d6-27f3d24d5dd4/v1/crop.jpg', 'variants/0e1796c4-b771-4b97-a8d6-27f3d24d5dd4/v1/optimized.webp', 'variants/0e1796c4-b771-4b97-a8d6-27f3d24d5dd4/v1/thumbnail.jpg']
2. the same message (same job_id and attempt) published twice more
3. both duplicates acknowledged without processing: duplicate_ignored(задание уже ready: повторная доставка, ack без обработки), duplicate_ignored(задание уже ready: повторная доставка, ack без обработки)
variants: [('crop', '97bf1400b30a'), ('optimized', '1090d84ed841'), ('thumbnail', '7bc40bf315c8')] — same rows, same objects, status ready, attempt 1
4. 3 messages that do not match jobs.schema.json -> reject -> DLQ attachments.dead: 8 -> 11
4. 3 messages that do not match jobs.schema.json -> reject -> DLQ attachments.dead: 34 -> 37
the worker keeps working: a new upload became ready
PASS: redelivery of a finished job is a no-op with ack (no second set of variants); malformed messages go to the DLQ without crashing the worker
+3 -3
View File
@@ -1,10 +1,10 @@
python student-tests/retry_replay.py
A. transient errors twice, then success: ready at attempt 3
pauses before attempts: #2: 1.83 s, #3: 2.17 s (backoff 2^n with random jitter in [d/2, d])
pauses before attempts: #2: 1.98 s, #3: 2.19 s (backoff 2^n with random jitter in [d/2, d])
events: queued(1) -> claimed(1) -> retry_scheduled(1) -> claimed(2) -> retry_scheduled(2) -> claimed(3) -> ready(3)
B. transient error every time: 5 attempts -> failed, error_code=retry_exhausted (last error storage_unavailable)
pauses: #2: 1.84 s, #3: 2.45 s, #4: 6.81 s, #5: 15.37 s
DLQ attachments.dead: 11 -> 12; registry: python -m messenger.jobs failed lists it; content -> 409, attach -> 409
pauses: #2: 1.96 s, #3: 2.31 s, #4: 5.86 s, #5: 13.62 s
DLQ attachments.dead: 30 -> 31; registry: python -m messenger.jobs failed lists it; content -> 409, attach -> 409
C. permanent error: broken JPEG scan -> failed at attempt 1, error_code=invalid_image (no retries)
D. replay of the failed job: {'result': 'queued', 'attempt': 6, 'previous_error': 'retry_exhausted'} -> ready at attempt 6; audit: operator:student-test: replay оператора: было retry_exhausted (последняя ошибка storage_unavailable); новая попытка 6, ещё 5 попыток
replay of the now ready job: {'result': 'noop', 'reason': 'ready'} — no new message, variants unchanged (3 rows), status ready
+4 -4
View File
@@ -13,11 +13,11 @@ SeaweedFS admin/UI port 8888 inside the network: closed
SeaweedFS admin/UI port 8080 inside the network: closed
host 127.0.0.1:9000, :9333, :8888: closed (S3 is not published)
attachments columns: id:uuid, chat_id:uuid, owner_id:uuid, filename:text, content_type:text, size_bytes:bigint, sha256:text, width:integer, height:integer, storage_key:text, status:text, created_at:timestamp with time zone, updated_at:timestamp with time zone, error_code:text, staging_key:text
api b0db3e40abfe: files with the same SHA-256 on disk: 0
api ef44b0d4c0a1: files with the same SHA-256 on disk: 0
worker d9eced386d93: files with the same SHA-256 on disk: 0
api 48dc392933dc: files with the same SHA-256 on disk: 0
api c1b7e1ab5673: files with the same SHA-256 on disk: 0
worker 292a36c54a41: files with the same SHA-256 on disk: 0
broker message (243 bytes): ['attachment_id', 'attempt', 'created_at', 'job_id', 'pipeline_version', 'schema_version', 'type'] — only IDs and service fields
s3-init run 1: exit 0: s3-init: bucket messenger-attachments already exists; anonymous access: 403 (private)
s3-init run 2: exit 0: s3-init: bucket messenger-attachments already exists; anonymous access: 403 (private)
objects in bucket before/after bootstrap: 164/164; the file still downloads
objects in bucket before/after bootstrap: 360/360; the file still downloads
PASS: bucket is private outside the API, the API S3 user has least privilege, the console is closed, bytes are only in S3, bucket bootstrap is idempotent
+16 -16
View File
@@ -2,17 +2,17 @@ python student-tests/check_stack.py
docker: 29.6.2
compose: 5.3.1
container_name: not set for any service (replicas of one service are possible)
api replicas running: 2 -> ['b0db3e40abfe', 'ef44b0d4c0a1'] (deploy.replicas = 2)
api replicas running: 2 -> ['48dc392933dc', 'c1b7e1ab5673'] (deploy.replicas = 2)
service container cpus memory published ports networks
worker 292a36c54a41 1.00 1024Mi - backend
api 48dc392933dc 1.00 512Mi - backend, edge
valkey 4e223cb9301e 0.50 128Mi - backend
s3 892c7ca290f2 0.50 512Mi - backend
lb 8be67a2e86b7 0.50 128Mi 127.0.0.1:8080->8080/tcp, 127.0.0.1:8081->8081/tcp, 127.0.0.1:8404->8404/tcp edge
broker 9f909ed7ecea 1.00 512Mi - backend
api b0db3e40abfe 1.00 512Mi - backend, edge
api c1b7e1ab5673 1.00 512Mi - backend, edge
postgres d2bfd48385f1 1.00 512Mi - backend
worker d9eced386d93 1.00 1024Mi - backend
api ef44b0d4c0a1 1.00 512Mi - backend, edge
published: only lb, only on 127.0.0.1 (api replicas have no ports)
balancer: every api server is under the /health/ready check, no backup servers -> api1 UP (L7OK), api2 UP (L7OK)
@@ -25,15 +25,15 @@ images: lb haproxy:3.2.25-alpine; api mtusi-messenger:lab5; worker mtusi-messen
PASS: one entry point (lb on 127.0.0.1), >= 2 api replicas without ports and container_name, only ready replicas get traffic, CPU/RAM limits everywhere, stores (incl. S3) only on the internal network, S3 admin credentials only in s3-init; broker and worker are separate services
docker compose ps -a --format "table {{.Service}}\t{{.ID}}\t{{.Status}}"
SERVICE CONTAINER ID STATUS
api b0db3e40abfe Up 34 seconds (healthy)
api ef44b0d4c0a1 Up 34 seconds (healthy)
broker 9f909ed7ecea Up 43 seconds (healthy)
lb 8be67a2e86b7 Up 33 seconds (healthy)
migrate e6c2c825d38d Exited (0) 35 seconds ago
postgres d2bfd48385f1 Up 43 seconds (healthy)
s3 892c7ca290f2 Up 43 seconds (healthy)
s3-init 08c2e7925d67 Exited (0) 35 seconds ago
valkey 4e223cb9301e Up 43 seconds (healthy)
worker d9eced386d93 Up 34 seconds (healthy)
s3-init-1 | s3-init: bucket messenger-attachments created; anonymous access: 403 (private)
migrate-1 | 2026-10-25 18:20:01,879 INFO messenger.db: Миграции применены: 001_core, 002_sessions, 003_text_as_bytes, 004_message_idempotency, 005_attachments, 006_jobs
api 48dc392933dc Up 49 seconds (healthy)
api c1b7e1ab5673 Up 49 seconds (healthy)
broker 9f909ed7ecea Up About a minute (healthy)
lb 8be67a2e86b7 Up 48 seconds (healthy)
migrate a5a9934b4d6b Exited (0) About a minute ago
postgres d2bfd48385f1 Up About a minute (healthy)
s3 892c7ca290f2 Up About a minute (healthy)
s3-init deab1aa2b022 Exited (0) 50 seconds ago
valkey 4e223cb9301e Up About a minute (healthy)
worker 292a36c54a41 Up 49 seconds (healthy)
s3-init-1 | s3-init: bucket messenger-attachments already exists; anonymous access: 403 (private)
migrate-1 | 2026-10-26 16:15:25,625 INFO messenger.db: Миграции: новых нет, схема актуальна
+2 -2
View File
@@ -1,10 +1,10 @@
python student-tests/staging_cleanup.py
1. ready 232becfa-7e6d-44da-bb4d-e72e9d0cc9fd: staging removed by the worker right after COMMIT; original and variants kept
1. ready a285845a-2a6d-438d-a37c-f5ce252e5ce6: staging removed by the worker right after COMMIT; original and variants kept
2. prepared: staging leftover of a ready attachment, orphan staging, orphan variant, staging of a failed attachment, staging of a queued job (worker stopped)
3. dry-run: {"staging_after_ready": 2, "staging_failed_expired": 0, "orphan": 2} found, deleted 0
grace 900 s: deleted 0 — everything is younger than the grace period
grace 2 s: {"staging_after_ready": 2, "staging_failed_expired": 0, "orphan": 2}, deleted 4; kept: ready original and variants, staging of the queued job, staging of the failed attachment (retention)
retention 0 s: failed staging deleted ({"staging_after_ready": 0, "staging_failed_expired": 3, "orphan": 0}); replay now: {'result': 'refused', 'reason': 'source_missing', 'detail': 'оригинал в staging уже удалён (истёк STAGING_RETENTION_SECONDS)'}
repeated run: deleted 0
4. worker started: f8dce515-9269-42bf-a961-6ef73c87d763 ready, its staging removed
4. worker started: 002336e3-fb36-4738-b420-29d5362140cb ready, its staging removed
PASS: staging is removed after the result is committed; objects without a reference in the database are removed only after the grace period; the staging of failed uploads is kept for replay until retention ends; dry-run and repeated runs are safe
+9 -7
View File
@@ -23,8 +23,10 @@ test_mime_spoofing_is_415 (test_attachments.AttachmentTest.test_mime_spoofing_is
test_outsider_and_anonymous_cannot_upload (test_attachments.AttachmentTest.test_outsider_and_anonymous_cannot_upload) ... ok
test_pixel_bomb_is_413 (test_attachments.AttachmentTest.test_pixel_bomb_is_413) ... ok
test_png_and_jpeg_roundtrip_for_member (test_attachments.AttachmentTest.test_png_and_jpeg_roundtrip_for_member) ... ok
test_structurally_broken_jpeg_is_415 (test_attachments.AttachmentTest.test_structurally_broken_jpeg_is_415) ... ok
test_too_large_is_413_before_reading (test_attachments.AttachmentTest.test_too_large_is_413_before_reading) ... ok
test_too_large_stream_is_413 (test_attachments.AttachmentTest.test_too_large_stream_is_413) ... ok
test_valid_jpeg_variants_are_accepted (test_attachments.AttachmentTest.test_valid_jpeg_variants_are_accepted) ... ok
test_variants_and_bad_ids (test_attachments.AttachmentTest.test_variants_and_bad_ids) ... ok
test_variants_follow_the_contract (test_attachments.AttachmentTest.test_variants_follow_the_contract) ... ok
test_bearer_required_on_business_endpoints (test_auth.AuthTest.test_bearer_required_on_business_endpoints) ... ok
@@ -53,7 +55,7 @@ test_replay_through_another_replica_returns_same_message (test_idempotency.Idemp
test_same_key_other_body_is_409 (test_idempotency.IdempotencyTest.test_same_key_other_body_is_409) ... ok
----------------------------------------------------------------------
Ran 52 tests in 24.217s
Ran 54 tests in 25.793s
OK
@@ -63,13 +65,13 @@ OK
X-Instance-Id есть в health, 404, 401 и 400
logout через одну реплику -> 401 на ['b0db3e40abfe', 'ef44b0d4c0a1']
logout через одну реплику -> 401 на ['48dc392933dc', 'c1b7e1ab5673']
20 x GET /users/me с одним токеном -> реплики {'ef44b0d4c0a1': 10, 'b0db3e40abfe': 10}; это ID запущенных контейнеров api, повторный вход не нужен
20 x GET /users/me с одним токеном -> реплики {'c1b7e1ab5673': 10, '48dc392933dc': 10}; это ID запущенных контейнеров api, повторный вход не нужен
10 x GET /users/me через реплики {'ef44b0d4c0a1': 5, 'b0db3e40abfe': 5}: попаданий в кэш +20, промахов +0 — кэш общий
10 x GET /users/me через реплики {'c1b7e1ab5673': 5, '48dc392933dc': 5}: попаданий в кэш +20, промахов +0 — кэш общий
сообщение записала реплика ef44b0d4c0a1, сразу прочитали ['b0db3e40abfe', 'ef44b0d4c0a1']
сообщение записала реплика c1b7e1ab5673, сразу прочитали ['48dc392933dc', 'c1b7e1ab5673']
с тем же ключом: сначала 400 (пустой текст), потом 201 — ошибка ключ не заняла
@@ -81,10 +83,10 @@ OK
10 одновременных разных тел с одним ключом: 201 x1, 409 x9, в истории 1 сообщение
20 одновременных POST с одним ключом через реплики {'b0db3e40abfe': 10, 'ef44b0d4c0a1': 10}: все 201 с одним id, в истории 1 сообщение
20 одновременных POST с одним ключом через реплики {'48dc392933dc': 10, 'c1b7e1ab5673': 10}: все 201 с одним id, в истории 1 сообщение
повтор: посторонний -> 404, после logout -> 401, после нового входа -> то же сообщение
1 запрос + 4 повтора через реплики ['b0db3e40abfe', 'ef44b0d4c0a1']: 201 и то же сообщение, в истории 1
1 запрос + 4 повтора через реплики ['48dc392933dc', 'c1b7e1ab5673']: 201 и то же сообщение, в истории 1
другой текст с тем же ключом -> 409 conflict, второе сообщение не создано
+2 -2
View File
@@ -1,9 +1,9 @@
python student-tests/worker_crash.py
A. worker_after_objects armed; upload -> 202 (7d0b4994-daec-489f-ab0c-fbad47e60ff5)
A. worker_after_objects armed; upload -> 202 (29951699-589c-4919-8291-a58289f70dff)
the worker crashed after writing objects (restart count 0 -> 1); objects left by the crashed attempt: 3
events: queued(1) -> claimed(1) -> lease_expired(1) -> retry_scheduled(1) -> claimed(2) -> ready(2)
ready at attempt 2; same keys and the same SHA-256 as the crashed attempt wrote: ['crop.jpg', 'optimized.webp', 'thumbnail.jpg']; 3 variant rows
B. worker_after_commit armed; upload -> 202 (d37dd53f-e784-47ba-9351-af5c9b091bd5)
B. worker_after_commit armed; upload -> 202 (50d85920-ab49-4658-9bf8-f61e1ac50181)
events: queued(1) -> claimed(1) -> ready(1) -> duplicate_ignored(1)
the redelivered message found the job ready and was acknowledged without processing
PASS: a worker crash after writing objects but before ack is finished by a retry with the same result; a crash after COMMIT but before ack ends with a no-op redelivery
+6 -6
View File
@@ -1,13 +1,13 @@
python student-tests/worker_outage.py
1. worker stopped: no running worker containers
2. upload -> 202 queued, attachment_id=58fc7ebe-6b35-4894-8af6-aad8f620136a
2. upload -> 202 queued, attachment_id=514906d6-77b8-4dec-a73f-a43670fc65ab
GET -> queued, /content -> 409, /content?variant=thumbnail -> 409
3. message with the queued attachment -> 201 (72038a80-6630-48ce-990a-4c37d5442ea4); text message -> 201 (d2a39236-0930-4973-ac60-f8089e57fc00)
3. message with the queued attachment -> 201 (97507e33-6eca-4009-aa8e-4239ddece625); text message -> 201 (1296cc2b-4850-4695-93bc-07411472f7a7)
4. after 5 s still queued: the API does not resize synchronously
5. job 8006a767-095b-412d-9493-fed8b6382c6d attempt 1: outbox row published at 2026-10-25T18:22:00.036515+00:00 by relay-ef44b0d4c0a1; queues: {'attachments.process': (1, 0), 'attachments.dead': (7, 0)}
5. job 296f84cb-b2cd-49b6-9080-2e460df42764 attempt 1: outbox row published at 2026-10-26T16:37:37.645701+00:00 by relay-c1b7e1ab5673; queues: {'attachments.process': (1, 0), 'attachments.dead': (34, 0)}
6. api replicas restarted (same containers, volumes kept)
broker restarted with volume rabbitmqdata; queues after restart: {'attachments.process': (1, 0), 'attachments.dead': (7, 0)}
7. worker started -> ready after 3.2 s
thumbnail 256×160 JPEG, original SHA-256 unchanged, message 72038a80-6630-48ce-990a-4c37d5442ea4 keeps the attachment; outbox rows for the job: 1 (published once, before the broker restart)
broker restarted with volume rabbitmqdata; queues after restart: {'attachments.process': (1, 0), 'attachments.dead': (34, 0)}
7. worker started -> ready after 3.8 s
thumbnail 256×160 JPEG, original SHA-256 unchanged, message 97507e33-6eca-4009-aa8e-4239ddece625 keeps the attachment; outbox rows for the job: 1 (published once, before the broker restart)
job events: queued(1) -> claimed(1) -> ready(1)
PASS: with the worker down uploads are accepted (202) and wait; the accepted job survives API and broker restarts and becomes ready once the worker is started
+11 -5
View File
@@ -17,6 +17,8 @@
Картинка НЕ декодируется и не уменьшается — это работа worker;
3. PUT оригинала в staging/<id> (ключ назначает сервер);
4. COMMIT: вложение + задание + outbox -> 202. После ответа будится relay этого же процесса.
Шаги 3–4 — одна транзакция под блокировкой ID вложения (store.receiving): пока она идёт,
уборщик этот staging не трогает (замечание к MR: уборка не должна удалять текущую работу).
Сбои:
- S3 недоступен на шаге 3 -> 503, в БД ничего нет; объект мог успеть записаться — тогда это
@@ -94,11 +96,15 @@ def accept(store: PostgresStore, user_id: str, chat_id: str, filename: str,
info = images.inspect(spool, declared)
attachment_id = str(uuid.uuid4())
staging = objects.staging_key(attachment_id)
objects.put(staging, spool, size, info.content_type, sha256) # сбой -> 503, строки в БД нет
attachment = store.create_queued_attachment(
attachment_id, user_id, chat_id, filename, info.content_type, size, sha256, info.width, info.height,
staging_key=staging, storage_key=objects.original_key(attachment_id),
actor="api-" + config.INSTANCE_ID)
# Одна транзакция от PUT до COMMIT под блокировкой ID вложения (store.receiving): уборщик
# не тронет staging, пока загрузка не закончилась, даже если строки в БД ещё нет.
with store.receiving(attachment_id) as conn:
objects.put(staging, spool, size, info.content_type, sha256) # сбой -> 503, транзакция откатывается
faults.pause("api_pause_after_staging") # проверка окна «staging записан, строки ещё нет»
attachment = store.create_queued_attachment(
attachment_id, user_id, chat_id, filename, info.content_type, size, sha256, info.width, info.height,
staging_key=staging, storage_key=objects.original_key(attachment_id),
actor="api-" + config.INSTANCE_ID, conn=conn)
faults.hit("api_after_commit") # проверка окна «COMMIT прошёл, до отправки в брокер» (faults.py)
log.info("Вложение %s принято: %d байт, %s, задание в outbox", attachment_id, size, info.content_type)
return attachment
+68 -31
View File
@@ -4,26 +4,42 @@
обработки больше не нужен. Уборщик сверяет содержимое bucket с базой и удаляет то, на что
база не ссылается.
Что нужно и не удаляется (PostgresStore.storage_references):
Что нужно и не удаляется:
- оригинал ready-вложения (originals/<id>) и все его варианты (variants/<id>/...);
- staging-оригинал задания в работе (queued, processing);
- staging-оригинал failed-вложения, пока не прошёл STAGING_RETENTION_SECONDS (24 ч):
оператор может сделать replay.
Всё остальное удаляется, но только если объекту больше grace period (ATTACHMENT_GRACE_SECONDS,
15 мин): так уборщик не заденет загрузку или обработку, которая идёт прямо сейчас (они длятся
секунды, лимит попытки — 60 с). Под удаление попадают:
- ВСЕ объекты вложения в работе (queued, processing): staging читает worker, а оригинал и
варианты он, возможно, пишет прямо сейчас, до COMMIT результата;
- все объекты failed-вложения, пока не прошёл STAGING_RETENTION_SECONDS (24 ч): оператор может
сделать replay, и worker запишет оригинал и варианты заново в те же ключи;
- staging загрузки, которая ещё идёт (PUT уже был, COMMIT строки вложения — ещё нет).
Под удаление попадают объекты старше grace period (ATTACHMENT_GRACE_SECONDS, 15 мин):
- staging уже готового вложения (worker удаляет его сам сразу после COMMIT, сюда попадает,
только если тогда не получилось);
- staging failed-вложения старше retention;
- «сироты»: объекты без строки в БД (API упал между PUT в staging и COMMIT, или worker записал
варианты, а задание потом ушло в failed).
Готовые вложения без объекта (missing) только считаются и пишутся в лог: решает человек.
Повторный и одновременный запуск безопасен: удаление идемпотентно.
- объекты failed-вложения после retention (сначала staging помечается удалённым в БД);
- «сироты»: объекты без строки в БД (API упал между PUT в staging и COMMIT).
Запуск вручную (внутри контейнера worker):
Как уборщик не удаляет текущую работу (замечание к MR). Прежняя версия читала ссылки из БД
один раз и удаляла по этому снимку: если между чтением и удалением оператор делал replay,
staging уже queued-задания удалялся, и worker получал source_missing. Теперь:
1. список объектов и снимок ссылок из БД только отбирают кандидатов (заведомо нужное не трогаем);
2. по каждому вложению-кандидату решение принимается заново, в короткой транзакции под
блокировками (PostgresStore.cleanup_attachment): advisory-блокировка ID вложения (её держит
идущая загрузка), затем строки задания и вложения (их меняют worker и replay). Пока блокировки
у уборщика, состояние не может поменяться;
3. у failed-вложения после retention сначала в БД помечается, что исходника нет
(staging_key = NULL, запись в журнале), и только после COMMIT объекты удаляются из S3:
replay, ждавший блокировку или пришедший позже, видит это и безопасно отказывает;
4. из S3 удаляется только то, что после COMMIT уже не может понадобиться никогда (сирота без
загрузки, staging готового, объекты failed без исходника). Поэтому медленный S3 не держит
блокировки, а оборванная сессия БД не открывает окно для гонки.
Готовые вложения без объекта (missing) только считаются и пишутся в лог: решает человек.
Повторный и одновременный запуск безопасен: удаление идемпотентно, вложение обрабатывает
только тот, кто взял его блокировку.
Запуск вручную (внутри контейнера api или worker):
python -m messenger.cleanup --dry-run # только показать, ничего не удалять
python -m messenger.cleanup # удалить по правилам выше
python -m messenger.cleanup --grace-seconds 5 # для теста: меньший grace period
python -m messenger.cleanup --attachment <id> # только объекты одного вложения
Вывод — одна строка JSON со счётчиками, без ключей доступа.
"""
import argparse
@@ -31,35 +47,54 @@ import json
import logging
import sys
import time
import uuid
from collections import Counter, defaultdict
from datetime import datetime, timedelta, timezone
from . import config, objects
from . import config, faults, objects
from .errors import AppError
from .store import PostgresStore
log = logging.getLogger("messenger.cleanup")
def run_once(store: PostgresStore, grace_seconds: int, retention_seconds: int, dry_run: bool = False) -> dict:
def run_once(store: PostgresStore, grace_seconds: int, retention_seconds: int, dry_run: bool = False,
attachment_id: str | None = None) -> dict:
started = time.monotonic()
# Сначала читаем bucket, потом БД: объект, появившийся между двумя чтениями, — свежий,
# он моложе grace и удалён не будет.
listed = objects.list_objects("")
if attachment_id is None:
listed = objects.list_objects("")
else:
listed = [item for prefix in objects.prefixes_of(attachment_id) for item in objects.list_objects(prefix)]
refs = store.storage_references(retention_seconds)
needed, done = refs["needed"], refs["done"]
faults.pause("cleanup_pause") # проверка гонки: окно между чтением ссылок и удалением
border = datetime.now(timezone.utc) - timedelta(seconds=grace_seconds)
counts = {"staging_after_ready": 0, "staging_failed_expired": 0, "orphan": 0}
deleted = 0
candidates = defaultdict(list) # ID вложения -> его объекты, которые МОГУТ быть лишними
for key, modified in listed:
if key in needed or modified >= border:
if key not in refs["needed"] and modified < border:
candidates[objects.attachment_of(key)].append(key)
counts = {"staging_after_ready": 0, "staging_failed_expired": 0, "orphan": 0}
kept, busy, deleted = Counter(), 0, 0
for owner, keys in candidates.items():
if owner is None:
# Ключ не того вида, что пишут API и worker: никакая текущая работа на него не ссылается.
counts["orphan"] += len(keys)
if not dry_run:
for key in keys:
objects.delete(key)
deleted += len(keys)
continue
reason = done.get(key, "orphan")
counts[reason] += 1
outcome = store.cleanup_attachment(owner, keys, retention_seconds, None if dry_run else objects.delete)
if outcome is None:
busy += len(keys) # идёт загрузка или переход состояния: в следующий раз
continue
for _key, reason in outcome["delete"]:
counts[reason] += 1
for _key, why in outcome["keep"]:
kept[why] += 1 # снимок говорил «лишний», а текущее состояние — «нужен»
if not dry_run:
objects.delete(key)
deleted += 1
deleted += len(outcome["delete"])
in_bucket = {key for key, _ in listed}
missing = len(refs["ready_originals"] - in_bucket)
missing = len(refs["ready_originals"] - in_bucket) if attachment_id is None else 0
if missing:
log.error("В БД есть %d готовых вложений без оригинала в S3 (нужна ручная проверка)", missing)
outbox_deleted = 0 if dry_run else store.delete_old_outbox(config.OUTBOX_RETENTION_SECONDS)
@@ -68,9 +103,9 @@ def run_once(store: PostgresStore, grace_seconds: int, retention_seconds: int, d
prefix = key.split("/", 1)[0] + "/"
by_prefix[prefix] = by_prefix.get(prefix, 0) + 1
return {"dry_run": dry_run, "grace_seconds": grace_seconds, "retention_seconds": retention_seconds,
"to_delete": counts, "deleted": deleted, "missing_ready_originals": missing,
"objects_in_bucket": len(listed), "by_prefix": by_prefix, "outbox_rows_deleted": outbox_deleted,
"seconds": round(time.monotonic() - started, 3)}
"to_delete": counts, "deleted": deleted, "kept_after_recheck": dict(kept), "skipped_busy": busy,
"missing_ready_originals": missing, "objects_in_bucket": len(listed), "by_prefix": by_prefix,
"outbox_rows_deleted": outbox_deleted, "seconds": round(time.monotonic() - started, 3)}
def main(argv=None) -> int:
@@ -78,6 +113,7 @@ def main(argv=None) -> int:
parser.add_argument("--dry-run", action="store_true", help="только посчитать, ничего не удалять")
parser.add_argument("--grace-seconds", type=int, default=config.ATTACHMENT_GRACE_SECONDS)
parser.add_argument("--retention-seconds", type=int, default=config.STAGING_RETENTION_SECONDS)
parser.add_argument("--attachment", type=uuid.UUID, help="только объекты одного вложения")
args = parser.parse_args(argv)
logging.basicConfig(level=logging.WARNING, format="%(levelname)s %(name)s: %(message)s")
config.validate()
@@ -86,7 +122,8 @@ def main(argv=None) -> int:
pool = db.create_pool(application_name="messenger-cleanup", max_size=2)
pool.open()
try:
print(json.dumps(run_once(PostgresStore(pool), args.grace_seconds, args.retention_seconds, args.dry_run)))
print(json.dumps(run_once(PostgresStore(pool), args.grace_seconds, args.retention_seconds, args.dry_run,
str(args.attachment) if args.attachment else None)))
except AppError as exc:
print(json.dumps({"error": exc.message}, ensure_ascii=False))
return 1
+22 -1
View File
@@ -3,7 +3,7 @@
Окна отказа из contracts/attachment-states.md нужно не описать, а воспроизвести: процесс должен
упасть ровно в нужном месте. Для этого в коде расставлены «точки отказа» hit("имя"). Точка
срабатывает, только если:
1. переменная FAULTS_ENABLED=1 (в compose.yaml для стенда; в рабочей среде её нет — точки молчат);
1. переменная FAULTS_ENABLED=1 (в .env учебного стенда, см. .env.example; в рабочей среде её нет — точки молчат);
2. внутри контейнера есть файл /tmp/faults/<имя>. Тест создаёт его через `docker exec`.
Срабатывание одноразовое: файл удаляется ДО падения, поэтому перезапущенный процесс
@@ -19,9 +19,17 @@
Ещё два файла не роняют процесс, а меняют поведение (содержимое файла — число):
- worker_slow каждая обработка дополнительно «работает» N секунд (долгая задача);
- worker_transient следующие N попыток завершаются временной ошибкой (как недоступный S3).
Точки-паузы (замечание к MR про уборщика): процесс один раз ждёт N секунд в опасном месте, чтобы
тест закрепил порядок событий («барьер») и вклинился в окно между двумя шагами:
- cleanup_pause уборщик прочитал ссылки из БД, но ещё ничего не удалял;
- cleanup_pause_locked уборщик под блокировкой вложения решил удалить и пометил staging удалённым,
COMMIT ещё не сделан (replay в это время ждёт блокировку);
- api_pause_after_staging API записал файл в staging, строки вложения в БД ещё нет;
- worker_pause_after_objects worker записал оригинал и варианты в S3, COMMIT результата ещё нет.
"""
import logging
import os
import time
log = logging.getLogger("messenger.faults")
@@ -59,6 +67,19 @@ def number(name: str) -> float:
return 0
def pause(name: str) -> None:
"""Точка-пауза: если включена, удалить её файл (сработает один раз) и подождать N секунд."""
seconds = number(name)
if seconds <= 0:
return
try:
os.remove(_path(name))
except FileNotFoundError:
return
log.warning("FAULT %s: пауза %.1f с (внедрённая задержка для проверки гонок)", name, seconds)
time.sleep(seconds)
def consume(name: str) -> bool:
"""Для worker_transient: уменьшить счётчик на 1. True — эта попытка должна «упасть»."""
left = int(number(name))
+341 -67
View File
@@ -17,10 +17,11 @@
считаются: распакованных байт должно быть ровно столько, сколько требуют ширина,
высота и формат пикселя (иначе файл обрезан или испорчен), а первый байт каждой строки —
допустимый тип фильтра 0–4 (Pillow неверный тип молча пропускает);
- JPEG: маркеры и длины сегментов, один кадр SOF (baseline, extended или progressive)
с ненулевыми размерами, хотя бы один непустой скан SOS, маркер конца EOI.
Глубокую проверку (каждый пиксель, строгое декодирование JPEG) делает worker: если файл
не декодируется, вложение получает failed с error_code=invalid_image.
- JPEG: всё, что строгий декодер worker проверяет по маркерам и заголовкам: маркеры и длины
сегментов, кадр SOF, таблицы DQT/DHT, связь каждого скана SOS с компонентами кадра,
параметры сканов, порядок и число маркеров RST, маркер конца EOI (подробно — ниже, у check_jpeg).
Глубокую проверку (каждый пиксель, строгое декодирование сжатых данных JPEG) делает worker:
если файл не декодируется, вложение получает failed с error_code=invalid_image.
"""
import struct
import threading
@@ -297,71 +298,344 @@ def check_png(f, width: int, height: int) -> None:
# ---------- JPEG ----------
#
# Где граница между 415 и failed (contracts/README.md: «заведомо повреждённые/чужие форматы — 415»).
# Worker декодирует JPEG библиотекой libjpeg-turbo в строгом режиме (imaging.py): любое её
# предупреждение — ошибка. Всё, что она проверяет по маркерам и заголовкам, то есть ДО распаковки
# сжатых данных, API проверяет здесь сам, теми же правилами. Поэтому такой файл получает 415 сразу,
# а не 202 и потом failed. На worker остаются только ошибки внутри сжатых данных скана: их не найти,
# не декодировав каждый блок 8×8 (это и есть тяжёлая работа, которую API не делает).
#
# Что проверяется (правила libjpeg-turbo: jdmarker.c, jdinput.c, jdhuff.c, jdphuff.c, turbojpeg.c,
# и спецификации JPEG ITU-T T.81; совпадение с настоящим декодером проверяет тест в образе,
# student-tests/worker/test_imaging.py):
# - маркеры: только известные, без мусора между сегментами, длины сегментов, один SOI, EOI в конце;
# - кадр SOF: baseline/extended/progressive с кодом Хаффмана, 8 бит, размеры до 65500, 1/3/4 компонента
# с разными идентификаторами, коэффициенты субдискретизации 1–4 и схема, которую понимает декодер;
# - таблицы DQT/DHT/DAC/DRI: номера, размеры, коды Хаффмана помещаются в свою длину (иначе
# «Bogus Huffman table»), символы DC-таблиц 0–15; таблица должна быть определена до скана;
# - скан SOS: каждый компонент есть в SOF и не повторяется в скане, блоков в MCU не больше 10,
# параметры Ss/Se/Ah/Al (для последовательного JPEG 0/63/0/0, для прогрессивного — допустимая
# последовательность сканов), маркеры RST идут по порядку и их ровно столько, сколько задаёт DRI;
# - APP0 JFIF версии 1 и допустимый код преобразования Adobe (APP14).
# Кадры, которые умеет декодировать libjpeg-turbo в Pillow: baseline, extended, progressive (Хаффман).
# Кадры, которые декодирует libjpeg-turbo в Pillow: baseline, extended, progressive (код Хаффмана).
_SOF_SUPPORTED = {0xC0, 0xC1, 0xC2}
_SOF_OTHER = {0xC3, 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF}
_SOF_OTHER = {0xC3, 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF} # lossless, arithmetic, hierarchical
# Сегменты, которые декодер разбирает или пропускает: DHT, DAC, DQT, DNL, DRI, APP0–APP15, COM.
# Остальные маркеры (JPG, DHP, EXP, JPGn, RES, TEM, RSTn вне скана) декодер считает ошибкой.
_SEGMENTS = {0xC4, 0xCC, 0xDB, 0xDC, 0xDD, 0xFE} | set(range(0xE0, 0xF0))
_JPEG_MAX_DIMENSION = 65500 # JPEG_MAX_DIMENSION libjpeg
_MAX_BLOCKS_IN_MCU = 10 # D_MAX_BLOCKS_IN_MCU libjpeg
# Схемы субдискретизации, которые понимает декодер worker (TurboJPEG): коэффициенты яркости при
# коэффициентах цветности 1×1 — 4:4:4, 4:2:2, 4:2:0, 4:4:0, 4:1:1. Оттенки серого — любые.
_LUMA_FACTORS = {(1, 1), (2, 1), (2, 2), (1, 2), (4, 1)}
def _subsampling_supported(factors: list[tuple[int, int]]) -> bool:
"""Распознаёт ли TurboJPEG схему субдискретизации (как getSubsamp в turbojpeg.c)."""
if len(factors) == 1:
return True
luma, chroma, black = factors[0], factors[1:3], factors[3:] # black — 4-й канал CMYK/YCCK
if luma in _LUMA_FACTORS and all(c == (1, 1) for c in chroma) and all(k == luma for k in black):
return True
if (luma == (2, 2) and chroma[0] == chroma[1] and chroma[0] in ((1, 2), (2, 1))
and all(k == (2, 2) for k in black)):
return True # 4:2:2 и 4:4:0, записанные «нестандартно» (яркость 2×2)
return luma[0] * luma[1] <= 3 and all(f == luma for f in factors[1:]) # 4:4:4: все коэффициенты равны
def _huffman_codes_fit(counts: bytes) -> bool:
"""Канонические коды Хаффмана помещаются в свои длины, и нет кода из одних единиц (рисунок C.2 T.81)."""
code = 0
for length, count in enumerate(counts, start=1):
code += count
if code >= 1 << length:
return False
code <<= 1
return True
@dataclass
class _Component:
ident: int
h: int
v: int
quant: int
quant_latched: bool = False # таблица квантования берётся при первом скане компонента
scans: int = 0
coef_bits: list | None = None # прогрессивный JPEG: последний Al каждого коэффициента, -1 — ещё не было
class _JpegCheck:
def __init__(self, data: bytes, width: int, height: int):
self.data, self.n, self.width, self.height = data, len(data), width, height
self.i = 2
self.components: list[_Component] | None = None
self.progressive = False
self.hmax = self.vmax = 1
self.quant: set[int] = set()
self.huffman: dict[tuple[int, int], tuple[bytes, bytes]] = {} # (0 — DC / 1 — AC, номер) -> (счётчики, символы)
self.restart_interval = 0
self.jfif = False
self.adobe_transform = None
self.scans = 0
self.full_scan = False # первый последовательный скан уже содержал все компоненты
def run(self) -> None:
if not self.data.startswith(b"\xff\xd8"):
raise Broken("нет маркера начала SOI")
while True:
marker = self._marker()
if marker == 0xD9: # EOI: конец картинки
break
if marker in _SOF_OTHER:
raise Broken("неподдерживаемый вид JPEG (lossless, arithmetic или hierarchical)")
if marker == 0xD8:
raise Broken("второй маркер SOI")
if marker not in _SOF_SUPPORTED and marker != 0xDA and marker not in _SEGMENTS:
raise Broken(f"недопустимый маркер 0x{marker:02X}")
segment = self._segment()
if marker in _SOF_SUPPORTED:
self._frame(marker, segment)
elif marker == 0xDA:
self._scan(segment)
elif marker == 0xC4:
self._dht(segment)
elif marker == 0xDB:
self._dqt(segment)
elif marker == 0xCC:
self._dac(segment)
elif marker == 0xDD:
if len(segment) != 2:
raise Broken("неверная длина DRI")
self.restart_interval = (segment[0] << 8) | segment[1]
elif marker == 0xE0 and len(segment) >= 14 and segment[:5] == b"JFIF\x00":
if segment[5] != 1:
raise Broken("неизвестная версия JFIF")
self.jfif = self.jfif or self.scans == 0
elif marker == 0xEE and len(segment) >= 12 and segment[:5] == b"Adobe" and self.scans == 0:
self.adobe_transform = segment[11]
if self.components is None or self.scans == 0:
raise Broken("нет данных изображения")
if not self.progressive and any(c.scans == 0 for c in self.components):
raise Broken("не все компоненты цвета закодированы в сканах")
# Данные ПОСЛЕ EOI допускаются: так устроены многие реальные фото (превью, «живые фото»).
# Клиенту файл отдаётся с Content-Type image/jpeg и nosniff, а варианты делаются заново.
def _marker(self) -> int:
data, n = self.data, self.n
if self.i >= n or data[self.i] != 0xFF:
raise Broken("лишние байты там, где должен быть маркер: файл испорчен или обрезан")
while self.i < n and data[self.i] == 0xFF: # байты-заполнители перед маркером
self.i += 1
if self.i >= n:
raise Broken("файл обрывается на маркере")
self.i += 1
return data[self.i - 1]
def _segment(self) -> bytes:
i = self.i
if i + 2 > self.n:
raise Broken("файл обрывается в сегменте")
length = (self.data[i] << 8) | self.data[i + 1]
if length < 2 or i + length > self.n:
raise Broken("неверная длина сегмента")
self.i = i + length
return self.data[i + 2:i + length]
def _frame(self, marker: int, segment: bytes) -> None:
if self.components is not None:
raise Broken("второй заголовок кадра SOF")
if len(segment) < 6:
raise Broken("неверный заголовок кадра SOF")
precision, rows, cols, count = struct.unpack(">BHHB", segment[:6])
if precision != 8:
raise Broken("поддерживается только 8 бит на канал")
if (cols, rows) != (self.width, self.height):
raise Broken("неверный заголовок кадра SOF")
if cols > _JPEG_MAX_DIMENSION or rows > _JPEG_MAX_DIMENSION:
raise Broken(f"ширина или высота больше {_JPEG_MAX_DIMENSION}")
if count not in (1, 3, 4) or len(segment) != 6 + 3 * count:
raise Broken("неверное число компонентов цвета в SOF (допустимо 1, 3 или 4)")
components = []
for k in range(count):
ident, factors, quant = segment[6 + 3 * k:9 + 3 * k]
h, v = factors >> 4, factors & 15
if not (1 <= h <= 4 and 1 <= v <= 4):
raise Broken("недопустимые коэффициенты субдискретизации")
if quant > 3:
raise Broken("неверный номер таблицы квантования")
if any(c.ident == ident for c in components):
raise Broken("повторяется идентификатор компонента в SOF")
components.append(_Component(ident, h, v, quant))
self.components = components
self.progressive = marker == 0xC2
self.hmax = max(c.h for c in components)
self.vmax = max(c.v for c in components)
def _dht(self, segment: bytes) -> None:
rest = segment
while rest:
if len(rest) < 17:
raise Broken("неверная таблица Хаффмана DHT")
index, counts = rest[0], rest[1:17]
total = sum(counts)
if total > 256 or total > len(rest) - 17:
raise Broken("неверная таблица Хаффмана DHT")
kind, number = (1, index - 0x10) if index & 0x10 else (0, index)
if not 0 <= number <= 3:
raise Broken("неверный номер таблицы Хаффмана")
self.huffman[(kind, number)] = (bytes(counts), bytes(rest[17:17 + total]))
rest = rest[17 + total:]
def _dqt(self, segment: bytes) -> None:
rest = segment
while rest:
precision, number = rest[0] >> 4, rest[0] & 15
if precision > 1 or number > 3:
raise Broken("неверная таблица квантования DQT")
size = 1 + 64 * (precision + 1)
if len(rest) < size:
raise Broken("таблица квантования DQT обрезана")
self.quant.add(number)
rest = rest[size:]
def _dac(self, segment: bytes) -> None:
if len(segment) % 2:
raise Broken("неверная длина DAC")
for k in range(0, len(segment), 2):
index, value = segment[k], segment[k + 1]
if index >= 32 or (index < 16 and (value & 15) > (value >> 4)):
raise Broken("неверный сегмент DAC")
def _huffman_table(self, kind: int, number: int) -> None:
"""Таблица, которую использует скан: определена и правильна (jpeg_make_d_derived_tbl)."""
if number > 3:
raise Broken("номер таблицы Хаффмана больше 3")
table = self.huffman.get((kind, number))
if table is None:
if not self.progressive and number <= 1:
return # последовательный декодер подставит стандартную таблицу (так пишет Motion JPEG)
raise Broken("скан использует неопределённую таблицу Хаффмана")
counts, symbols = table
if not symbols or not _huffman_codes_fit(counts):
raise Broken("неверная таблица Хаффмана: коды не помещаются в свою длину")
if kind == 0 and max(symbols) > 15:
raise Broken("неверная таблица Хаффмана DC")
def _first_scan(self) -> None:
"""Перед первым сканом декодер выбирает цветовое пространство и схему субдискретизации."""
count = len(self.components)
if count == 3 and not self.jfif and self.adobe_transform not in (None, 0, 1):
raise Broken("неизвестный код цветового преобразования Adobe")
if count == 4 and self.adobe_transform not in (None, 0, 2):
raise Broken("неизвестный код цветового преобразования Adobe")
if not _subsampling_supported([(c.h, c.v) for c in self.components]):
raise Broken("неподдерживаемая схема субдискретизации цвета")
def _scan(self, segment: bytes) -> None:
if self.components is None:
raise Broken("скан раньше заголовка кадра")
if self.scans == 0:
self._first_scan()
count = segment[0] if segment else 0
if not 1 <= count <= 4 or len(segment) != 4 + 2 * count:
raise Broken("неверный заголовок скана SOS")
members = []
for k in range(count):
ident, tables = segment[1 + 2 * k], segment[2 + 2 * k]
component = next((c for c in self.components if c.ident == ident), None)
if component is None:
raise Broken("скан ссылается на компонент, которого нет в заголовке кадра SOF")
if any(component is m[0] for m in members):
raise Broken("компонент повторяется в одном скане")
members.append((component, tables >> 4, tables & 15))
if count > 1 and sum(c.h * c.v for c, _dc, _ac in members) > _MAX_BLOCKS_IN_MCU:
raise Broken("слишком много блоков в MCU")
ss, se, ah, al = segment[-3], segment[-2], segment[-1] >> 4, segment[-1] & 15
if self.progressive:
self._progressive(members, ss, se, ah, al)
else:
self._sequential(members, ss, se, ah, al)
for component, _dc, _ac in members:
if not component.quant_latched:
if component.quant not in self.quant:
raise Broken("компонент использует неопределённую таблицу квантования")
component.quant_latched = True
restarts = self._entropy_data()
expected = (self._mcus(members) - 1) // self.restart_interval if self.restart_interval else 0
if restarts != expected:
raise Broken("маркеров RST не столько, сколько задаёт интервал DRI")
self.scans += 1
def _sequential(self, members, ss, se, ah, al) -> None:
if (ss, se, ah, al) != (0, 63, 0, 0):
raise Broken("неверные параметры Ss/Se/Ah/Al для последовательного JPEG")
if self.full_scan:
raise Broken("лишний скан: первый скан уже содержал все компоненты")
if self.scans == 0 and len(members) == len(self.components):
self.full_scan = True
for component, dc, ac in members:
if component.scans:
raise Broken("компонент закодирован в двух сканах")
component.scans += 1
self._huffman_table(0, dc)
self._huffman_table(1, ac)
def _progressive(self, members, ss, se, ah, al) -> None:
dc_band = ss == 0
bad = se != 0 if dc_band else (ss > se or se > 63 or len(members) != 1)
if bad or (ah and al != ah - 1) or al > 13:
raise Broken("неверные параметры прогрессивного скана")
for component, dc, ac in members:
bits = component.coef_bits = component.coef_bits or [-1] * 64
if not dc_band and bits[0] < 0:
raise Broken("прогрессивный скан: коэффициенты AC раньше DC")
for k in range(ss, se + 1):
if ah != max(bits[k], 0):
raise Broken("нарушена последовательность прогрессивных сканов")
bits[k] = al
component.scans += 1
if dc_band:
if ah == 0: # уточняющему DC-скану таблица не нужна
self._huffman_table(0, dc)
else:
self._huffman_table(1, ac)
def _mcus(self, members) -> int:
"""Сколько MCU в скане (per_scan_setup libjpeg): от этого зависит число маркеров RST."""
if len(members) == 1:
c = members[0][0]
return (-(-self.width * c.h // (self.hmax * 8))) * (-(-self.height * c.v // (self.vmax * 8)))
return (-(-self.width // (self.hmax * 8))) * (-(-self.height // (self.vmax * 8)))
def _entropy_data(self) -> int:
"""Пройти сжатые данные скана до следующего маркера. Возвращает число маркеров RST."""
data, n = self.data, self.n
start = i = self.i
restarts = 0
while True:
j = data.find(b"\xff", i)
if j < 0 or j + 1 >= n:
raise Broken("скан обрывается: нет маркера конца EOI (файл обрезан)")
following = data[j + 1]
if following == 0x00: # FF 00 — байт FF внутри данных
i = j + 2
elif following == 0xFF: # заполнитель перед маркером
i = j + 1
elif 0xD0 <= following <= 0xD7: # RSTn: номера идут по кругу 0..7, с 0 в каждом скане
if following != 0xD0 + restarts % 8:
raise Broken("маркеры RST идут не по порядку")
restarts += 1
i = j + 2
else:
break
if j == start:
raise Broken("пустой скан: нет сжатых данных изображения")
self.i = j
return restarts
def check_jpeg(data: bytes, width: int, height: int) -> None:
n = len(data)
if not data.startswith(b"\xff\xd8"):
raise Broken("нет маркера начала SOI")
i, frame, scans = 2, None, 0
while True:
if i >= n or data[i] != 0xFF:
raise Broken("ожидался маркер: файл обрезан или испорчен")
while i < n and data[i] == 0xFF: # байты-заполнители перед маркером
i += 1
if i >= n:
raise Broken("файл обрывается на маркере")
marker = data[i]
i += 1
if marker == 0xD9: # EOI: конец картинки
break
if marker == 0x01: # TEM: маркер без длины
continue
if marker in (0x00, 0xD8) or 0xD0 <= marker <= 0xD7:
raise Broken("неожиданный маркер")
if i + 2 > n:
raise Broken("файл обрывается в сегменте")
length = (data[i] << 8) | data[i + 1]
if length < 2 or i + length > n:
raise Broken("неверная длина сегмента")
segment = data[i + 2:i + length]
if marker in _SOF_SUPPORTED or marker in _SOF_OTHER:
if marker in _SOF_OTHER:
raise Broken("неподдерживаемый вид JPEG (lossless, arithmetic или hierarchical)")
if frame is not None or len(segment) < 6:
raise Broken("неверный заголовок кадра SOF")
rows, cols, components = struct.unpack(">HHB", segment[1:6])
if (cols, rows) != (width, height) or not 1 <= components <= 4 or len(segment) != 6 + 3 * components:
raise Broken("неверный заголовок кадра SOF")
frame = (cols, rows)
i += length
if marker == 0xDA: # SOS: дальше идут сжатые данные скана
if frame is None:
raise Broken("скан раньше заголовка кадра")
if not segment or not 1 <= segment[0] <= 4 or len(segment) != 4 + 2 * segment[0]:
raise Broken("неверный заголовок скана SOS")
start = i
while True: # конец скана — первый маркер, кроме FF00 и RSTn
j = data.find(b"\xff", i)
if j < 0 or j + 1 >= n:
raise Broken("скан обрывается: нет маркера конца EOI (файл обрезан)")
following = data[j + 1]
if following == 0x00 or 0xD0 <= following <= 0xD7:
i = j + 2
continue
if following == 0xFF:
i = j + 1
continue
break
if j == start:
raise Broken("пустой скан: нет сжатых данных изображения")
scans += 1
i = j
if frame is None or scans == 0:
raise Broken("нет данных изображения")
# Данные ПОСЛЕ EOI допускаются: так устроены многие реальные фото (превью, «живые фото»).
# Клиенту файл отдаётся с Content-Type image/jpeg и nosniff, а варианты делаются заново.
_JpegCheck(data, width, height).run()
+4 -2
View File
@@ -96,8 +96,10 @@ def _strict_jpeg_check(data: bytes) -> None:
_h, _w, colorspace, _sub = simplejpeg.decode_jpeg_header(data)
target = "CMYK" if colorspace in ("CMYK", "YCCK") else ("GRAY" if colorspace == "Gray" else "RGB")
simplejpeg.decode_jpeg(data, colorspace=target, strict=True, min_factor=8)
except ValueError:
raise InvalidImage("JPEG повреждён: libjpeg-turbo в строгом режиме нашёл ошибку") from None
except (ValueError, KeyError):
# KeyError: simplejpeg не знает некоторых схем субдискретизации TurboJPEG 3 (например, 4:4:1).
# API такие JPEG отклоняет сам (images._subsampling_supported), здесь — вторая линия защиты.
raise InvalidImage("JPEG повреждён или не поддерживается: libjpeg-turbo в строгом режиме нашёл ошибку") from None
def _orientation(img) -> int:
+44 -24
View File
@@ -113,6 +113,10 @@ def create(conn, attachment_id, actor: str) -> uuid.UUID:
_CLEAR_LEASE = "lease_owner = NULL, lease_token = NULL, lease_until = NULL"
class LockBusy(Exception):
"""Строку задания дольше lock_timeout держит другая транзакция (уборщик, worker)."""
class JobStore:
def __init__(self, pool, actor: str):
self.pool = pool
@@ -306,40 +310,56 @@ class JobStore:
# ---------- оператор ----------
def _job_of(self, conn, attachment_id: str, lock: bool = False):
return conn.execute(
f"""SELECT j.job_id, j.status, j.attempt, j.last_error_code, a.staging_key, a.error_code
FROM attachment_jobs j JOIN attachments a ON a.id = j.attachment_id
WHERE j.attachment_id = %s AND j.pipeline_version = %s {'FOR UPDATE OF j' if lock else ''}""",
(uuid.UUID(attachment_id), config.PIPELINE_VERSION)).fetchone()
def replay(self, attachment_id: str, staging_exists) -> dict:
"""failed -> queued по команде оператора. Готовое или ещё идущее задание НЕ повторяется."""
"""failed -> queued по команде оператора. Готовое или ещё идущее задание НЕ повторяется.
Всё в ОДНОЙ транзакции под блокировкой строк задания и вложения — тех же, что берёт уборщик
(store.cleanup_attachment), в том же порядке. Поэтому уборщик не удалит staging между
проверкой исходника и переводом в queued (замечание к MR):
- уборщик успел раньше: он уже пометил staging удалённым (staging_key = NULL) и удалил его,
replay ждал блокировку и теперь безопасно отказывает (source_missing), задание остаётся failed;
- replay успел раньше: уборщик ждёт блокировку, потом видит queued — исходник нужен текущей
работе, и он его не трогает.
Наличие объекта в S3 (staging_exists) проверяется тоже под блокировкой.
"""
aid = uuid.UUID(attachment_id)
try:
return self._replay(aid, staging_exists)
except LockBusy:
return {"result": "busy", "detail": "вложение сейчас обрабатывает уборщик или worker, повторите позже"}
def _replay(self, aid: uuid.UUID, staging_exists) -> dict:
with self._tx() as conn:
row = self._job_of(conn, attachment_id)
if row is None:
return {"result": "not_found"}
job_id, status, attempt, last_code, staging_key, error_code = row
# Команда оператора может подождать блокировку дольше обычного запроса (5 с).
conn.execute("SET LOCAL lock_timeout = '20s'")
conn.execute("SET LOCAL statement_timeout = '25s'")
try:
row = conn.execute("""SELECT job_id, status, attempt, last_error_code FROM attachment_jobs
WHERE attachment_id = %s AND pipeline_version = %s FOR UPDATE""",
(aid, config.PIPELINE_VERSION)).fetchone()
if row is None:
return {"result": "not_found"}
staging_key, error_code = conn.execute(
"SELECT staging_key, error_code FROM attachments WHERE id = %s FOR UPDATE", (aid,)).fetchone()
except psycopg.errors.LockNotAvailable:
raise LockBusy() from None
job_id, status, attempt, last_code = row
if status != "failed":
event(conn, job_id, uuid.UUID(attachment_id), attempt, "replay_refused", self.actor,
event(conn, job_id, aid, attempt, "replay_refused", self.actor,
f"задание в состоянии {status}: повторять нечего")
return {"result": "noop", "reason": status}
if not staging_key or not staging_exists(staging_key):
return {"result": "refused", "reason": "source_missing",
"detail": "оригинал в staging уже удалён (истёк STAGING_RETENTION_SECONDS)"}
with self._tx() as conn:
row = self._job_of(conn, attachment_id, lock=True)
job_id, status, attempt, last_code, staging_key, error_code = row
if status != "failed": # пока проверяли S3, статус поменялся
return {"result": "noop", "reason": status}
if not staging_key or not staging_exists(staging_key):
detail = "оригинал в staging уже удалён (истёк STAGING_RETENTION_SECONDS)"
event(conn, job_id, aid, attempt, "replay_refused", self.actor, "source_missing: " + detail)
return {"result": "refused", "reason": "source_missing", "detail": detail}
new_attempt = attempt + 1
conn.execute(f"""UPDATE attachment_jobs SET status = 'queued', attempt = %s, max_attempts = %s,
{_CLEAR_LEASE}, next_attempt_at = now(), finished_at = NULL, updated_at = now()
WHERE job_id = %s""", (new_attempt, attempt + config.JOB_MAX_ATTEMPTS, job_id))
conn.execute("""UPDATE attachments SET status = 'queued', error_code = NULL, updated_at = now()
WHERE id = %s AND status = 'failed'""", (uuid.UUID(attachment_id),))
enqueue(conn, job_id, uuid.UUID(attachment_id), config.PIPELINE_VERSION, new_attempt)
event(conn, job_id, uuid.UUID(attachment_id), new_attempt, "replay_requested", self.actor,
WHERE id = %s AND status = 'failed'""", (aid,))
enqueue(conn, job_id, aid, config.PIPELINE_VERSION, new_attempt)
event(conn, job_id, aid, new_attempt, "replay_requested", self.actor,
f"replay оператора: было {error_code} (последняя ошибка {last_code}); "
f"новая попытка {new_attempt}, ещё {config.JOB_MAX_ATTEMPTS} попыток")
return {"result": "queued", "attempt": new_attempt, "previous_error": error_code}
+17
View File
@@ -81,6 +81,23 @@ def variant_key(attachment_id: str, pipeline_version: int, name: str, extension:
return f"{VARIANTS_PREFIX}{uuid.UUID(attachment_id)}/v{int(pipeline_version)}/{name}{extension}"
def attachment_of(key: str) -> str | None:
"""ID вложения, которому принадлежит ключ: staging/<id>, originals/<id>, variants/<id>/...
Для ключа другого вида — None (уборщик решает по ключу, к какому вложению идти за блокировкой)."""
for prefix in (STAGING_PREFIX, PREFIX, VARIANTS_PREFIX):
if key.startswith(prefix):
try:
return str(uuid.UUID(key[len(prefix):].split("/", 1)[0]))
except ValueError:
return None
return None
def prefixes_of(attachment_id: str) -> list[str]:
"""Префиксы всех объектов одного вложения (для уборки одного вложения: cleanup --attachment)."""
return [staging_key(attachment_id), original_key(attachment_id), f"{VARIANTS_PREFIX}{uuid.UUID(attachment_id)}/"]
def client():
"""Один клиент на процесс (клиенты boto3 потокобезопасны), создаётся при первом обращении."""
global _client
+148 -16
View File
@@ -21,7 +21,7 @@ import psycopg
from psycopg import errors as pg_errors
from psycopg_pool import ConnectionPool, PoolTimeout
from . import config, jobs
from . import config, faults, jobs
from .errors import Conflict, InvalidRequest, NotFound, Unavailable
log = logging.getLogger("messenger.store")
@@ -131,6 +131,43 @@ _ATTACHMENT_COLUMNS = ("a.id, a.chat_id, a.owner_id, a.filename, a.content_type,
"a.status, a.created_at, a.updated_at, a.storage_key, a.error_code, " + _VARIANTS)
# Advisory-блокировки PostgreSQL по ID вложения (замечание к MR про уборщика): пространство «l5»,
# чтобы не пересечься с другими advisory-блокировками. Ключ — первые 32 бита UUID: совпадение у двух
# вложений возможно, но безвредно (уборщик пропустит одно из них до следующего прохода).
_LOCK_NAMESPACE = 0x6C35
def attachment_lock(attachment_id: str) -> tuple[int, int]:
return _LOCK_NAMESPACE, int.from_bytes(uuid.UUID(attachment_id).bytes[:4], "big", signed=True)
def _cleanup_decision(row, variant_keys: set, key: str) -> tuple[str, str]:
"""Можно ли удалить объект key вложения, если row — его ТЕКУЩЕЕ состояние (прочитано под блокировкой).
row = (status, staging_key, storage_key, failed и retention истёк) или None (строки нет).
Возвращает ("delete" | "keep", причина). «delete» дан только там, где удаление безопасно
навсегда: объект удаляется уже после COMMIT, без блокировок, и состояние к тому времени может
поменяться только так, что этот объект всё равно никому не понадобится.
"""
if row is None:
# Строки нет, а блокировку ID никто не держит: загрузка с этим ID закончилась без COMMIT
# (новая загрузка всегда получает новый UUID), строка не появится уже никогда.
return "delete", "orphan"
status, staging_key, storage_key, expired = row
if status in ("queued", "processing"):
return "keep", "current_work" # worker может прямо сейчас читать staging и писать результат
if status == "ready": # ready не меняется (replay готового — no-op)
if key == storage_key or key in variant_keys:
return "keep", "published"
return ("delete", "staging_after_ready") if key == staging_key else ("delete", "orphan")
# failed: пока не истёк retention и исходник на месте, возможен replay — он заново запишет оригинал
# и варианты в те же ключи, поэтому ничего не трогаем. После retention staging помечается удалённым
# (staging_key = NULL): replay уже невозможен, и все объекты вложения можно удалить.
if not expired and staging_key is not None:
return "keep", "staging_kept_for_replay" if key == staging_key else "failed_kept_for_replay"
return "delete", "staging_failed_expired" if key.startswith("staging/") else "orphan"
def _attachment(row) -> tuple[Attachment, str]:
"""(вложение для ответа, ключ оригинала в S3 — только для сервера)."""
return (Attachment(str(row[0]), str(row[1]), str(row[2]), row[3], row[4], int(row[5]), row[6], row[7],
@@ -355,26 +392,47 @@ class PostgresStore:
# --- вложения: метаданные здесь, байты в S3 ---
@contextmanager
def receiving(self, attachment_id: str):
"""Транзакция приёма файла (замечание к MR про уборщика).
Блокировка ID вложения (advisory, attachment_lock) берётся ДО записи в staging и держится
до COMMIT строки вложения. Уборщик (cleanup_attachment) берёт ту же блокировку без ожидания:
пока загрузка идёт, её staging для него «занят», даже если строки в БД ещё нет. Упал API —
PostgreSQL сам снимает блокировку вместе с сессией, и объект без строки уберётся как «сирота».
Если процесс API завис посреди загрузки, сессию закроет idle_in_transaction_session_timeout
(30 с: запись в staging ограничена 6 с, остальное — запас для медленного диска и точки-паузы теста).
"""
with self._conn() as conn, conn.transaction():
conn.execute("SET LOCAL idle_in_transaction_session_timeout = '30s'")
conn.execute("SELECT pg_advisory_xact_lock(%s, %s)", attachment_lock(attachment_id))
yield conn
def create_queued_attachment(self, attachment_id: str, user_id: str, chat_id: str, filename: str,
content_type: str, size_bytes: int, sha256: str, width: int, height: int,
staging_key: str, storage_key: str, actor: str) -> Attachment:
staging_key: str, storage_key: str, actor: str, conn=None) -> Attachment:
"""Устойчивый приём (с lab5): оригинал уже в staging S3; теперь одной транзакцией —
вложение (queued), задание и строка outbox для брокера. После COMMIT можно отвечать 202.
conn — транзакция receiving(), в которой оригинал записывался в staging (attachments.py).
Вставка вложения идёт, только если пользователь — участник чата (иначе 404).
"""
with self._conn() as conn, conn.transaction():
row = conn.execute(
f"""INSERT INTO attachments AS a (id, chat_id, owner_id, filename, content_type, size_bytes,
sha256, width, height, storage_key, staging_key, status)
SELECT %s, cm.chat_id, cm.user_id, %s, %s, %s, %s, %s, %s, %s, %s, 'queued'
FROM chat_members cm WHERE cm.chat_id = %s AND cm.user_id = %s
RETURNING {_ATTACHMENT_COLUMNS}""",
(uuid.UUID(attachment_id), filename, content_type, size_bytes, sha256, width, height,
storage_key, staging_key, uuid.UUID(chat_id), uuid.UUID(user_id))).fetchone()
if row is None:
raise NotFound("Чат не найден")
jobs.create(conn, row[0], actor)
if conn is None:
with self.receiving(attachment_id) as conn:
return self.create_queued_attachment(attachment_id, user_id, chat_id, filename, content_type,
size_bytes, sha256, width, height, staging_key, storage_key,
actor, conn)
row = conn.execute(
f"""INSERT INTO attachments AS a (id, chat_id, owner_id, filename, content_type, size_bytes,
sha256, width, height, storage_key, staging_key, status)
SELECT %s, cm.chat_id, cm.user_id, %s, %s, %s, %s, %s, %s, %s, %s, 'queued'
FROM chat_members cm WHERE cm.chat_id = %s AND cm.user_id = %s
RETURNING {_ATTACHMENT_COLUMNS}""",
(uuid.UUID(attachment_id), filename, content_type, size_bytes, sha256, width, height,
storage_key, staging_key, uuid.UUID(chat_id), uuid.UUID(user_id))).fetchone()
if row is None:
raise NotFound("Чат не найден")
jobs.create(conn, row[0], actor)
return _attachment(row)[0]
def get_attachment(self, user_id: str, attachment_id: str) -> tuple[Attachment, str]:
@@ -411,11 +469,13 @@ class PostgresStore:
# --- для уборщика (cleanup.py) ---
def storage_references(self, retention_seconds: int) -> dict:
"""Какие объекты S3 нужны: ключ -> причина. Всё остальное старше grace уборщик удалит.
"""Снимок ссылок для ПРЕДВАРИТЕЛЬНОГО отбора: ключ -> причина, почему объект нужен.
Нужны: оригиналы ready-вложений, их варианты, staging-оригиналы заданий в работе
(queued, processing) и staging failed-вложений моложе retention (для replay).
Отдельно — ключи staging, которые больше не нужны, с причиной (для отчёта уборщика).
Снимок только отсекает заведомо нужное. Удалять по нему нельзя: пока уборщик идёт по
списку, состояние меняется (замечание к MR). Окончательно решает cleanup_attachment
под блокировками по текущему состоянию.
"""
with self._conn() as conn:
rows = conn.execute(
@@ -442,6 +502,78 @@ class PostgresStore:
ready_originals = {key for key, why in needed.items() if why == "original"}
return {"needed": needed, "done": done, "ready_originals": ready_originals}
def cleanup_attachment(self, attachment_id: str, keys: list[str], retention_seconds: int,
delete=None, actor: str = "cleanup") -> dict | None:
"""Уборка объектов ОДНОГО вложения: решение принимается заново, под блокировками (замечание к MR).
Снимок ссылок (storage_references) мог устареть, пока уборщик шёл по списку: оператор сделал
replay, загрузка закоммитила строку, worker записал объекты. Поэтому две фазы.
Фаза 1 — короткая транзакция:
1. advisory-блокировка ID вложения без ожидания — её держит идущая загрузка (receiving):
занято -> None, объекты остаются до следующего прохода;
2. блокировка строк задания и вложения (FOR NO KEY UPDATE; порядок тот же, что у claim,
complete и replay: сначала задание, потом вложение) — переходы состояния ждут, а уборщик
читает ТЕКУЩЕЕ состояние;
3. решение (_cleanup_decision). Если удаляется staging истёкшего failed-вложения, он сначала
помечается в БД удалённым (staging_key = NULL, запись staging_expired в журнале) — COMMIT.
Replay, который ждал блокировку или придёт позже, видит, что исходника нет, и отказывает.
Фаза 2 — удаление из S3 уже без блокировок. Удаляется только то, что после фазы 1 не может
понадобиться никогда (см. _cleanup_decision), поэтому медленный S3 не держит блокировки,
а оборванная сессия БД не открывает окно для гонки.
delete=None — пробный прогон: решения те же, но ничего не меняется.
Возвращает {"delete": [(ключ, причина)], "keep": [(ключ, почему)]} или None (занято).
"""
aid = uuid.UUID(attachment_id)
with self._conn() as conn:
try:
with conn.transaction():
if not conn.execute("SELECT pg_try_advisory_xact_lock(%s, %s)",
attachment_lock(attachment_id)).fetchone()[0]:
return None
conn.execute("SET LOCAL lock_timeout = '3s'")
# Транзакция короткая; запас — для медленной базы и точки-паузы теста (faults.py).
conn.execute("SET LOCAL idle_in_transaction_session_timeout = '30s'")
job_rows = conn.execute("""SELECT job_id, attempt FROM attachment_jobs WHERE attachment_id = %s
FOR NO KEY UPDATE""", (aid,)).fetchall()
row = conn.execute(
"""SELECT status, staging_key, storage_key,
status = 'failed' AND updated_at < now() - make_interval(secs => %s)
FROM attachments WHERE id = %s FOR NO KEY UPDATE""", (retention_seconds, aid)).fetchone()
variant_keys = {r[0] for r in conn.execute(
"SELECT storage_key FROM attachment_variants WHERE attachment_id = %s", (aid,))}
decisions = [(key, *_cleanup_decision(row, variant_keys, key)) for key in keys]
orphans = [key for key, action, why in decisions if why == "orphan"]
if orphans:
# Страховка: ключ «чужого» вида (например, оригинал lab4 со случайным ключом)
# может принадлежать другому вложению. На такой ключ ссылаются — не трогаем.
referenced = {r[0] for r in conn.execute(
"""SELECT t.k FROM unnest(%s::text[]) AS t(k)
WHERE EXISTS (SELECT 1 FROM attachments a
WHERE a.id <> %s AND (a.storage_key = t.k OR a.staging_key = t.k))
OR EXISTS (SELECT 1 FROM attachment_variants v
WHERE v.attachment_id <> %s AND v.storage_key = t.k)""",
(orphans, aid, aid))}
decisions = [(k, "keep", "referenced") if k in referenced else (k, a, w)
for k, a, w in decisions]
result = {"delete": [(k, w) for k, a, w in decisions if a == "delete"],
"keep": [(k, w) for k, a, w in decisions if a == "keep"]}
if delete is not None and result["delete"] and row is not None and row[0] == "failed" \
and row[1] is not None:
# У failed что-то удаляется, только когда retention истёк. Сначала — отметка
# «исходника нет» (даже если сам staging попадёт в уборку в следующий раз):
# после COMMIT replay невозможен, и объекты вложения больше никому не нужны.
conn.execute("UPDATE attachments SET staging_key = NULL WHERE id = %s", (aid,))
for job_id, attempt in job_rows:
jobs.event(conn, job_id, aid, attempt, "staging_expired", actor,
"retention истёк: исходник в staging удаляется уборщиком, replay невозможен")
faults.pause("cleanup_pause_locked") # проверка: replay ждёт эту транзакцию
except pg_errors.LockNotAvailable:
return None # строку держит переход состояния: попробуем в следующий раз
if delete is not None:
for key, _why in result["delete"]:
delete(key) # фаза 2: после COMMIT, без блокировок
return result
def delete_old_outbox(self, retention_seconds: int) -> int:
"""Отправленные строки outbox старше retention больше не нужны (журнал заданий остаётся)."""
with self._conn() as conn:
+1
View File
@@ -259,6 +259,7 @@ class Worker:
try:
try:
variants = self._produce(lease, item.abort)
faults.pause("worker_pause_after_objects") # проверка уборщика: объекты есть, COMMIT ещё нет
faults.hit("worker_after_objects") # объекты в S3 есть, COMMIT и ack — нет
if not self.jobs.complete(lease, variants):
log.warning("Задание %s: lease потерян до COMMIT — результат не записан", lease.job_id)
+1 -1
View File
@@ -12,7 +12,7 @@ import hashlib
from filegen import upload_when_ready, wait_status, wait_until
from helpers import Client, check, run
from stand import api_containers, docker, lb_summary, lb_up_count, ps_table, wait_balanced
from stand import docker, lb_summary, lb_up_count, ps_table, wait_balanced
def main():
+200
View File
@@ -0,0 +1,200 @@
"""Замечание к MR: уборщик S3 не удаляет текущую работу — воспроизведение на стенде с «барьерами».
make cleanup-race (= python student-tests/cleanup_race.py)
Порядок событий закрепляют точки-паузы (src/messenger/faults.py): процесс один раз ждёт
несколько секунд в опасном месте, а тест в это время делает следующий шаг. Grace period = 0,
чтобы уборщик рассматривал даже свежие объекты (так же, как в воспроизведении из замечания).
Настоящие PostgreSQL, S3, CLI уборщика, replay, API и worker.
A. Как в замечании. failed-вложение с истёкшим retention (состояние и возраст заданы через
updated_at, как в замечании). Уборщик прочитал ссылки и остановился (cleanup_pause) ->
оператор делает replay (queued) -> уборщик продолжает. Было: staging удалён, worker ->
failed / source_missing. Стало: уборщик перепроверяет состояние под блокировкой и staging
не трогает; после запуска worker вложение становится ready.
B. Обратный порядок. Уборщик под блокировкой уже решил удалить staging истёкшего failed и пометил
его удалённым, COMMIT ещё нет (cleanup_pause_locked) -> replay ждёт блокировку и безопасно
отказывает (source_missing), задание остаётся failed, в журнале — запись уборщика и отказ
replay; сам объект уборщик удаляет после COMMIT.
C. Загрузка между PUT в staging и COMMIT строки вложения (api_pause_after_staging): уборщик
пропускает это вложение (занято), загрузка заканчивается 202 -> ready.
D. Worker записал оригинал и варианты в S3, COMMIT ещё нет (worker_pause_after_objects):
уборщик ничего не удаляет (задание в processing), worker коммитит -> ready, файлы на месте.
"""
import hashlib
import threading
import time
import ops
from filegen import SAMPLE_PNG, png, wait_status
from helpers import Client, check, run
# Секунд в точке-паузе: столько длится «окно» гонки. С запасом: на Windows каждый docker exec — около секунды.
PAUSE = {"cleanup_pause": "10", "cleanup_pause_locked": "8", "api_pause_after_staging": "10",
"worker_pause_after_objects": "12"}
def background(fn, *args):
result = {}
def target():
try:
result["value"] = fn(*args)
except BaseException as exc: # noqa: BLE001 — передаём в основной поток
result["error"] = exc
thread = threading.Thread(target=target, daemon=True)
thread.start()
return thread, result
def finish(step, seconds=60):
thread, result = step
thread.join(seconds)
check(not thread.is_alive(), "a background step did not finish")
if "error" in result:
raise result["error"]
return result["value"]
def wait_paused(container, point, seconds=40):
"""Точка-пауза сработала (процесс удалил её файл и ждёт) — можно делать следующий шаг."""
deadline = time.monotonic() + seconds
while ops.armed(container, point):
check(time.monotonic() < deadline, f"{point} did not fire")
time.sleep(0.2)
def janitor(container, attachment_id):
return ops.cli_in(container, "messenger.cleanup", "--grace-seconds", "0", "--attachment", attachment_id)
def mark_failed_long_ago(attachment_id):
ops.psql(f"""UPDATE attachment_jobs SET status = 'failed', finished_at = now(),
last_error_code = 'storage_unavailable', last_error = 'cleanup-race'
WHERE attachment_id = '{attachment_id}';
UPDATE attachments SET status = 'failed', error_code = 'retry_exhausted',
updated_at = now() - interval '2 days'
WHERE id = '{attachment_id}'""")
def staging_exists(attachment_id):
return ops.objects(f"staging/{attachment_id}") == [f"staging/{attachment_id}"]
def upload(api, actor, chat, data, name):
return api.call("POST", f"/api/v1/chats/{chat['id']}/attachments?filename={name}", 202, actor=actor,
raw=data, headers={"Content-Type": "image/png"}, schema="Attachment")["json"]
def main():
api = Client(timeout=30)
alice, bob, _eve, chat = api.bootstrap()
container = ops.containers("api")[0] # здесь запускается уборщик и включаются его паузы
# ---------- A и B: подготовка двух failed-вложений с истёкшим retention ----------
ops.stop("worker")
try:
a = upload(api, alice, chat, SAMPLE_PNG, "race-a.png")
b = upload(api, alice, chat, png(40, 30), "race-b.png")
for att in (a, b):
mark_failed_long_ago(att["id"])
# ---------- A ----------
ops.arm("api", "cleanup_pause", PAUSE["cleanup_pause"], container=container)
cleanup = background(janitor, container, a["id"])
wait_paused(container, "cleanup_pause")
print(f"A. failed {a['id']} (retention expired); the janitor read the references and stopped")
replayed = ops.replay(a["id"])
check(replayed.get("result") == "queued", f"replay: {replayed}")
print(f" operator replay while the janitor waits -> {replayed}")
out = finish(cleanup)
check(out["deleted"] == 0 and out["kept_after_recheck"] == {"current_work": 1}, f"janitor: {out}")
check(staging_exists(a["id"]), "the staging of the replayed job was deleted")
print(f" janitor continued: deleted {out['deleted']}, re-checked under the lock -> kept "
f"{out['kept_after_recheck']}; staging/{a['id'][:8]}... is still in S3")
# ---------- B ----------
ops.arm("api", "cleanup_pause_locked", PAUSE["cleanup_pause_locked"], container=container)
cleanup = background(janitor, container, b["id"])
wait_paused(container, "cleanup_pause_locked")
print(f"B. failed {b['id']} (retention expired); the janitor holds the lock: staging marked deleted, "
f"no COMMIT yet")
started = time.monotonic()
refused = ops.replay(b["id"])
waited = time.monotonic() - started
out = finish(cleanup)
check(refused.get("result") == "refused" and refused.get("reason") == "source_missing", f"replay: {refused}")
check(out["deleted"] == 1 and out["to_delete"]["staging_failed_expired"] == 1, f"janitor: {out}")
job = ops.job(b["id"])
events = [e["event"] for e in job["events"] if e["event"] in ("staging_expired", "replay_refused")]
check(job["job"]["status"] == "failed" and events == ["staging_expired", "replay_refused"], f"{job}")
check(not staging_exists(b["id"]), "the expired staging must be deleted")
print(f" replay waited {waited:.1f} s for the lock -> {refused['result']} ({refused['reason']}); "
f"job stays failed; journal: {' -> '.join(events)}")
finally:
ops.start("worker")
ops.wait_healthy("worker", 1)
ready = wait_status(api, bob, a["id"], ("ready", "failed"), seconds=90)
check(ready["status"] == "ready", f"A must become ready, got {ready['status']} / {ready['error_code']}")
print(f" A: worker started -> ready with {[v['name'] for v in ready['variants']]} (before the fix: "
f"failed / source_missing)")
# ---------- C ----------
before = set(ops.objects("staging/"))
ops.arm("api", "api_pause_after_staging", PAUSE["api_pause_after_staging"])
try:
sending = background(upload, api, alice, chat, png(48, 36), "race-c.png")
deadline = time.monotonic() + 30
while True:
new = sorted(set(ops.objects("staging/")) - before)
if new:
break
check(time.monotonic() < deadline, "the upload did not reach staging")
time.sleep(0.2)
c_id = new[0].split("/", 1)[1]
rows = ops.psql(f"SELECT count(*) FROM attachments WHERE id = '{c_id}'")
check(rows == "0", "the row must not be committed yet")
print(f"C. upload {c_id}: staging written, no row in the database yet (API paused before COMMIT)")
out = janitor(container, c_id)
check(out["deleted"] == 0 and out["skipped_busy"] == 1, f"janitor: {out}")
print(f" janitor (grace 0): skipped_busy {out['skipped_busy']}, deleted {out['deleted']} — "
f"the upload holds the attachment lock")
att = finish(sending)
check(att["id"] == c_id, "unexpected attachment id")
finally:
ops.disarm("api", "api_pause_after_staging")
meta = wait_status(api, bob, c_id, seconds=60)
print(f" upload -> 202, then {meta['status']} with {len(meta['variants'])} variants")
# ---------- D ----------
ops.arm("worker", "worker_pause_after_objects", PAUSE["worker_pause_after_objects"])
try:
d = upload(api, alice, chat, SAMPLE_PNG, "race-d.png")
deadline = time.monotonic() + 60
while len(ops.objects(f"variants/{d['id']}/")) < 3 or not ops.objects(f"originals/{d['id']}"):
check(time.monotonic() < deadline, "the worker did not write the objects")
time.sleep(0.2)
status = ops.job(d["id"])["attachment_status"]
check(status == "processing", f"expected processing, got {status}")
print(f"D. {d['id']}: worker wrote the original and 3 variants, COMMIT not yet (status {status})")
out = janitor(container, d["id"])
# По снимку ссылок оригинал и 3 варианта — ничьи (на них ещё нет COMMIT), staging — нужен.
check(out["deleted"] == 0 and out["kept_after_recheck"].get("current_work", 0) == 4, f"janitor: {out}")
print(f" janitor (grace 0): the snapshot marked the original and 3 variants as unreferenced; re-checked "
f"under the lock -> kept {out['kept_after_recheck']}, deleted {out['deleted']}")
finally:
ops.disarm("worker", "worker_pause_after_objects")
meta = wait_status(api, bob, d["id"], seconds=60)
body = api.call("GET", f"/api/v1/attachments/{d['id']}/content", 200, actor=bob)["bytes"]
check(hashlib.sha256(body).hexdigest() == d["sha256"], "the original changed")
for variant in meta["variants"]:
got = api.call("GET", f"/api/v1/attachments/{d['id']}/content?variant={variant['name']}", 200, actor=bob)
check(hashlib.sha256(got["bytes"]).hexdigest() == variant["sha256"], "variant bytes differ")
print(f" worker committed -> {meta['status']}; the original and all variants download with the same SHA-256")
print("PASS: the janitor re-checks the state under the attachment lock before deleting: a replay accepted "
"after its snapshot keeps the staging (A), a replay after the janitor's decision is refused safely (B), "
"an upload in progress (C) and objects of a job in processing (D) are not deleted")
if __name__ == "__main__":
run(main)
+249
View File
@@ -0,0 +1,249 @@
"""Замечание к MR: уборщик S3 не удаляет текущую работу — решение под блокировками в настоящей PostgreSQL.
Выполняется ВНУТРИ контейнера приложения вместе с остальными тестами БД:
make db-test == docker compose --profile tools run --rm db-test
Уборщик проверяется без S3: вместо удаления объекта ему передаётся функция-«барьер», которая
запоминает ключ и, если нужно, ждёт сигнала теста. Так порядок событий задаётся точно, как
в воспроизведении из замечания (барьер в тестовом драйвере), а не надеждой на тайминги:
1. снимок ссылок -> replay коммитит queued -> уборщик продолжает: staging НЕ удаляется
(решение перепроверяется по текущему состоянию под блокировкой);
2. уборщик под блокировкой уже пометил staging истёкшего failed-вложения удалённым, COMMIT ещё
нет -> replay ждёт и безопасно отказывает source_missing, задание остаётся failed, в журнале
обе записи; сам объект удаляется после COMMIT;
3. replay держит блокировку (проверяет исходник) -> уборщик ждёт и видит queued: не удаляет;
4. загрузка записала staging, COMMIT строки ещё не было -> уборщик вложение пропускает;
5. задание в processing (worker пишет оригинал и варианты) -> ничего не удаляется;
6. обычная уборка не сломана: «сирота» без строки, staging готового и объекты failed-вложения
после retention удаляются; опубликованное и всё failed-вложения до конца retention — нет.
"""
import threading
import time
import unittest
import uuid
from messenger import config, db, faults, jobs
from messenger.store import PostgresStore
RETENTION = 3600
class Barrier:
"""«Удаление объекта» для уборщика: запоминает ключи; может остановиться и ждать сигнала."""
def __init__(self, hold: bool = False):
self.deleted, self.entered, self.release = [], threading.Event(), threading.Event()
if not hold:
self.release.set()
def __call__(self, key):
self.deleted.append(key)
self.entered.set()
assert self.release.wait(20), "the test never released the barrier"
class CleanupRaceTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
config.validate()
db.migrate()
cls.pool = db.create_pool(max_size=6)
cls.pool.open(wait=True)
cls.store = PostgresStore(cls.pool)
cls.jobs = jobs.JobStore(cls.pool, "operator:db-test")
cls.worker = jobs.JobStore(cls.pool, "worker-db-test")
cls.user = cls.store.create_user("cl_" + uuid.uuid4().hex[:12], "Cleanup test", "not-a-real-hash")
cls.chat = cls.store.create_chat(cls.user.id, "cleanup", [cls.user.id])
@classmethod
def tearDownClass(cls):
cls.pool.close()
def scalar(self, sql, *params):
with self.pool.connection() as conn:
return conn.execute(sql, params).fetchone()[0]
def execute(self, sql, *params):
with self.pool.connection() as conn:
conn.execute(sql, params)
def queued(self):
attachment_id = str(uuid.uuid4())
self.store.create_queued_attachment(
attachment_id, self.user.id, self.chat.id, "c.png", "image/png", 10, "0" * 64, 2, 2,
staging_key="staging/" + attachment_id, storage_key="originals/" + attachment_id, actor="db-test")
return attachment_id
def failed(self, expired: bool):
"""failed-вложение; expired — retention истёк (как в замечании: возраст через updated_at)."""
attachment_id = self.queued()
job_id = str(self.scalar("SELECT job_id FROM attachment_jobs WHERE attachment_id = %s", uuid.UUID(attachment_id)))
message = {"job_id": job_id, "attachment_id": attachment_id, "pipeline_version": 1, "attempt": 1}
lease = self.worker.claim(message, "host/1").lease
self.worker.fail(lease, "invalid_image", "test")
if expired:
self.execute("UPDATE attachments SET updated_at = now() - interval '2 days' WHERE id = %s",
uuid.UUID(attachment_id))
return attachment_id, job_id
def state(self, attachment_id):
with self.pool.connection() as conn:
return conn.execute("""SELECT a.status, a.staging_key IS NOT NULL, j.status FROM attachments a
JOIN attachment_jobs j ON j.attachment_id = a.id WHERE a.id = %s""",
(uuid.UUID(attachment_id),)).fetchone()
def events(self, job_id):
with self.pool.connection() as conn:
return [r[0] for r in conn.execute("SELECT event FROM job_events WHERE job_id = %s ORDER BY id",
(uuid.UUID(job_id),))]
def test_1_replay_after_snapshot_keeps_staging(self):
attachment_id, job_id = self.failed(expired=True)
staging = "staging/" + attachment_id
refs = self.store.storage_references(RETENTION) # уборщик прочитал ссылки...
self.assertNotIn(staging, refs["needed"]) # ...по снимку staging лишний
self.assertEqual(self.jobs.replay(attachment_id, lambda key: True)["result"], "queued") # барьер: replay
barrier = Barrier()
outcome = self.store.cleanup_attachment(attachment_id, [staging], RETENTION, barrier) # уборщик продолжает
self.assertEqual((outcome["delete"], outcome["keep"]), ([], [(staging, "current_work")]))
self.assertEqual(barrier.deleted, [])
self.assertEqual(self.state(attachment_id), ("queued", True, "queued"))
print(f"\n snapshot -> replay (queued) -> cleanup: kept {outcome['keep']}, nothing deleted")
def test_2_cleanup_first_then_replay_waits_and_refuses(self):
attachment_id, job_id = self.failed(expired=True)
staging = "staging/" + attachment_id
locked, release = threading.Event(), threading.Event()
real_pause = faults.pause
def pause(name): # барьер внутри транзакции уборщика (точка cleanup_pause_locked)
if name == "cleanup_pause_locked":
locked.set()
release.wait(20)
faults.pause = pause
try:
barrier, cleanup = Barrier(), {}
janitor = threading.Thread(target=lambda: cleanup.update(
self.store.cleanup_attachment(attachment_id, [staging], RETENTION, barrier)))
janitor.start()
self.assertTrue(locked.wait(10), "cleanup did not reach its decision") # держит блокировки
replay = {}
operator = threading.Thread(target=lambda: replay.update(self.jobs.replay(attachment_id, lambda key: True)))
operator.start()
time.sleep(1.0)
self.assertTrue(operator.is_alive(), "replay must wait for the cleanup's lock")
self.assertEqual(barrier.deleted, []) # до COMMIT в S3 ничего не удаляется
release.set()
janitor.join(10)
operator.join(10)
finally:
faults.pause = real_pause
self.assertEqual(cleanup["delete"], [(staging, "staging_failed_expired")])
self.assertEqual(barrier.deleted, [staging]) # удалён после COMMIT
self.assertEqual((replay["result"], replay["reason"]), ("refused", "source_missing"))
self.assertEqual(self.state(attachment_id), ("failed", False, "failed"))
# Порядок в журнале: сначала уборщик, потом отказ replay (записи worker стенда, если он
# успел увидеть тестовое задание, сюда не относятся).
ours = [e for e in self.events(job_id) if e in ("staging_expired", "replay_refused", "replay_requested")]
self.assertEqual(ours, ["staging_expired", "replay_refused"])
print(f"\n cleanup marked the staging deleted, holds the lock -> replay waited 1 s+ -> {replay['result']} "
f"({replay['reason']}); job stays failed; journal: staging_expired, replay_refused")
def test_3_replay_first_then_cleanup_waits_and_keeps(self):
attachment_id, job_id = self.failed(expired=True)
staging = "staging/" + attachment_id
checking, release = threading.Event(), threading.Event()
def slow_head(key): # replay проверяет исходник в S3, держа блокировки
checking.set()
return release.wait(20)
replay = {}
operator = threading.Thread(target=lambda: replay.update(self.jobs.replay(attachment_id, slow_head)))
operator.start()
self.assertTrue(checking.wait(10))
cleanup, barrier = {}, Barrier()
janitor = threading.Thread(target=lambda: cleanup.update(
self.store.cleanup_attachment(attachment_id, [staging], RETENTION, barrier) or {"busy": True}))
janitor.start()
time.sleep(1.0)
self.assertTrue(janitor.is_alive(), "cleanup must wait for the replay's lock")
release.set()
operator.join(10)
janitor.join(10)
self.assertEqual(replay["result"], "queued")
self.assertEqual(cleanup.get("keep"), [(staging, "current_work")])
self.assertEqual(barrier.deleted, [])
print(f"\n replay holds the lock -> cleanup waited -> kept {cleanup['keep']}")
def test_4_upload_in_progress_is_skipped(self):
attachment_id = str(uuid.uuid4())
staging = "staging/" + attachment_id
inside, finish = threading.Event(), threading.Event()
def upload(): # как attachments.accept: PUT в staging, потом строка, COMMIT
with self.store.receiving(attachment_id) as conn:
inside.set() # «PUT в staging прошёл»
finish.wait(20)
self.store.create_queued_attachment(
attachment_id, self.user.id, self.chat.id, "u.png", "image/png", 10, "0" * 64, 2, 2,
staging_key=staging, storage_key="originals/" + attachment_id, actor="db-test", conn=conn)
api = threading.Thread(target=upload)
api.start()
self.assertTrue(inside.wait(10))
barrier = Barrier()
self.assertIsNone(self.store.cleanup_attachment(attachment_id, [staging], RETENTION, barrier)) # занято
finish.set()
api.join(10)
after = self.store.cleanup_attachment(attachment_id, [staging], RETENTION, barrier)
self.assertEqual((after["keep"], barrier.deleted), ([(staging, "current_work")], []))
self.assertEqual(self.state(attachment_id), ("queued", True, "queued"))
print("\n upload between PUT and COMMIT -> cleanup skipped it (busy); after COMMIT -> current work, kept")
def test_5_objects_of_processing_job_are_kept(self):
attachment_id = self.queued()
job_id = str(self.scalar("SELECT job_id FROM attachment_jobs WHERE attachment_id = %s", uuid.UUID(attachment_id)))
self.worker.claim({"job_id": job_id, "attachment_id": attachment_id, "pipeline_version": 1, "attempt": 1},
"host/1")
keys = [f"originals/{attachment_id}", f"variants/{attachment_id}/v1/thumbnail.jpg", f"staging/{attachment_id}"]
barrier = Barrier()
outcome = self.store.cleanup_attachment(attachment_id, keys, RETENTION, barrier)
self.assertEqual((outcome["delete"], barrier.deleted), ([], []))
self.assertEqual({why for _key, why in outcome["keep"]}, {"current_work"})
print("\n processing job (worker writes the original and variants before COMMIT) -> all 3 objects kept")
def test_6_regular_cleanup_still_works(self):
barrier = Barrier()
orphan = str(uuid.uuid4()) # строки нет, загрузка не идёт
out = self.store.cleanup_attachment(orphan, [f"staging/{orphan}"], RETENTION, barrier)
self.assertEqual(out["delete"], [(f"staging/{orphan}", "orphan")])
kept_id, _job = self.failed(expired=False) # retention не истёк: нужен для replay
out = self.store.cleanup_attachment(kept_id, [f"staging/{kept_id}", f"originals/{kept_id}"], RETENTION, barrier)
self.assertEqual(out["keep"], [(f"staging/{kept_id}", "staging_kept_for_replay"),
(f"originals/{kept_id}", "failed_kept_for_replay")]) # replay перезапишет
dead_id, dead_job = self.failed(expired=True) # retention истёк: удаляется всё
out = self.store.cleanup_attachment(dead_id, [f"originals/{dead_id}"], RETENTION, barrier)
self.assertEqual(out["delete"], [(f"originals/{dead_id}", "orphan")])
self.assertEqual(self.state(dead_id)[1], False) # staging помечен удалённым до удаления
self.assertEqual(self.jobs.replay(dead_id, lambda key: True)["reason"], "source_missing")
ready = self.queued()
job_id = str(self.scalar("SELECT job_id FROM attachment_jobs WHERE attachment_id = %s", uuid.UUID(ready)))
lease = self.worker.claim({"job_id": job_id, "attachment_id": ready, "pipeline_version": 1, "attempt": 1},
"host/1").lease
variants = [{"name": n, "storage_key": f"variants/{ready}/v1/{n}.jpg", "content_type": "image/jpeg",
"size_bytes": 5, "width": 1, "height": 1, "sha256": "a" * 64} for n in ("thumbnail", "crop")]
self.assertTrue(self.worker.complete(lease, variants))
keys = [f"staging/{ready}", f"originals/{ready}", f"variants/{ready}/v1/thumbnail.jpg",
f"variants/{ready}/v1/stale.jpg"]
out = self.store.cleanup_attachment(ready, keys, RETENTION, barrier)
self.assertEqual(sorted(out["delete"]), sorted([(f"staging/{ready}", "staging_after_ready"),
(f"variants/{ready}/v1/stale.jpg", "orphan")]))
self.assertEqual({why for _key, why in out["keep"]}, {"published"})
dry = self.store.cleanup_attachment(orphan, [f"staging/{orphan}"], RETENTION, None) # пробный прогон
self.assertEqual(dry["delete"], [(f"staging/{orphan}", "orphan")])
self.assertEqual(len(barrier.deleted), 4) # dry-run ничего не удалил
print("\n orphan, staging after ready, objects of a failed attachment after retention -> deleted; "
"published original and variants, a failed attachment within retention -> kept; dry-run deletes nothing")
if __name__ == "__main__":
unittest.main(verbosity=2)
+142
View File
@@ -39,6 +39,27 @@ SAMPLE_JPEG = base64.b64decode(
"8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDwGCw9q0ILD2rcgsPatCCw9q+pqYw4MFj9tTDgsPatCCw9q24LD2rQgsPauCpjD67BY/bU"
"xILD2q/BYe1bkFh7VoQWHtXBUxh9dgsftqc3BYe1aEFh7VuQWHtWhBYe1cdTGH824LH7amHBYe1aEFh7VuQWHtWhBYe1cFTGH12C"
"x+2phwWHtWhBYe1bkFh7VoQWHtXn1MYfXYLH7an/2Q==")
# Ещё два синтетических JPEG 40×24 (созданы для курса Pillow): progressive и с маркерами RST (DRI = 1 MCU).
PROGRESSIVE_JPEG = base64.b64decode(
"/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAA0JCgsKCA0LCgsODg0PEyAVExISEyccHhcgLikxMC4pLSwzOko+MzZGNywtQFdBRkxOUlNS"
"Mj5aYVpQYEpRUk//2wBDAQ4ODhMREyYVFSZPNS01T09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09P"
"T0//wgARCAAYACgDASIAAhEBAxEB/8QAFwABAQEBAAAAAAAAAAAAAAAAAAMEBf/EABgBAAMBAQAAAAAAAAAAAAAAAAIDBAEG/9oADAMB"
"AAIQAxAAAAHg11WxeWuqzbMreOuNSLlrVG22B1f/xAAWEAADAAAAAAAAAAAAAAAAAAAAAQL/2gAIAQEAAQUCUCgUCgUCgUCgUCgUCgUC"
"gUH/xAAXEQADAQAAAAAAAAAAAAAAAAAAAQID/9oACAEDAQE/AY2I2FsRTIpipn//xAAXEQEBAQEAAAAAAAAAAAAAAAABABAR/9oACAEC"
"AQE/ARhuxGf/xAAUEAEAAAAAAAAAAAAAAAAAAAAw/9oACAEBAAY/An//xAAUEAEAAAAAAAAAAAAAAAAAAAAw/9oACAEBAAE/IXAAAAA/"
"/9oADAMBAAIAAwAAABBpk59wP//EABcRAQADAAAAAAAAAAAAAAAAABAAESH/2gAIAQMBAT8QKydq0//EABYRAQEBAAAAAAAAAAAAAAAA"
"AAEAEP/aAAgBAgEBPxDPK2bC3//EABUQAQEAAAAAAAAAAAAAAAAAAABh/9oACAEBAAE/EJJJJJJJJJJJJJJJP//Z")
RESTART_JPEG = base64.b64decode(
"/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAA0JCgsKCA0LCgsODg0PEyAVExISEyccHhcgLikxMC4pLSwzOko+MzZGNywtQFdBRkxOUlNS"
"Mj5aYVpQYEpRUk//2wBDAQ4ODhMREyYVFSZPNS01T09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09P"
"T0//wAARCAAYACgDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQID"
"AAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlq"
"c3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3"
"+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEI"
"FEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImK"
"kpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/90ABAAB/9oADAMBAAIR"
"AxEAPwDg4rP2q3FZ+1akVn7Vbis/alCZz0MYf//Q5mKz9qtxWftWpFZ+1W4rP2rohM9GhjD/0c+Kz9qK34rP2orvUz6aGM0P/9J0Vn7V"
"bis/aiiuSDZ8pQqyP//T2IrP2q3FZ+1FFTBs82hVkf/U66Kz9qKKK1TZcKsrH//Z")
def _chunk(kind: bytes, data: bytes) -> bytes:
@@ -87,6 +108,127 @@ def bad_filter_png() -> bytes:
return b"\x89PNG\r\n\x1a\n" + _chunk(b"IHDR", ihdr) + _chunk(b"IDAT", zlib.compress(raw)) + _chunk(b"IEND", b"")
# ---------- JPEG по сегментам: чтобы портить структуру точечно ----------
def jpeg_parts(data: bytes) -> list:
"""JPEG -> [("seg", маркер, данные) | ("scan", заголовок SOS, сжатые данные) | ("eoi", хвост)]."""
i, parts = 2, []
while True:
marker = data[i + 1]
i += 2
if marker == 0xD9:
parts.append(("eoi", data[i:]))
return parts
length = int.from_bytes(data[i:i + 2], "big")
payload, i = data[i + 2:i + length], i + length
if marker != 0xDA:
parts.append(("seg", marker, payload))
continue
j = i
while data[j] != 0xFF or data[j + 1] == 0x00 or 0xD0 <= data[j + 1] <= 0xD7:
j += 1
parts.append(("scan", payload, data[i:j]))
i = j
def jpeg_join(parts: list) -> bytes:
out = bytearray(b"\xff\xd8")
for part in parts:
if part[0] == "seg":
out += bytes([0xFF, part[1]]) + struct.pack(">H", len(part[2]) + 2) + part[2]
elif part[0] == "scan":
out += b"\xff\xda" + struct.pack(">H", len(part[1]) + 2) + part[1] + part[2]
else:
out += b"\xff\xd9" + part[1]
return bytes(out)
def _edit(data: bytes, kind, fn, index: int = 0) -> bytes:
"""Поменять index-й сегмент вида kind (маркер или "scan"): fn(bytearray) -> bytes."""
parts, seen = jpeg_parts(data), 0
for k, part in enumerate(parts):
hit = part[0] == "scan" if kind == "scan" else part[0] == "seg" and part[1] == kind
if hit:
if seen == index:
if kind == "scan":
parts[k] = ("scan", fn(bytearray(part[1])), part[2])
else:
parts[k] = ("seg", kind, fn(bytearray(part[2])))
return jpeg_join(parts)
seen += 1
raise AssertionError(f"segment {kind} #{index} not found")
def _set(position: int, value: int):
def change(payload: bytearray) -> bytes:
payload[position] = value
return bytes(payload)
return change
def teacher_bad_sos_jpeg() -> bytes:
"""Воспроизведение из замечания: в первом SOS (FF DA по смещению i) байт i+5 — первый
идентификатор компонента — заменить на 250, которого нет в SOF."""
data = bytearray(SAMPLE_JPEG)
i = data.index(b"\xff\xda")
data[i + 5] = 250
return bytes(data)
def broken_structure_jpegs() -> list[tuple[str, bytes]]:
"""JPEG, которые строгий декодер worker отвергает по маркерам и заголовкам (API: 415)."""
def drop(data, test):
return jpeg_join([p for p in jpeg_parts(data) if not test(p)])
def scans(data):
return [p for p in jpeg_parts(data) if p[0] == "scan"]
def swap_rst(entropy: bytes) -> bytes:
e = bytearray(entropy)
positions = [k for k in range(len(e) - 1) if e[k] == 0xFF and 0xD0 <= e[k + 1] <= 0xD7]
e[positions[0] + 1], e[positions[1] + 1] = e[positions[1] + 1], e[positions[0] + 1]
return bytes(e)
seq_scan = scans(SAMPLE_JPEG)[0]
first_progressive = scans(PROGRESSIVE_JPEG)[0]
no_jfif = drop(SAMPLE_JPEG, lambda p: p[0] == "seg" and p[1] == 0xE0)
restart_parts = jpeg_parts(RESTART_JPEG)
return [
("SOS: компонент 250, которого нет в SOF (замечание к MR)", teacher_bad_sos_jpeg()),
("SOS: один компонент дважды в скане", _edit(SAMPLE_JPEG, "scan", _set(3, 1))),
("SOS: таблица Хаффмана DC 2 не определена", _edit(SAMPLE_JPEG, "scan", _set(2, 0x20))),
("SOS: номер таблицы Хаффмана AC 5", _edit(SAMPLE_JPEG, "scan", _set(4, 0x05))),
("SOS: Se=62 в последовательном JPEG", _edit(SAMPLE_JPEG, "scan", _set(-2, 62))),
("SOS: Ah/Al не нули в последовательном JPEG", _edit(SAMPLE_JPEG, "scan", _set(-1, 0x10))),
("SOS: 5 компонентов в скане", _edit(SAMPLE_JPEG, "scan", _set(0, 5))),
("SOF: таблица квантования 3 не определена", _edit(SAMPLE_JPEG, 0xC0, _set(8, 3))),
("SOF: повторяется идентификатор компонента", _edit(SAMPLE_JPEG, 0xC0, _set(9, 1))),
("SOF: субдискретизация 1×4 (не понимает декодер)", _edit(SAMPLE_JPEG, 0xC0, _set(7, 0x14))),
("SOF: коэффициент субдискретизации 0", _edit(SAMPLE_JPEG, 0xC0, _set(10, 0x01))),
("SOF: 12 бит на канал", _edit(SAMPLE_JPEG, 0xC0, _set(0, 12))),
("SOF: 2 компонента", _edit(SAMPLE_JPEG, 0xC0, lambda p: bytes(p[:5]) + b"\x02" + bytes(p[6:12]))),
("DHT: коды не помещаются в длину (3 кода по 1 биту)",
_edit(SAMPLE_JPEG, 0xC4, lambda p: b"\x00" + bytes([3] + [0] * 15) + b"\x00\x01\x02")),
("DHT: символ 16 в таблице DC", _edit(SAMPLE_JPEG, 0xC4, lambda p: bytes(p[:-1]) + b"\x10")),
("DHT: номер таблицы 4", _edit(SAMPLE_JPEG, 0xC4, _set(0, 0x04))),
("DQT: таблица обрезана", _edit(SAMPLE_JPEG, 0xDB, lambda p: bytes(p[:-1]))),
("сегмент с зарезервированным маркером 0xF0",
jpeg_join([("seg", 0xF0, b"\x00\x00")] + jpeg_parts(SAMPLE_JPEG))),
("мусорные байты между сегментами", SAMPLE_JPEG.replace(b"\xff\xdb", b"\x00\x00\xff\xdb", 1)),
("APP0: JFIF версии 3", _edit(SAMPLE_JPEG, 0xE0, _set(5, 3))),
("APP14: неизвестное преобразование Adobe 7",
jpeg_join([("seg", 0xEE, b"Adobe\x00\x64\x00\x00\x00\x00\x07")] + jpeg_parts(no_jfif))),
("второй скан после полного скана",
jpeg_join(jpeg_parts(SAMPLE_JPEG)[:-1] + [seq_scan, ("eoi", b"")])),
("progressive: AC-скан раньше DC-скана", drop(PROGRESSIVE_JPEG, lambda p: p is not None and p == first_progressive)),
("progressive: Al=14", _edit(PROGRESSIVE_JPEG, "scan", _set(-1, 14))),
("RST: маркеры RST0 и RST1 поменяны местами",
jpeg_join([("scan", p[1], swap_rst(p[2])) if p[0] == "scan" else p for p in restart_parts])),
("RST: маркеры есть, а интервала DRI нет", drop(RESTART_JPEG, lambda p: p[0] == "seg" and p[1] == 0xDD)),
("RST: интервал DRI 2 вместо 1", _edit(RESTART_JPEG, 0xDD, lambda p: b"\x00\x02")),
]
def garbage_scan_jpeg() -> bytes:
"""SAMPLE_JPEG с мусором вместо сжатых данных скана: маркеры и длины целы, данные — нет."""
sos = SAMPLE_JPEG.index(b"\xff\xda")
+26 -5
View File
@@ -133,6 +133,14 @@ def cli(service: str, *args: str) -> dict:
return json.loads(lines[-1])
def cli_in(container: str, *args: str) -> dict:
"""То же, что cli(), но в конкретном контейнере (там, где включена точка-пауза)."""
out = _run(["docker", "exec", "-i", container, "python", "-m", *args])
lines = [line for line in out.splitlines() if line.startswith("{") or line.startswith("[")]
check(bool(lines), f"no JSON from {' '.join(args)}")
return json.loads(lines[-1])
def job(attachment_id: str, service: str = "api") -> dict:
"""Состояние задания, журнал, строки outbox и варианты (python -m messenger.jobs show)."""
return cli(service, "messenger.jobs", "show", attachment_id)
@@ -148,11 +156,24 @@ def psql(sql: str) -> str:
"-v", "ON_ERROR_STOP=1", "-c", sql)
def queues() -> dict:
"""{очередь: (готовых к выдаче, выдано и не подтверждено)} — rabbitmqctl внутри контейнера брокера."""
out = compose("exec", "-T", "broker", "rabbitmqctl", "-q", "list_queues", "-p", "messenger",
"name", "messages_ready", "messages_unacknowledged", "--formatter", "json")
return {q["name"]: (int(q["messages_ready"]), int(q["messages_unacknowledged"])) for q in json.loads(out or "[]")}
def queues(seconds: float = 30) -> dict:
"""{очередь: (готовых к выдаче, выдано и не подтверждено)} — rabbitmqctl внутри контейнера брокера.
Сразу после перезапуска брокер уже отвечает на ping, но quorum-очереди ещё восстанавливаются
с диска, и list_queues может один раз не ответить: тогда повторяем до seconds секунд.
"""
args = ("exec", "-T", "broker", "rabbitmqctl", "-q", "list_queues", "-p", "messenger",
"name", "messages_ready", "messages_unacknowledged", "--formatter", "json")
deadline = time.monotonic() + seconds
while True:
out = compose(*args, check_exit=False) # при ошибке rabbitmqctl печатает справку, не JSON
try:
rows = json.loads(out or "[]")
return {q["name"]: (int(q["messages_ready"]), int(q["messages_unacknowledged"])) for q in rows}
except (ValueError, KeyError, TypeError):
pass
check(time.monotonic() < deadline, "rabbitmqctl list_queues: the broker does not answer")
time.sleep(1)
def objects(prefix: str) -> list[str]:
+24 -2
View File
@@ -9,6 +9,8 @@
Без метаданных: в вариантах нет EXIF (APP1), ICC (APP2), блоков EXIF/XMP/ICCP у WebP.
Уровень 4 (lab4, сохранено): слишком большой файл, «бомба» по пикселям, повреждённые файлы,
подмена MIME, опасные filename, чужое attachment_id и вложение другого чата — точные коды, без 500.
Замечание к MR (lab5): JPEG с ошибками в заголовках (SOS ссылается на компонент, которого нет в SOF,
неопределённые таблицы, неверные параметры сканов, RST не по порядку и др.) — 415 сразу, а не 202 -> failed.
lab5: failed-вложение нельзя прикрепить (409), его байты — 409; ровно 10 MiB и ровно 40 млн
пикселей принимаются, на байт/пиксель больше — 413.
"""
@@ -17,8 +19,9 @@ import unittest
import uuid
from urllib.parse import quote
from filegen import (SAMPLE_JPEG, SAMPLE_PNG, bad_filter_png, bomb_png, corrupt_crc, garbage_scan_jpeg, gray_png,
jpeg_markers, png, png_exact_size, raw_upload, truncated, wait_status, webp_chunks, webp_size)
from filegen import (PROGRESSIVE_JPEG, RESTART_JPEG, SAMPLE_JPEG, SAMPLE_PNG, bad_filter_png, bomb_png,
broken_structure_jpegs, corrupt_crc, garbage_scan_jpeg, gray_png, jpeg_markers, png, png_exact_size,
raw_upload, truncated, wait_status, webp_chunks, webp_size)
from helpers import Client, idempotency
from image_probe import jpeg_size
@@ -172,6 +175,25 @@ class AttachmentTest(unittest.TestCase):
"unsupported_media_type")
self.upload(b"", expected=400) # пустое тело
def test_structurally_broken_jpeg_is_415(self):
# Замечание к MR: первый SOS ссылался на компонент 250, которого нет в SOF, а API отвечал
# 202 (потом failed/invalid_image). Теперь всё, что строгий декодер worker отвергает по
# маркерам и заголовкам, отклоняется сразу: 415, в БД и S3 ничего не появляется.
for name, data in broken_structure_jpegs():
with self.subTest(name):
reply = self.upload(data, "image/jpeg", "broken.jpg", expected=415)
self.assertEqual(reply["json"]["error"]["code"], "unsupported_media_type")
def test_valid_jpeg_variants_are_accepted(self):
# Обратная сторона: строгая проверка не отклоняет правильные progressive JPEG и JPEG
# с маркерами RST — они проходят и доходят до ready с тремя вариантами.
for name, data in (("progressive", PROGRESSIVE_JPEG), ("restart-markers", RESTART_JPEG)):
with self.subTest(name):
att = self.upload(data, "image/jpeg", f"{name}.jpg")["json"]
ready = self.ready(att["id"])
self.assertEqual(sorted(v["name"] for v in ready["variants"]), ["crop", "optimized", "thumbnail"])
self.assertEqual(self.content(att["id"])["bytes"], data)
def test_mime_spoofing_is_415(self):
cases = ((SAMPLE_PNG, "image/jpeg"), # PNG под видом JPEG
(SAMPLE_JPEG, "image/png"), # JPEG под видом PNG
+1 -1
View File
@@ -32,7 +32,7 @@ from datetime import datetime, timezone
from filegen import png, raw_upload, wait_status
from helpers import ROOT, Client, check, run
from stand import api_containers, compose_quiet, docker, wait_balanced
from stand import compose_quiet, docker, wait_balanced
MIB = 1024 * 1024
PROBE = "grep -E '^(VmRSS|VmHWM)' /proc/1/status; cat /sys/fs/cgroup/memory.peak 2>/dev/null || echo 0"
+161 -1
View File
@@ -11,20 +11,30 @@
- 16-битные, палитровые, CMYK-картинки обрабатываются;
- одинаковый вход даёт одинаковые байты (повтор задания идемпотентен);
- лимиты worker: пиксели (до декодирования), память (RLIMIT_AS дочернего процесса), время (SIGKILL).
Замечание к MR: проверка структуры JPEG в API (images.py) сверяется здесь с настоящим декодером
worker (libjpeg-turbo в строгом режиме, та же версия, что в образе):
- случайные повреждения заголовков: если API файл пропустил, декодер может споткнуться только
о сжатые данные скана (их без декодирования не проверить), но не о заголовки; если декодер
файл целиком принял, API его тоже не отклоняет;
- полный перебор коэффициентов субдискретизации: API и TurboJPEG принимают одни и те же схемы.
"""
import hashlib
import io
import itertools
import os
import random
import struct
import tempfile
import time
import unittest
import warnings
import zlib
from pathlib import Path
import simplejpeg
from PIL import Image, ImageCms, ImageOps
from messenger import imaging, sandbox
from messenger import images, imaging, sandbox
FIXTURE = Path(__file__).resolve().parents[2] / "tests" / "fixtures" / "sample.png"
@@ -42,6 +52,85 @@ def big_rgba_png(width, height):
return b"\x89PNG\r\n\x1a\n" + _chunk(b"IHDR", ihdr) + _chunk(b"IDAT", data) + _chunk(b"IEND", b"")
# ---------- JPEG по сегментам (для сверки проверки API с декодером) ----------
def jpeg_parts(data):
"""JPEG -> [("seg", маркер, данные) | ("scan", заголовок SOS, сжатые данные) | ("eoi", хвост)]."""
i, parts = 2, []
while True:
marker = data[i + 1]
i += 2
if marker == 0xD9:
parts.append(("eoi", data[i:]))
return parts
length = int.from_bytes(data[i:i + 2], "big")
payload, i = data[i + 2:i + length], i + length
if marker != 0xDA:
parts.append(("seg", marker, payload))
continue
j = i
while data[j] != 0xFF or data[j + 1] == 0x00 or 0xD0 <= data[j + 1] <= 0xD7:
j += 1
parts.append(("scan", payload, data[i:j]))
i = j
def jpeg_join(parts):
out = bytearray(b"\xff\xd8")
for part in parts:
if part[0] == "seg":
out += bytes([0xFF, part[1]]) + struct.pack(">H", len(part[2]) + 2) + part[2]
elif part[0] == "scan":
out += b"\xff\xda" + struct.pack(">H", len(part[1]) + 2) + part[1] + part[2]
else:
out += b"\xff\xd9" + part[1]
return bytes(out)
def gradient_jpeg(mode="RGB", size=(48, 32), **options):
image = Image.new(mode, size)
pixels = image.load()
for y in range(size[1]):
for x in range(size[0]):
value = (x * 7 + y * 13) % 256
pixels[x, y] = value if mode == "L" else tuple((value + k * 60) % 256 for k in range(len(mode)))
out = io.BytesIO()
image.save(out, "JPEG", **options)
return out.getvalue()
def api_verdict(data):
"""Что ответит API: accept или причина 415 (images.inspect без HTTP)."""
try:
width, height = images._header_size(io.BytesIO(data), "JPEG")
images.check_jpeg(data, width, height)
return "accept"
except Exception as exc: # UnsupportedMediaType / Broken
return f"reject: {exc}"
def worker_verdict(data):
"""Что скажет worker: строгий libjpeg-turbo (как imaging._strict_jpeg_check) и Pillow."""
try:
_h, _w, colorspace, _sub = simplejpeg.decode_jpeg_header(data)
target = "CMYK" if colorspace in ("CMYK", "YCCK") else ("GRAY" if colorspace == "Gray" else "RGB")
simplejpeg.decode_jpeg(data, colorspace=target, strict=True, min_factor=8)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
with Image.open(io.BytesIO(data)) as image:
image.load()
except Exception as exc:
return str(exc)
return "ok"
# Ошибки, которые libjpeg находит только внутри сжатых данных скана (без декодирования не проверить):
# неверный код Хаффмана, данные кончились раньше блоков, лишние байты в конце данных,
# RST не на границе интервала.
ENTROPY_ERRORS = ("bad Huffman code", "premature end of data segment", "extraneous bytes before marker",
"instead of RST")
class ImagingTest(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
@@ -169,6 +258,77 @@ class ImagingTest(unittest.TestCase):
with self.assertRaises(imaging.InvalidImage): # ...а строгая проверка libjpeg-turbo — нет
imaging.process(path, os.path.join(self.dir, "o"), "image/jpeg")
def test_jpeg_header_check_matches_strict_decoder(self):
bases = [gradient_jpeg(), gradient_jpeg(subsampling=0), gradient_jpeg(subsampling=1),
gradient_jpeg(progressive=True), gradient_jpeg(progressive=True, optimize=True),
gradient_jpeg(restart_marker_blocks=1), gradient_jpeg("L"), gradient_jpeg("CMYK"),
gradient_jpeg(size=(130, 70), restart_marker_rows=1),
gradient_jpeg(size=(64, 64), progressive=True, restart_marker_blocks=2)]
for data in bases:
self.assertEqual((api_verdict(data), worker_verdict(data)), ("accept", "ok"))
rnd = random.Random(20261026)
counts = {"both accept": 0, "both reject": 0, "accepted, entropy error in worker": 0}
for _ in range(800):
parts = jpeg_parts(rnd.choice(bases))
k = rnd.choice([n for n, part in enumerate(parts) if part[0] != "eoi"])
operation = rnd.randrange(6)
if operation <= 2: # байт в заголовке сегмента или скана
part = parts[k]
payload = bytearray(part[2] if part[0] == "seg" else part[1])
if payload:
position = rnd.randrange(len(payload))
payload[position] = rnd.choice([rnd.randrange(256), (payload[position] + 1) % 256,
payload[position] ^ (1 << rnd.randrange(8))])
parts[k] = ("seg", part[1], bytes(payload)) if part[0] == "seg" else ("scan", bytes(payload), part[2])
elif operation == 3: # сегмент или скан пропал
del parts[k]
elif operation == 4: # сегмент или скан повторился
parts.insert(k, parts[k])
else: # лишний или чужой маркер RST в сжатых данных
scans = [n for n, part in enumerate(parts) if part[0] == "scan"]
n = rnd.choice(scans)
entropy = bytearray(parts[n][2])
position = rnd.randrange(len(entropy))
entropy[position:position] = bytes([0xFF, 0xD0 + rnd.randrange(8)])
parts[n] = ("scan", parts[n][1], bytes(entropy))
data = jpeg_join(parts)
api, worker = api_verdict(data), worker_verdict(data)
with self.subTest(api=api, worker=worker):
if api == "accept":
# Пропущенный API файл не должен падать в worker на заголовках.
self.assertTrue(worker == "ok" or any(e in worker for e in ENTROPY_ERRORS))
else:
# Отклонённый API файл декодер тоже не принимает целиком.
self.assertNotEqual(worker, "ok")
if api == "accept":
counts["both accept" if worker == "ok" else "accepted, entropy error in worker"] += 1
else:
counts["both reject"] += 1
print(f"\n 800 random header mutations: {counts}")
def test_subsampling_rule_matches_turbojpeg(self):
factors = [(h, v) for h in range(1, 5) for v in range(1, 5)]
cases = [(gradient_jpeg("L"), [(f,) for f in factors]),
(gradient_jpeg(), list(itertools.product(factors, repeat=3))),
(gradient_jpeg("CMYK"), [(y, c, c, k) for y in factors for c in factors for k in factors])]
compared = 0
for data, combinations in cases:
parts = jpeg_parts(data)
sof = next(n for n, part in enumerate(parts) if part[0] == "seg" and part[1] == 0xC0)
for combination in combinations:
payload = bytearray(parts[sof][2])
for k, (h, v) in enumerate(combination):
payload[7 + 3 * k] = h * 16 + v
parts[sof] = ("seg", 0xC0, bytes(payload))
try:
simplejpeg.decode_jpeg_header(jpeg_join(parts))
decoder = True
except (ValueError, KeyError): # KeyError: схема, которой нет в simplejpeg (4:4:1)
decoder = False
self.assertEqual(images._subsampling_supported(list(combination)), decoder, combination)
compared += 1
print(f"\n {compared} sampling-factor combinations: API and TurboJPEG agree on every one")
def test_limits_in_child_process(self):
path = os.path.join(self.dir, "big.png")
Path(path).write_bytes(big_rgba_png(6000, 6000)) # 36 млн пикселей RGBA