diff --git a/Makefile b/Makefile index 043f772..4c2631b 100644 --- a/Makefile +++ b/Makefile @@ -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 diff --git a/REPORT.md b/REPORT.md index e76cb58..fc26ae2 100644 --- a/REPORT.md +++ b/REPORT.md @@ -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=` (задание, журнал, outbox, варианты), `make replay ID=`, `make queues` (очереди брокера и DLQ), `make cleanup ARGS=--dry-run`. +Остановить worker для демонстрации: `make worker-stop`, запустить: `make worker-start`. Команды оператора: `make jobs` (сколько заданий в каждом состоянии), `make failed` (реестр failed), `make job ID=` (задание, журнал, outbox, варианты), `make replay ID=`, `make queues` (очереди брокера и DLQ), `make cleanup ARGS=--dry-run` (или `ARGS="--attachment "` — только одно вложение). Безопасная остановка: `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/` (ключ назначает сервер). -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. \ No newline at end of file diff --git a/evidence/attachment-failover.txt b/evidence/attachment-failover.txt index 33dd693..cb6b759 100644 --- a/evidence/attachment-failover.txt +++ b/evidence/attachment-failover.txt @@ -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) diff --git a/evidence/cleanup-race.txt b/evidence/cleanup-race.txt new file mode 100644 index 0000000..38e3e03 --- /dev/null +++ b/evidence/cleanup-race.txt @@ -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 diff --git a/evidence/concurrency.txt b/evidence/concurrency.txt index 4c6b543..fc1ddc0 100644 --- a/evidence/concurrency.txt +++ b/evidence/concurrency.txt @@ -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 diff --git a/evidence/db-test.txt b/evidence/db-test.txt index 0d4978c..0749c45 100644 --- a/evidence/db-test.txt +++ b/evidence/db-test.txt @@ -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 diff --git a/evidence/failover.txt b/evidence/failover.txt index 36453df..866655b 100644 --- a/evidence/failover.txt +++ b/evidence/failover.txt @@ -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 diff --git a/evidence/failure-s3.txt b/evidence/failure-s3.txt index 58d53e1..15165b1 100644 --- a/evidence/failure-s3.txt +++ b/evidence/failure-s3.txt @@ -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 diff --git a/evidence/imaging-test.txt b/evidence/imaging-test.txt index 5469874..7b85c19 100644 --- a/evidence/imaging-test.txt +++ b/evidence/imaging-test.txt @@ -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 diff --git a/evidence/lease.txt b/evidence/lease.txt index 2a8cd99..09eeb95 100644 --- a/evidence/lease.txt +++ b/evidence/lease.txt @@ -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) diff --git a/evidence/outbox-crash.txt b/evidence/outbox-crash.txt index fc45685..804c579 100644 --- a/evidence/outbox-crash.txt +++ b/evidence/outbox-crash.txt @@ -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 diff --git a/evidence/persistence.txt b/evidence/persistence.txt index 93d90fb..162cb1a 100644 --- a/evidence/persistence.txt +++ b/evidence/persistence.txt @@ -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 diff --git a/evidence/redelivery.txt b/evidence/redelivery.txt index 76203e3..bee65db 100644 --- a/evidence/redelivery.txt +++ b/evidence/redelivery.txt @@ -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 diff --git a/evidence/retry-replay.txt b/evidence/retry-replay.txt index 6b1467d..490b481 100644 --- a/evidence/retry-replay.txt +++ b/evidence/retry-replay.txt @@ -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 diff --git a/evidence/s3-checks.txt b/evidence/s3-checks.txt index 2d86fbc..1bfd7f1 100644 --- a/evidence/s3-checks.txt +++ b/evidence/s3-checks.txt @@ -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 diff --git a/evidence/stack.txt b/evidence/stack.txt index f973781..26c0a0f 100644 --- a/evidence/stack.txt +++ b/evidence/stack.txt @@ -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: Миграции: новых нет, схема актуальна diff --git a/evidence/staging-cleanup.txt b/evidence/staging-cleanup.txt index 36efc1e..acc2892 100644 --- a/evidence/staging-cleanup.txt +++ b/evidence/staging-cleanup.txt @@ -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 diff --git a/evidence/student-test.txt b/evidence/student-test.txt index ed91e43..d338adb 100644 --- a/evidence/student-test.txt +++ b/evidence/student-test.txt @@ -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, второе сообщение не создано diff --git a/evidence/worker-crash.txt b/evidence/worker-crash.txt index c0f4963..44007d4 100644 --- a/evidence/worker-crash.txt +++ b/evidence/worker-crash.txt @@ -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 diff --git a/evidence/worker-outage.txt b/evidence/worker-outage.txt index af51325..ddf213c 100644 --- a/evidence/worker-outage.txt +++ b/evidence/worker-outage.txt @@ -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 diff --git a/src/messenger/attachments.py b/src/messenger/attachments.py index 41bfc18..3195696 100644 --- a/src/messenger/attachments.py +++ b/src/messenger/attachments.py @@ -17,6 +17,8 @@ Картинка НЕ декодируется и не уменьшается — это работа worker; 3. PUT оригинала в staging/ (ключ назначает сервер); 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 diff --git a/src/messenger/cleanup.py b/src/messenger/cleanup.py index fa8f980..a5a63e7 100644 --- a/src/messenger/cleanup.py +++ b/src/messenger/cleanup.py @@ -4,26 +4,42 @@ обработки больше не нужен. Уборщик сверяет содержимое bucket с базой и удаляет то, на что база не ссылается. -Что нужно и не удаляется (PostgresStore.storage_references): +Что нужно и не удаляется: - оригинал ready-вложения (originals/) и все его варианты (variants//...); -- 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 # только объекты одного вложения Вывод — одна строка 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 diff --git a/src/messenger/faults.py b/src/messenger/faults.py index ea616ab..9bdeaf9 100644 --- a/src/messenger/faults.py +++ b/src/messenger/faults.py @@ -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)) diff --git a/src/messenger/images.py b/src/messenger/images.py index 4577ab0..dccdf4e 100644 --- a/src/messenger/images.py +++ b/src/messenger/images.py @@ -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() diff --git a/src/messenger/imaging.py b/src/messenger/imaging.py index edaa7a4..98beaa9 100644 --- a/src/messenger/imaging.py +++ b/src/messenger/imaging.py @@ -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: diff --git a/src/messenger/jobs.py b/src/messenger/jobs.py index ccb6f24..323eb47 100644 --- a/src/messenger/jobs.py +++ b/src/messenger/jobs.py @@ -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} diff --git a/src/messenger/objects.py b/src/messenger/objects.py index 9ff60b4..9faa33c 100644 --- a/src/messenger/objects.py +++ b/src/messenger/objects.py @@ -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/, originals/, variants//... + Для ключа другого вида — 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 diff --git a/src/messenger/store.py b/src/messenger/store.py index cc2c7cf..ce2e81f 100644 --- a/src/messenger/store.py +++ b/src/messenger/store.py @@ -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: diff --git a/src/messenger/worker.py b/src/messenger/worker.py index b27ccdc..c3f7b93 100644 --- a/src/messenger/worker.py +++ b/src/messenger/worker.py @@ -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) diff --git a/student-tests/attachment_failover.py b/student-tests/attachment_failover.py index 0fb82fc..d979d01 100644 --- a/student-tests/attachment_failover.py +++ b/student-tests/attachment_failover.py @@ -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(): diff --git a/student-tests/cleanup_race.py b/student-tests/cleanup_race.py new file mode 100644 index 0000000..3bb883b --- /dev/null +++ b/student-tests/cleanup_race.py @@ -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) diff --git a/student-tests/db/test_cleanup.py b/student-tests/db/test_cleanup.py new file mode 100644 index 0000000..2d72503 --- /dev/null +++ b/student-tests/db/test_cleanup.py @@ -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) diff --git a/student-tests/filegen.py b/student-tests/filegen.py index 8a141ca..37af896 100644 --- a/student-tests/filegen.py +++ b/student-tests/filegen.py @@ -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") diff --git a/student-tests/ops.py b/student-tests/ops.py index d0738b6..ddc68d6 100644 --- a/student-tests/ops.py +++ b/student-tests/ops.py @@ -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]: diff --git a/student-tests/test_attachments.py b/student-tests/test_attachments.py index d366841..ad2a3e3 100644 --- a/student-tests/test_attachments.py +++ b/student-tests/test_attachments.py @@ -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 diff --git a/student-tests/upload_memory.py b/student-tests/upload_memory.py index 53d7964..27ab29e 100644 --- a/student-tests/upload_memory.py +++ b/student-tests/upload_memory.py @@ -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" diff --git a/student-tests/worker/test_imaging.py b/student-tests/worker/test_imaging.py index 233fbe0..23f798d 100644 --- a/student-tests/worker/test_imaging.py +++ b/student-tests/worker/test_imaging.py @@ -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