исправление
This commit is contained in:
@@ -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
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
- Автор, группа: Гаджиев Нухбала, БВТ2303
|
||||
- Целевая оценка; выбранный трек 5, если нужен: 4, трек 5 не выбран
|
||||
- Commit/PR: TODO после публикации
|
||||
- Commit/PR: https://gitea.privcloud.tech/mtusi2026/mtusi2026lab5/pulls/4
|
||||
- Использованные источники, библиотеки и помощь ИИ: всё из lab4 (FastAPI, uvicorn, pydantic, psycopg 3, argon2-cffi, valkey-py, boto3, Pillow 13.0.0, HAProxy 3.2, PostgreSQL 17, Valkey 8.1, SeaweedFS 4.44) и новое: RabbitMQ 4.2.9 (брокер), pika 1.4.4 (клиент RabbitMQ), simplejpeg 1.9.0 и numpy 2.3.5 (строгая проверка JPEG через libjpeg-turbo). Документация: RabbitMQ (Reliability Guide, Consumer Acknowledgements and Publisher Confirms, Quorum Queues, Dead Letter Exchanges, Configuration), pika (BlockingConnection, add_callback_threadsafe), PostgreSQL (SELECT … FOR UPDATE SKIP LOCKED), Pillow (draft, resize с reducing_gap, ImageOps.exif_transpose), спецификация PNG (блоки, фильтры строк, Adam7). ИИ использовался только как вспомогательный ресурс: для оценки решения, написания комментариев к коду и составления текстовых документов.
|
||||
|
||||
## Запуск из чистого clone
|
||||
@@ -25,11 +25,11 @@ make restore PYTHON=python
|
||||
make test-persistence ACTION_SCRIPT=scripts/restart.cmd PYTHON=python # Linux/macOS: scripts/restart.sh
|
||||
```
|
||||
|
||||
Свои проверки lab5: `make worker-outage`, `redelivery`, `outbox-crash`, `worker-crash`, `retry-replay`, `lease`, `concurrency`, `staging-cleanup`, `imaging-test`, `db-test` (на Windows с `PYTHON=python`). Проверки lab2–lab4 остались: `make student-test`, `attachments`, `attachment-failover`, `failure-s3`, `s3-checks`, `failover`, `persistence`, `check-stack` и др. Все HTTP-проверки идут через балансировщик `http://127.0.0.1:8080`.
|
||||
Свои проверки lab5: `make worker-outage`, `redelivery`, `outbox-crash`, `worker-crash`, `retry-replay`, `lease`, `concurrency`, `staging-cleanup`, `cleanup-race`, `imaging-test`, `db-test` (на Windows с `PYTHON=python`). Проверки lab2–lab4 остались: `make student-test`, `attachments`, `attachment-failover`, `failure-s3`, `s3-checks`, `failover`, `persistence`, `check-stack` и др. Все HTTP-проверки идут через балансировщик `http://127.0.0.1:8080`.
|
||||
|
||||
Bootstrap. Схему БД создаёт одноразовый `migrate` (миграции 001–006), bucket — одноразовый `s3-init`. Пользователя, пароль, vhost и права RabbitMQ брокер берёт из файла-секрета `secrets/rabbitmq_credentials.conf` при первом запуске с пустым volume; exchange и очереди объявляют relay и worker при подключении (повторное объявление с теми же параметрами ничего не меняет). Всё повторяемо: `docker compose run --rm migrate`, `make s3-bootstrap`. Действие оператора одно: один раз создать секреты.
|
||||
|
||||
Остановить worker для демонстрации: `make worker-stop`, запустить: `make worker-start`. Команды оператора: `make jobs` (сколько заданий в каждом состоянии), `make failed` (реестр failed), `make job ID=<attachment_id>` (задание, журнал, outbox, варианты), `make replay ID=<attachment_id>`, `make queues` (очереди брокера и DLQ), `make cleanup ARGS=--dry-run`.
|
||||
Остановить worker для демонстрации: `make worker-stop`, запустить: `make worker-start`. Команды оператора: `make jobs` (сколько заданий в каждом состоянии), `make failed` (реестр failed), `make job ID=<attachment_id>` (задание, журнал, outbox, варианты), `make replay ID=<attachment_id>`, `make queues` (очереди брокера и DLQ), `make cleanup ARGS=--dry-run` (или `ARGS="--attachment <id>"` — только одно вложение).
|
||||
|
||||
Безопасная остановка: `make down` (volumes `pgdata`, `s3data`, `rabbitmqdata` остаются). Намеренное удаление учебных данных: `docker compose down -v`, затем `rm -rf secrets` и снова `sh scripts/init-secrets.sh` (пароль RabbitMQ задаётся только при первом запуске, поэтому секреты и volume удаляются вместе).
|
||||
|
||||
@@ -61,9 +61,9 @@ migrate, s3-init — одноразовые; сети: edge (lb <-> api), backen
|
||||
|
||||
Приём (`src/messenger/attachments.py`) и что сохранено в момент 202:
|
||||
1. Проверки как в lab4: токен, участник чата, `filename`, `Content-Type`, размер до и во время чтения, тип по первым байтам, пиксели по заголовку до распаковки.
|
||||
2. Структура файла без декодирования пикселей (`images.py`): у PNG — блоки, CRC, палитра, tRNS, ничего после IEND, распаковка IDAT порциями по 1 МиБ с подсчётом байт и проверкой типа фильтра строк; у JPEG — маркеры, один кадр SOF, непустые сканы, EOI. Заведомо битые — 415.
|
||||
2. Структура файла без декодирования пикселей (`images.py`): у PNG — блоки, CRC, палитра, tRNS, ничего после IEND, распаковка IDAT порциями по 1 МиБ с подсчётом байт и проверкой типа фильтра строк. У JPEG — всё, что строгий декодер worker (libjpeg-turbo) проверяет по маркерам и заголовкам: известные маркеры и длины сегментов, кадр SOF, таблицы DQT/DHT (коды Хаффмана помещаются в свою длину), каждый компонент скана SOS есть в SOF и не повторяется, параметры сканов, порядок и число маркеров RST, версия JFIF, код Adobe, схема субдискретизации, которую понимает декодер, EOI. Заведомо битые — 415. В worker остаются только ошибки внутри сжатых данных скана: их не найти без декодирования каждого блока (failed, `invalid_image`).
|
||||
3. PUT оригинала в `staging/<id>` (ключ назначает сервер).
|
||||
4. Одна транзакция: вложение `queued` + задание `attempt=1` + строка outbox (тело сообщения) + запись в журнал. После COMMIT — 202 `queued`. Сам ответ не ждёт брокера.
|
||||
4. Одна транзакция: вложение `queued` + задание `attempt=1` + строка outbox (тело сообщения) + запись в журнал. После COMMIT — 202 `queued`. Сам ответ не ждёт брокера. Шаги 3–4 идут под advisory-блокировкой ID вложения: пока загрузка не закоммичена, уборщик её staging не трогает.
|
||||
|
||||
Outbox (`relay.py`, поток в каждой реплике API). Relay берёт неотправленные строки с `FOR UPDATE SKIP LOCKED` (реплики не мешают друг другу), публикует в брокер с publisher confirm и только потом ставит `published_at`. Если API упал после COMMIT, строку отправит relay другой реплики или этой после перезапуска. Если relay упал после подтверждения брокера, строка уйдёт ещё раз (дубль, это нормально при at-least-once). Брокер недоступен — загрузки по-прежнему 202, строки ждут в PostgreSQL. Поэтому брокер не входит в readiness, а S3 входит: без S3 не принять файл в staging.
|
||||
|
||||
@@ -73,7 +73,7 @@ Worker (`worker.py`). Проверяет сообщение по схеме (н
|
||||
|
||||
Состояния (наружу как есть): `queued` → `processing` (lease) → `ready` / `failed`; временная ошибка или истёкший lease → снова `queued` со следующей попыткой; `failed` → `queued` только по replay оператора. Ключ эффекта `(attachment_id, pipeline_version, variant)` — первичный ключ `attachment_variants` и он же ключ объекта в S3: повтор не создаёт второй набор. Ready не откатывается назад: все переходы обновляют вложение только из `queued`/`processing`.
|
||||
|
||||
Повторы и ошибки. Постоянные (`invalid_image`, `image_too_large`, `source_missing`, `source_corrupted`) — failed сразу, сообщение в DLQ. Временные (`storage_unavailable`, `processing_timeout`, `worker_crashed`, `lease_expired`, `processing_failed`) — следующая попытка через backoff с jitter: пауза случайная в [d/2, d], d = min(60 с, 2 с · 2^(n−1)). Всего попыток `JOB_MAX_ATTEMPTS=5`, потом failed с `retry_exhausted` и DLQ. Реестр failed — таблица `attachment_jobs` (`make failed`), журнал — `job_events`. Replay (`make replay ID=...`) переводит только failed в queued с новой попыткой и записью в журнале (кто и что было). Для ready или ещё идущего задания он ничего не делает. Если staging уже удалён (прошло `STAGING_RETENTION_SECONDS`), replay отказывает.
|
||||
Повторы и ошибки. Постоянные (`invalid_image`, `image_too_large`, `source_missing`, `source_corrupted`) — failed сразу, сообщение в DLQ. Временные (`storage_unavailable`, `processing_timeout`, `worker_crashed`, `lease_expired`, `processing_failed`) — следующая попытка через backoff с jitter: пауза случайная в [d/2, d], d = min(60 с, 2 с · 2^(n−1)). Всего попыток `JOB_MAX_ATTEMPTS=5`, потом failed с `retry_exhausted` и DLQ. Реестр failed — таблица `attachment_jobs` (`make failed`), журнал — `job_events`. Replay (`make replay ID=...`) переводит только failed в queued с новой попыткой и записью в журнале (кто и что было). Для ready или ещё идущего задания он ничего не делает. Если staging уже удалён (прошло `STAGING_RETENTION_SECONDS`), replay отказывает (`source_missing`, тоже с записью в журнале). Всё это одна транзакция под блокировкой строк задания и вложения — тех же, что берёт уборщик.
|
||||
|
||||
Lease (`jobs.py`). Захват — жетон и срок `JOB_LEASE_SECONDS=30`. Пока worker жив, он продлевает аренду каждые 10 с, поэтому долгая задача не теряет её. Зависший или мёртвый worker не продлевает, и через 30 с фоновая проверка (`reap`, раз в 5 с) засчитывает попытку как неудачную и назначает следующую. Результат принимается, только если жетон совпадает (fencing): опоздавший worker ничего не перезапишет, а обнаружив потерю lease, бросает работу. Если lease держит прежний запуск того же контейнера (Docker его перезапустил), попытка засчитывается сразу, без ожидания 30 с. Попытка не дольше `JOB_TIMEOUT_SECONDS=60`: дочерний процесс убивается.
|
||||
|
||||
@@ -81,9 +81,13 @@ Lease (`jobs.py`). Захват — жетон и срок `JOB_LEASE_SECONDS=30
|
||||
|
||||
Лимиты worker. Байты: объект из staging не больше 10 MiB и совпадает с размером и SHA-256 в БД. Пиксели: не больше 40 млн, проверяются до декодирования. Сжатые данные JPEG проверяются строго (libjpeg-turbo, предупреждение = ошибка): Pillow битый скан молча «дорисовывает» серым. Память: дочерний процесс с `RLIMIT_AS = WORKER_MEMORY_LIMIT_MB = 640` МиБ (нехватка → `image_too_large`), контейнер — 1 ГиБ. Время: `JOB_TIMEOUT_SECONDS=60`, потом SIGKILL. Параллельно `WORKER_CONCURRENCY=2` задания, prefetch брокера тоже 2.
|
||||
|
||||
Уборка (`cleanup.py`, поток worker раз в 5 мин и `make cleanup`). Нужные объекты: оригиналы и варианты ready, staging заданий в работе, staging failed моложе 24 ч. Остальное удаляется, только если старше grace 15 мин: staging готового (если worker не успел удалить), staging failed после retention, объекты без строки в БД. Есть dry-run.
|
||||
Уборка (`cleanup.py`, поток worker раз в 5 мин и `make cleanup`). Нужные объекты: оригиналы и варианты ready, ВСЕ объекты вложений в работе (queued, processing: worker может прямо сейчас писать оригинал и варианты), все объекты failed-вложения моложе 24 ч (replay запишет их заново в те же ключи), staging загрузки, которая ещё не закоммичена. Остальное удаляется, только если старше grace 15 мин: staging готового (если worker не успел удалить), объекты failed после retention, объекты без строки в БД. Есть dry-run и уборка одного вложения (`--attachment`). Как уборщик не удаляет текущую работу (замечание к MR): список объектов и снимок ссылок только отбирают кандидатов, а решение по каждому вложению принимается заново под блокировками (`store.cleanup_attachment`): advisory-блокировка ID вложения без ожидания (её держит идущая загрузка — тогда вложение пропускается), затем строки задания и вложения (`FOR NO KEY UPDATE`, тот же порядок, что у worker и replay). У failed-вложения после retention в той же транзакции помечается, что исходника нет (`staging_key = NULL`, запись `staging_expired` в журнале): replay, который ждал блокировку или пришёл позже, безопасно отказывает. Из S3 объекты удаляются уже после COMMIT и только те, что больше никогда не понадобятся, поэтому медленный S3 не держит блокировки, а оборванная сессия БД не открывает окно для гонки.
|
||||
|
||||
Что перенесено из lab4: весь код, миграции 001–005, свои тесты, Dockerfile, конфиги HAProxy/Valkey, SeaweedFS и `s3-init`, скрипты. Что изменено: сервисы `broker` и `worker`, volume `rabbitmqdata`, секреты RabbitMQ, миграция 006 (задания, outbox, варианты, журнал), модули `broker.py`, `relay.py`, `jobs.py`, `worker.py`, `sandbox.py`, `imaging.py`, `faults.py`; загрузка 201 → 202; `images.py` — вместо полного декодирования проверка структуры (PNG по спецификации, JPEG по маркерам); `/health/ready` проверяет и S3; уборщик переехал в worker и знает про staging и варианты; hook перезапуска перезапускает ещё брокер и worker.
|
||||
Что перенесено из lab4: весь код, миграции 001–005, свои тесты, Dockerfile, конфиги HAProxy/Valkey, SeaweedFS и `s3-init`, скрипты. Что изменено: сервисы `broker` и `worker`, volume `rabbitmqdata`, секреты RabbitMQ, миграция 006 (задания, outbox, варианты, журнал), модули `broker.py`, `relay.py`, `jobs.py`, `worker.py`, `sandbox.py`, `imaging.py`, `faults.py`; загрузка 201 → 202; `images.py` — вместо полного декодирования проверка структуры (PNG по спецификации, JPEG по правилам строгого декодера); `/health/ready` проверяет и S3; уборщик переехал в worker и знает про staging и варианты; hook перезапуска перезапускает ещё брокер и worker.
|
||||
|
||||
Исправления по замечаниям к MR:
|
||||
1. Структурно повреждённый JPEG (SOS ссылается на компонент 250, которого нет в SOF) принимался с 202 и только потом становился failed. Причина: у скана проверялась длина, но не связь с кадром. Теперь `images.py` повторяет все проверки заголовков строгого декодера worker (список — в п. 2 «Приёма»), такой файл получает 415. Совпадение с декодером проверено в образе: 800 случайных повреждений заголовков и 8208 комбинаций субдискретизации без расхождений (`make imaging-test`).
|
||||
2. Уборщик мог удалить staging уже принятого replay: удалял по снимку ссылок без согласования с изменением состояния. Теперь решение принимается под блокировками по текущему состоянию, replay — одна транзакция под теми же блокировками, а staging сначала помечается удалённым в БД (подробно — в абзаце «Уборка»). Тем же механизмом закрыты ещё два окна, которые видны при grace = 0: загрузка между PUT в staging и COMMIT и объекты worker до COMMIT результата. Проверки: `make db-test` (барьеры в настоящей PostgreSQL) и `make cleanup-race` (то же на стенде с точками-паузами).
|
||||
|
||||
Переменные (новые; остальные как в lab4, см. `.env.example`):
|
||||
|
||||
@@ -123,6 +127,7 @@ Lease (`jobs.py`). Захват — жетон и срок `JOB_LEASE_SECONDS=30
|
||||
| 3: демонстрация worker остановлен → … → ready; задание переживает рестарт брокера | make worker-outage | 202 → сообщение с вложением → перезапуск API и брокера → worker → ready, thumbnail доступен | evidence/worker-outage.txt |
|
||||
| 4: crop 128×128 и optimized WebP, параметры качества и удаления метаданных | make attachments; make imaging-test | crop JPEG 128×128, optimized WebP ≤1280; ориентация EXIF, белый фон под прозрачностью; в вариантах нет EXIF/XMP/ICC | evidence/student-test.txt, imaging-test.txt |
|
||||
| 4: лимиты по байтам, пикселям, времени и памяти worker | make imaging-test; make attachments | 36 Мп RGBA в лимите 640 МиБ — ok, в лимите 200 МиБ — image_too_large; таймаут — процесс убит; лимит пикселей до декодирования; битый скан JPEG — invalid_image; ровно 10 MiB и 40 млн px — ready, на 1 больше — 413 | evidence/imaging-test.txt, student-test.txt |
|
||||
| Контракт: заведомо повреждённые JPEG — 415 (замечание к MR 1) | make student-test; make imaging-test | пример из замечания (байт i+5 первого SOS = 250) и ещё 26 повреждений заголовков — 415; корректные progressive и с маркерами RST — ready; проверка API совпадает со строгим декодером на 800 случайных повреждениях и 8208 схемах субдискретизации | evidence/student-test.txt, imaging-test.txt |
|
||||
| 4: transactional outbox, crash между COMMIT и publish, ready без ручного задания | make outbox-crash; make db-test | A: API упал после COMMIT; B: relay упал до publish; C: relay упал после publish — во всех ready, одна попытка, один набор вариантов; D: брокер остановлен — 202, строка ждёт, потом ready | evidence/outbox-crash.txt, db-test.txt |
|
||||
| 4: backoff с jitter, постоянные и временные ошибки | make retry-replay; make db-test | паузы в [d/2, d] при d = 2, 4, 8, 16 с; битый JPEG — invalid_image сразу, попытка 1 | evidence/retry-replay.txt, db-test.txt |
|
||||
| 4: DLQ / реестр failed и безопасный явный replay | make retry-replay | failed → DLQ +1 и `jobs failed`; replay failed → ready с записью в журнале; replay ready — noop, нового сообщения нет | evidence/retry-replay.txt |
|
||||
@@ -130,6 +135,7 @@ Lease (`jobs.py`). Захват — жетон и срок `JOB_LEASE_SECONDS=30
|
||||
| 4: timeout/lease для зависшего processing | make lease | долгая задача продлевает lease; замороженный worker теряет его, задание забирает второй worker, проснувшийся ничего не перезаписывает | evidence/lease.txt |
|
||||
| 4: ограниченная конкуренция и prefetch | make concurrency | одновременно не больше 2 заданий в processing и 2 сообщений без ack, остальные ждут в очереди | evidence/concurrency.txt |
|
||||
| 4: очистка staging после безопасной фиксации | make staging-cleanup | staging удаляется сразу после COMMIT; остатки и «сироты» — после grace; staging failed хранится до retention; dry-run и повтор безопасны | evidence/staging-cleanup.txt |
|
||||
| Уборка не удаляет текущую работу (замечание к MR 2) | make cleanup-race; make db-test | grace 0: снимок → replay → уборщик: staging не удалён, потом ready (было failed/source_missing); уборщик уже пометил staging удалённым и держит блокировку → replay ждёт её и отказывает source_missing, задание failed; загрузка до COMMIT — пропущена (занято); объекты worker до COMMIT — не удалены | evidence/cleanup-race.txt, db-test.txt |
|
||||
| Свойства lab4: S3 приватный, права, bootstrap; S3 недоступен | make s3-checks; make failure-s3 | анонимно 403, ключ API не может создать, удалить или открыть bucket; в сообщении брокера только ID; S3 остановлен — реплики не готовы, балансировщик отвечает 503, после запуска файл цел | evidence/s3-checks.txt, failure-s3.txt |
|
||||
| Выбранный трек 5 | — | не выбран | — |
|
||||
|
||||
@@ -152,17 +158,20 @@ Lease (`jobs.py`). Захват — жетон и срок `JOB_LEASE_SECONDS=30
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| `docker compose stop worker`, upload | 202, queued, API работает | 202, queued, /content 409, текст 201 | после `start worker` ready за 3,2 с; потерь нет |
|
||||
| `docker compose stop worker`, upload | 202, queued, API работает | 202, queued, /content 409, текст 201 | после `start worker` ready за 3,8 с; потерь нет |
|
||||
| Перезапуск API и брокера с volumes, worker остановлен | задание не теряется | строка outbox отправлена один раз до перезапуска, после запуска worker — ready | потерь нет |
|
||||
| API падает после COMMIT, до 202 | работа принята | клиент получил 502, вложение ready (строку отправил relay другой реплики) | сразу; потерь нет |
|
||||
| relay падает до / после publish | задание доходит до ready | до: строка отправлена после перезапуска; после: дубль, duplicate_ignored | секунды (перезапуск контейнера Docker); потерь нет |
|
||||
| брокер остановлен | загрузки 202, задания ждут | строка outbox не отправлена, после запуска брокера — ready | ready через 6,4 с после запуска брокера |
|
||||
| брокер остановлен | загрузки 202, задания ждут | строка outbox не отправлена, после запуска брокера — ready | ready через 11,8 с после запуска брокера |
|
||||
| worker падает после записи в S3 до ack | тот же результат | попытка 2, те же ключи и SHA-256 | секунды (прежний запуск того же контейнера) |
|
||||
| worker заморожен (`docker pause`) | задание переходит к другому worker | lease истёк, второй worker сделал ready, проснувшийся бросил работу | 31 с после заморозки (JOB_LEASE_SECONDS=30) |
|
||||
| временная ошибка 2 раза / всегда | повтор с паузой / failed | ready на попытке 3 / failed retry_exhausted после 5 попыток | паузы 1,84 / 2,45 / 6,81 / 15,37 с (диапазоны 1–2, 2–4, 4–8, 8–16 с) |
|
||||
| `docker compose stop s3` | реплики не готовы, 503 | реплики вне балансировки через 1,0 с, live 200, ready 503, балансировщик отвечает 503 | после `start s3` реплики вернулись через 23,7 с, файл цел |
|
||||
| остановка одной реплики API (`make failover`) | запросы идут на другую | 119 и 125 успешных записей, 0 ошибок | 5,1 и 5,5 с до первого успешного запроса |
|
||||
| перезапуск всего стенда (`make persistence`) | данные, файл и токен сохраняются | всё на месте | 44,6 с вместе с ожиданием готовности |
|
||||
| worker заморожен (`docker pause`) | задание переходит к другому worker | lease истёк, второй worker сделал ready, проснувшийся бросил работу | 33 с после заморозки (JOB_LEASE_SECONDS=30) |
|
||||
| временная ошибка 2 раза / всегда | повтор с паузой / failed | ready на попытке 3 / failed retry_exhausted после 5 попыток | паузы 1,96 / 2,31 / 5,86 / 13,62 с (диапазоны 1–2, 2–4, 4–8, 8–16 с) |
|
||||
| `docker compose stop s3` | реплики не готовы, 503 | реплики вне балансировки через 0,9 с, live 200, ready 503, балансировщик отвечает 503 | после `start s3` реплики вернулись через 18,0 с, файл цел |
|
||||
| остановка одной реплики API (`make failover`) | запросы идут на другую | по 124 успешных записи, 0 ошибок | 4,5 и 4,6 с до первого успешного запроса |
|
||||
| перезапуск всего стенда (`make persistence`) | данные, файл и токен сохраняются | всё на месте | 49,6 с вместе с ожиданием готовности |
|
||||
| уборщик прочитал ссылки, затем replay (`make cleanup-race` A) | staging нужен текущей работе | уборщик перепроверил под блокировкой: удалено 0, staging на месте | после запуска worker — ready; потерь нет |
|
||||
| уборщик решил удалить staging (пометил в БД, COMMIT ещё нет), в это время replay (B) | безопасный отказ replay | replay ждал блокировку 8,0 с (пауза уборщика в тесте), отказ source_missing, задание failed, журнал: staging_expired → replay_refused | работа не потеряна: её и не было (retention истёк) |
|
||||
| уборка во время загрузки, до COMMIT (C) и во время обработки, до COMMIT (D) | ничего не удаляется | C: вложение пропущено как занятое; D: 4 объекта оставлены (processing) | загрузка — 202 → ready; обработка — ready, SHA-256 совпадают |
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
@@ -170,7 +179,10 @@ Lease (`jobs.py`). Захват — жетон и срок `JOB_LEASE_SECONDS=30
|
||||
- At-least-once, а не exactly-once: дубли бывают, и это нормально (relay упал после publish, worker упал до ack). Защита — состояние задания в БД, ключ эффекта и жетон lease.
|
||||
- Readiness зависит от S3: пока S3 недоступен, не работает и текстовая часть API (как при отказе PostgreSQL). Это сознательный выбор: без S3 нельзя принять файл в staging, а это обязательный путь. Брокер и worker на readiness не влияют.
|
||||
- После падения worker задание ждёт до 30 с (срок lease), если упал не прежний запуск того же контейнера, а другой worker. Меньший lease быстрее восстанавливает работу, но чаще отбирает задание у медленного worker.
|
||||
- Точки отказа (`faults.py`) включены только на учебном стенде (`FAULTS_ENABLED=1`) и срабатывают по файлу внутри контейнера; в рабочей среде переменной нет.
|
||||
- Точки отказа и точки-паузы (`faults.py`) включены только на учебном стенде (`FAULTS_ENABLED=1`) и срабатывают по файлу внутри контейнера; в рабочей среде переменной нет.
|
||||
- JPEG со схемами субдискретизации, которых не понимает декодер worker (TurboJPEG): например, 4:4:1 или CMYK 4:2:2 — отклоняются 415 как неподдерживаемые, хотя формально корректны. Поддерживаются 4:4:4, 4:2:2, 4:2:0, 4:4:0, 4:1:1 и оттенки серого.
|
||||
- Загрузка держит соединение с БД, пока пишет файл в staging (до 6 с, лимит операции S3). Replay ждёт блокировку вложения до 20 с (её коротко берут уборщик и worker), потом отвечает busy.
|
||||
- Остатки неудачной попытки failed-вложения (оригинал и варианты в S3) лежат до конца retention (24 ч): раньше их удалять нельзя, иначе replay может потерять только что записанные объекты.
|
||||
- Цветовой профиль ICC в варианты не переносится. Анимированные PNG обрабатываются по первому кадру. JPEG с данными после маркера конца принимается (так устроены многие фото с телефона), варианты из него делаются заново.
|
||||
- Вложения lab4 (ready без вариантов) остаются ready, их варианты — 404. Переобработка старых вложений новой версией pipeline — это трек 2 на «5».
|
||||
- Пользователь RabbitMQ один на API и worker (права только на `attachments*`). Отдельные пользователи и mTLS — lab7.
|
||||
- Пользователь RabbitMQ один на API и worker (права только на `attachments*`). Отдельные пользователи и mTLS — lab7.
|
||||
@@ -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)
|
||||
|
||||
@@ -0,0 +1,14 @@
|
||||
python student-tests/cleanup_race.py
|
||||
A. failed b2299717-daa4-4704-afd1-19efe898e821 (retention expired); the janitor read the references and stopped
|
||||
operator replay while the janitor waits -> {'result': 'queued', 'attempt': 2, 'previous_error': 'retry_exhausted'}
|
||||
janitor continued: deleted 0, re-checked under the lock -> kept {'current_work': 1}; staging/b2299717... is still in S3
|
||||
B. failed 6c7228dc-9d9f-4b3c-9f3d-aa6692124418 (retention expired); the janitor holds the lock: staging marked deleted, no COMMIT yet
|
||||
replay waited 8.0 s for the lock -> refused (source_missing); job stays failed; journal: staging_expired -> replay_refused
|
||||
A: worker started -> ready with ['thumbnail', 'crop', 'optimized'] (before the fix: failed / source_missing)
|
||||
C. upload e0578869-000a-4a70-b43b-ab12f6d5ff49: staging written, no row in the database yet (API paused before COMMIT)
|
||||
janitor (grace 0): skipped_busy 1, deleted 0 — the upload holds the attachment lock
|
||||
upload -> 202, then ready with 3 variants
|
||||
D. d4abfa4b-af5e-4208-8d4e-f69a1783891b: worker wrote the original and 3 variants, COMMIT not yet (status processing)
|
||||
janitor (grace 0): the snapshot marked the original and 3 variants as unreferenced; re-checked under the lock -> kept {'current_work': 4}, deleted 0
|
||||
worker committed -> ready; the original and all variants download with the same SHA-256
|
||||
PASS: the janitor re-checks the state under the attachment lock before deleting: a replay accepted after its snapshot keeps the staging (A), a replay after the janitor's decision is refused safely (B), an upload in progress (C) and objects of a job in processing (D) are not deleted
|
||||
+10
-10
@@ -1,13 +1,13 @@
|
||||
python student-tests/concurrency.py
|
||||
time s | processing (DB) | unacked (broker) | waiting in queue
|
||||
2.5 | 2 | 0 | 0
|
||||
7.1 | 2 | 2 | 4
|
||||
10.4 | 2 | 2 | 2
|
||||
13.4 | 2 | 2 | 2
|
||||
16.1 | 2 | 2 | 2
|
||||
20.5 | 2 | 2 | 0
|
||||
23.3 | 2 | 2 | 0
|
||||
26.5 | 2 | 2 | 0
|
||||
29.4 | 0 | 0 | 0
|
||||
peak: 2 jobs in processing, 2 unacknowledged messages, up to 4 waiting in the queue; all 6 ready after 29.4 s
|
||||
2.4 | 2 | 0 | 0
|
||||
5.0 | 2 | 2 | 4
|
||||
7.6 | 2 | 2 | 4
|
||||
11.6 | 2 | 2 | 4
|
||||
14.3 | 2 | 2 | 2
|
||||
17.1 | 2 | 2 | 2
|
||||
19.7 | 2 | 2 | 0
|
||||
23.8 | 2 | 2 | 0
|
||||
26.5 | 0 | 2 | 0
|
||||
peak: 2 jobs in processing, 2 unacknowledged messages, up to 4 waiting in the queue; all 6 ready after 26.5 s
|
||||
PASS: at most WORKER_CONCURRENCY=2 jobs run at once and the broker gives the worker at most prefetch=2 messages; the rest wait in the durable queue
|
||||
|
||||
+30
-12
@@ -2,8 +2,26 @@ docker compose --profile tools run --rm db-test
|
||||
Container mtusi-lab5-postgres-1 Running
|
||||
Container mtusi-lab5-postgres-1 Waiting
|
||||
Container mtusi-lab5-postgres-1 Healthy
|
||||
Container mtusi-lab5-db-test-run-436c3e33e3cf Creating
|
||||
Container mtusi-lab5-db-test-run-436c3e33e3cf Created
|
||||
Container mtusi-lab5-db-test-run-dcea39c16e25 Creating
|
||||
Container mtusi-lab5-db-test-run-dcea39c16e25 Created
|
||||
test_1_replay_after_snapshot_keeps_staging (test_cleanup.CleanupRaceTest.test_1_replay_after_snapshot_keeps_staging) ...
|
||||
snapshot -> replay (queued) -> cleanup: kept [('staging/224e34a0-91da-415f-acc4-ecc686b36842', 'current_work')], nothing deleted
|
||||
ok
|
||||
test_2_cleanup_first_then_replay_waits_and_refuses (test_cleanup.CleanupRaceTest.test_2_cleanup_first_then_replay_waits_and_refuses) ...
|
||||
cleanup marked the staging deleted, holds the lock -> replay waited 1 s+ -> refused (source_missing); job stays failed; journal: staging_expired, replay_refused
|
||||
ok
|
||||
test_3_replay_first_then_cleanup_waits_and_keeps (test_cleanup.CleanupRaceTest.test_3_replay_first_then_cleanup_waits_and_keeps) ... ok
|
||||
test_4_upload_in_progress_is_skipped (test_cleanup.CleanupRaceTest.test_4_upload_in_progress_is_skipped)
|
||||
replay holds the lock -> cleanup waited -> kept [('staging/34b4b519-0cbc-4edb-baab-e86b337fdf38', 'current_work')]
|
||||
...
|
||||
upload between PUT and COMMIT -> cleanup skipped it (busy); after COMMIT -> current work, kept
|
||||
ok
|
||||
test_5_objects_of_processing_job_are_kept (test_cleanup.CleanupRaceTest.test_5_objects_of_processing_job_are_kept) ... ok
|
||||
test_6_regular_cleanup_still_works (test_cleanup.CleanupRaceTest.test_6_regular_cleanup_still_works) ...
|
||||
processing job (worker writes the original and variants before COMMIT) -> all 3 objects kept
|
||||
|
||||
orphan, staging after ready, objects of a failed attachment after retention -> deleted; published original and variants, a failed attachment within retention -> kept; dry-run deletes nothing
|
||||
ok
|
||||
test_backoff_bounds (test_jobs.JobsIntegrationTest.test_backoff_bounds) ... ok
|
||||
test_claim_once_and_concurrent_claims (test_jobs.JobsIntegrationTest.test_claim_once_and_concurrent_claims) ...
|
||||
10 concurrent claims of one job: 1 claimed, 9 in_progress
|
||||
@@ -15,29 +33,29 @@ test_permanent_error_fails_at_once (test_jobs.JobsIntegrationTest.test_permanent
|
||||
test_replay_rules (test_jobs.JobsIntegrationTest.test_replay_rules) ... ok
|
||||
test_retry_backoff_then_exhausted (test_jobs.JobsIntegrationTest.test_retry_backoff_then_exhausted) ... ok
|
||||
test_upload_creates_job_and_outbox_in_one_transaction (test_jobs.JobsIntegrationTest.test_upload_creates_job_and_outbox_in_one_transaction) ... ok
|
||||
test_concurrent_registration_has_one_winner (test_store.StoreIntegrationTest.test_concurrent_registration_has_one_winner) ... ok
|
||||
test_concurrent_same_idempotency_key_creates_one_row (test_store.StoreIntegrationTest.test_concurrent_same_idempotency_key_creates_one_row) ...
|
||||
test_concurrent_registration_has_one_winner (test_store.StoreIntegrationTest.test_concurrent_registration_has_one_winner) ...
|
||||
20 параллельных create_user: 1 создан, 19 получили Conflict (409)
|
||||
ok
|
||||
test_create_chat_rolls_back_when_failing_midway (test_store.StoreIntegrationTest.test_create_chat_rolls_back_when_failing_midway) ...
|
||||
test_concurrent_same_idempotency_key_creates_one_row (test_store.StoreIntegrationTest.test_concurrent_same_idempotency_key_creates_one_row) ...
|
||||
20 одновременных add_message с одним ключом: 1 строка, 1 новое + 19 повторов с тем же сообщением
|
||||
|
||||
ok
|
||||
test_create_chat_rolls_back_when_failing_midway (test_store.StoreIntegrationTest.test_create_chat_rolls_back_when_failing_midway) ... ok
|
||||
test_database_rejects_message_from_non_member (test_store.StoreIntegrationTest.test_database_rejects_message_from_non_member) ...
|
||||
чат с несуществующим участником: транзакция откатилась, строк chats/chat_members не осталось
|
||||
ok
|
||||
test_database_rejects_message_from_non_member (test_store.StoreIntegrationTest.test_database_rejects_message_from_non_member) ...
|
||||
|
||||
INSERT сообщения от не-участника напрямую в БД: ForeignKeyViolation
|
||||
ok
|
||||
test_migrations_rerun_is_noop (test_store.StoreIntegrationTest.test_migrations_rerun_is_noop) ...
|
||||
test_migrations_rerun_is_noop (test_store.StoreIntegrationTest.test_migrations_rerun_is_noop) ... ok
|
||||
test_old_version_insert_without_key_still_works (test_store.StoreIntegrationTest.test_old_version_insert_without_key_still_works) ...
|
||||
schema_migrations: ['001_core', '002_sessions', '003_text_as_bytes', '004_message_idempotency', '005_attachments', '006_jobs']; повторный migrate() ничего не применил
|
||||
ok
|
||||
test_old_version_insert_without_key_still_works (test_store.StoreIntegrationTest.test_old_version_insert_without_key_still_works) ...
|
||||
|
||||
INSERT как в lab2 (без ключа) после миграции 004 работает: старая версия совместима со схемой
|
||||
ok
|
||||
test_same_key_other_body_is_conflict (test_store.StoreIntegrationTest.test_same_key_other_body_is_conflict) ...
|
||||
тот же ключ с другим телом: Conflict (409), в базе по-прежнему одна строка
|
||||
ok
|
||||
|
||||
----------------------------------------------------------------------
|
||||
Ran 16 tests in 0.624s
|
||||
Ran 22 tests in 2.833s
|
||||
|
||||
OK
|
||||
|
||||
+47
-47
@@ -1,64 +1,64 @@
|
||||
python student-tests/run_failover.py
|
||||
hook: scripts/stop-one.cmd; api replicas: ['b0db3e40abfe', 'ef44b0d4c0a1']
|
||||
hook: scripts/stop-one.cmd; api replicas: ['48dc392933dc', 'c1b7e1ab5673']
|
||||
|
||||
=== run 1: containers before (HAProxy: api1 UP, api2 UP)
|
||||
SERVICE CONTAINER STATE STARTED AT (UTC)
|
||||
api b0db3e40abfe running (healthy) 2026-10-25T18:28:33.999
|
||||
api ef44b0d4c0a1 running (healthy) 2026-10-25T18:23:36.756
|
||||
broker 9f909ed7ecea running (healthy) 2026-10-25T18:23:53.670
|
||||
lb 8be67a2e86b7 running (healthy) 2026-10-25T18:20:04.043
|
||||
migrate e6c2c825d38d exited 2026-10-25T18:28:07.167
|
||||
postgres d2bfd48385f1 running (healthy) 2026-10-25T18:19:54.204
|
||||
s3 892c7ca290f2 running (healthy) 2026-10-25T18:29:00.995
|
||||
s3-init 08c2e7925d67 exited 2026-10-25T18:28:07.169
|
||||
valkey 4e223cb9301e running (healthy) 2026-10-25T18:19:54.202
|
||||
worker d9eced386d93 running (healthy) 2026-10-25T18:28:09.870
|
||||
api 48dc392933dc running (healthy) 2026-10-26T16:24:32.726
|
||||
api c1b7e1ab5673 running (healthy) 2026-10-26T16:18:45.657
|
||||
broker 9f909ed7ecea running (healthy) 2026-10-26T16:19:00.163
|
||||
lb 8be67a2e86b7 running (healthy) 2026-10-26T16:15:42.154
|
||||
migrate a5a9934b4d6b exited 2026-10-26T16:23:38.842
|
||||
postgres d2bfd48385f1 running (healthy) 2026-10-26T16:15:17.840
|
||||
s3 892c7ca290f2 running (healthy) 2026-10-26T16:24:57.683
|
||||
s3-init deab1aa2b022 exited 2026-10-26T16:23:38.843
|
||||
valkey 4e223cb9301e running (healthy) 2026-10-26T16:15:17.820
|
||||
worker 292a36c54a41 running (healthy) 2026-10-26T16:23:41.416
|
||||
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.␍
|
||||
{"observed_instances_before": 2, "successful_writes": 119, "failed_attempts": 0, "first_recovery_seconds": 5.11}␍
|
||||
{"observed_instances_before": 2, "successful_writes": 124, "failed_attempts": 0, "first_recovery_seconds": 4.531}␍
|
||||
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
containers after (HAProxy: api1 UP)
|
||||
SERVICE CONTAINER STATE STARTED AT (UTC)
|
||||
api b0db3e40abfe running (healthy) 2026-10-25T18:28:33.999
|
||||
api ef44b0d4c0a1 exited 2026-10-25T18:23:36.756
|
||||
broker 9f909ed7ecea running (healthy) 2026-10-25T18:23:53.670
|
||||
lb 8be67a2e86b7 running (healthy) 2026-10-25T18:20:04.043
|
||||
migrate e6c2c825d38d exited 2026-10-25T18:28:07.167
|
||||
postgres d2bfd48385f1 running (healthy) 2026-10-25T18:19:54.204
|
||||
s3 892c7ca290f2 running (healthy) 2026-10-25T18:29:00.995
|
||||
s3-init 08c2e7925d67 exited 2026-10-25T18:28:07.169
|
||||
valkey 4e223cb9301e running (healthy) 2026-10-25T18:19:54.202
|
||||
worker d9eced386d93 running (healthy) 2026-10-25T18:28:09.870
|
||||
the hook stopped ef44b0d4c0a1 (X-Instance-Id of that replica = container ID); other api containers, postgres, valkey, s3 and lb kept running
|
||||
restored: docker start ef44b0d4c0a1 -> healthy and back in HAProxy (api1 UP, api2 UP)
|
||||
api 48dc392933dc exited 2026-10-26T16:24:32.726
|
||||
api c1b7e1ab5673 running (healthy) 2026-10-26T16:18:45.657
|
||||
broker 9f909ed7ecea running (healthy) 2026-10-26T16:19:00.163
|
||||
lb 8be67a2e86b7 running (healthy) 2026-10-26T16:15:42.154
|
||||
migrate a5a9934b4d6b exited 2026-10-26T16:23:38.842
|
||||
postgres d2bfd48385f1 running (healthy) 2026-10-26T16:15:17.840
|
||||
s3 892c7ca290f2 running (healthy) 2026-10-26T16:24:57.683
|
||||
s3-init deab1aa2b022 exited 2026-10-26T16:23:38.843
|
||||
valkey 4e223cb9301e running (healthy) 2026-10-26T16:15:17.820
|
||||
worker 292a36c54a41 running (healthy) 2026-10-26T16:23:41.416
|
||||
the hook stopped 48dc392933dc (X-Instance-Id of that replica = container ID); other api containers, postgres, valkey, s3 and lb kept running
|
||||
restored: docker start 48dc392933dc -> healthy and back in HAProxy (api1 UP, api2 UP)
|
||||
|
||||
=== run 2: containers before (HAProxy: api1 UP, api2 UP)
|
||||
SERVICE CONTAINER STATE STARTED AT (UTC)
|
||||
api b0db3e40abfe running (healthy) 2026-10-25T18:28:33.999
|
||||
api ef44b0d4c0a1 running (healthy) 2026-10-25T18:30:14.430
|
||||
broker 9f909ed7ecea running (healthy) 2026-10-25T18:23:53.670
|
||||
lb 8be67a2e86b7 running (healthy) 2026-10-25T18:20:04.043
|
||||
migrate e6c2c825d38d exited 2026-10-25T18:28:07.167
|
||||
postgres d2bfd48385f1 running (healthy) 2026-10-25T18:19:54.204
|
||||
s3 892c7ca290f2 running (healthy) 2026-10-25T18:29:00.995
|
||||
s3-init 08c2e7925d67 exited 2026-10-25T18:28:07.169
|
||||
valkey 4e223cb9301e running (healthy) 2026-10-25T18:19:54.202
|
||||
worker d9eced386d93 running (healthy) 2026-10-25T18:28:09.870
|
||||
api 48dc392933dc running (healthy) 2026-10-26T16:25:57.020
|
||||
api c1b7e1ab5673 running (healthy) 2026-10-26T16:18:45.657
|
||||
broker 9f909ed7ecea running (healthy) 2026-10-26T16:19:00.163
|
||||
lb 8be67a2e86b7 running (healthy) 2026-10-26T16:15:42.154
|
||||
migrate a5a9934b4d6b exited 2026-10-26T16:23:38.842
|
||||
postgres d2bfd48385f1 running (healthy) 2026-10-26T16:15:17.840
|
||||
s3 892c7ca290f2 running (healthy) 2026-10-26T16:24:57.683
|
||||
s3-init deab1aa2b022 exited 2026-10-26T16:23:38.843
|
||||
valkey 4e223cb9301e running (healthy) 2026-10-26T16:15:17.820
|
||||
worker 292a36c54a41 running (healthy) 2026-10-26T16:23:41.416
|
||||
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.␍
|
||||
{"observed_instances_before": 2, "successful_writes": 125, "failed_attempts": 0, "first_recovery_seconds": 5.531}␍
|
||||
{"observed_instances_before": 2, "successful_writes": 124, "failed_attempts": 0, "first_recovery_seconds": 4.594}␍
|
||||
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
containers after (HAProxy: api2 UP)
|
||||
SERVICE CONTAINER STATE STARTED AT (UTC)
|
||||
api b0db3e40abfe exited 2026-10-25T18:28:33.999
|
||||
api ef44b0d4c0a1 running (healthy) 2026-10-25T18:30:14.430
|
||||
broker 9f909ed7ecea running (healthy) 2026-10-25T18:23:53.670
|
||||
lb 8be67a2e86b7 running (healthy) 2026-10-25T18:20:04.043
|
||||
migrate e6c2c825d38d exited 2026-10-25T18:28:07.167
|
||||
postgres d2bfd48385f1 running (healthy) 2026-10-25T18:19:54.204
|
||||
s3 892c7ca290f2 running (healthy) 2026-10-25T18:29:00.995
|
||||
s3-init 08c2e7925d67 exited 2026-10-25T18:28:07.169
|
||||
valkey 4e223cb9301e running (healthy) 2026-10-25T18:19:54.202
|
||||
worker d9eced386d93 running (healthy) 2026-10-25T18:28:09.870
|
||||
the hook stopped b0db3e40abfe (X-Instance-Id of that replica = container ID); other api containers, postgres, valkey, s3 and lb kept running
|
||||
restored: docker start b0db3e40abfe -> healthy and back in HAProxy (api1 UP, api2 UP)
|
||||
api 48dc392933dc running (healthy) 2026-10-26T16:25:57.020
|
||||
api c1b7e1ab5673 exited 2026-10-26T16:18:45.657
|
||||
broker 9f909ed7ecea running (healthy) 2026-10-26T16:19:00.163
|
||||
lb 8be67a2e86b7 running (healthy) 2026-10-26T16:15:42.154
|
||||
migrate a5a9934b4d6b exited 2026-10-26T16:23:38.842
|
||||
postgres d2bfd48385f1 running (healthy) 2026-10-26T16:15:17.840
|
||||
s3 892c7ca290f2 running (healthy) 2026-10-26T16:24:57.683
|
||||
s3-init deab1aa2b022 exited 2026-10-26T16:23:38.843
|
||||
valkey 4e223cb9301e running (healthy) 2026-10-26T16:15:17.820
|
||||
worker 292a36c54a41 running (healthy) 2026-10-26T16:23:41.416
|
||||
the hook stopped c1b7e1ab5673 (X-Instance-Id of that replica = container ID); other api containers, postgres, valkey, s3 and lb kept running
|
||||
restored: docker start c1b7e1ab5673 -> healthy and back in HAProxy (api1 UP, api2 UP)
|
||||
|
||||
PASS: public failover test passed 2 times; every api replica was stopped once and restored
|
||||
|
||||
+29
-29
@@ -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
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
docker compose --profile tools run --rm imaging-test
|
||||
Container mtusi-lab5-imaging-test-run-522cead2dfe0 Creating
|
||||
Container mtusi-lab5-imaging-test-run-522cead2dfe0 Created
|
||||
Container mtusi-lab5-imaging-test-run-7b65aee97073 Creating
|
||||
Container mtusi-lab5-imaging-test-run-7b65aee97073 Created
|
||||
test_alpha_is_white_in_jpeg_and_kept_in_webp (test_imaging.ImagingTest.test_alpha_is_white_in_jpeg_and_kept_in_webp) ... ok
|
||||
test_broken_jpeg_scan_is_invalid (test_imaging.ImagingTest.test_broken_jpeg_scan_is_invalid) ... ok
|
||||
test_exif_orientation_is_applied (test_imaging.ImagingTest.test_exif_orientation_is_applied) ...
|
||||
@@ -10,14 +10,20 @@ test_fixture_variants (test_imaging.ImagingTest.test_fixture_variants) ...
|
||||
fixture 320×200 -> thumbnail JPEG 256×160, crop JPEG 128×128, optimized WebP 320×200
|
||||
ok
|
||||
test_geometry (test_imaging.ImagingTest.test_geometry) ... ok
|
||||
test_jpeg_header_check_matches_strict_decoder (test_imaging.ImagingTest.test_jpeg_header_check_matches_strict_decoder) ...
|
||||
800 random header mutations: {'both accept': 318, 'both reject': 427, 'accepted, entropy error in worker': 55}
|
||||
ok
|
||||
test_limits_in_child_process (test_imaging.ImagingTest.test_limits_in_child_process) ...
|
||||
36 Mpx RGBA in a child process: ok in 3.78 s with 640 MiB; MemoryError -> image_too_large with 200 MiB; timeout 0.2 s -> killed after 0.21 s; 1000 px limit -> image_too_large
|
||||
36 Mpx RGBA in a child process: ok in 3.93 s with 640 MiB; MemoryError -> image_too_large with 200 MiB; timeout 0.2 s -> killed after 0.21 s; 1000 px limit -> image_too_large
|
||||
ok
|
||||
test_metadata_is_stripped (test_imaging.ImagingTest.test_metadata_is_stripped) ... ok
|
||||
test_modes (test_imaging.ImagingTest.test_modes) ... ok
|
||||
test_same_input_same_bytes (test_imaging.ImagingTest.test_same_input_same_bytes) ... ok
|
||||
test_subsampling_rule_matches_turbojpeg (test_imaging.ImagingTest.test_subsampling_rule_matches_turbojpeg) ...
|
||||
8208 sampling-factor combinations: API and TurboJPEG agree on every one
|
||||
ok
|
||||
|
||||
----------------------------------------------------------------------
|
||||
Ran 9 tests in 5.420s
|
||||
Ran 11 tests in 6.036s
|
||||
|
||||
OK
|
||||
|
||||
+5
-5
@@ -1,9 +1,9 @@
|
||||
python student-tests/lease_takeover.py
|
||||
1. long job (35 s > lease 30 s) on d9eced386d93/507dfab2: lease_until moved forward 2 times: 18:26:08 -> 18:26:10 -> 18:26:20
|
||||
2. worker B 3b645a26424d started (the job is still held by A's lease)
|
||||
worker A d9eced386d93 frozen (docker pause): no more renewals
|
||||
lease expired -> attempt 2 -> ready 31 s after the freeze; result committed by worker-3b645a26424d/a5b5d050
|
||||
1. long job (35 s > lease 30 s) on 292a36c54a41/4b7735c2: lease_until moved forward 2 times: 16:21:03 -> 16:21:13 -> 16:21:23
|
||||
2. worker B fa1bafe61888 started (the job is still held by A's lease)
|
||||
worker A 292a36c54a41 frozen (docker pause): no more renewals
|
||||
lease expired -> attempt 2 -> ready 33 s after the freeze; result committed by worker-fa1bafe61888/279ac631
|
||||
events: queued(1) -> claimed(1) -> lease_expired(1) -> retry_scheduled(1) -> claimed(2) -> ready(2)
|
||||
3. worker A unpaused: Задание cd53da75-5133-44f3-a33f-038d4dbfd6ca: lease забрал другой worker — работа брошена
|
||||
3. worker A unpaused: Задание d08bfc08-1460-4633-bbfd-6b3f69088ca3: lease забрал другой worker — работа брошена
|
||||
still exactly one result: status ready, attempt 2, 3 variant rows, metadata unchanged
|
||||
PASS: a running worker keeps its lease by renewing it; a frozen one loses it, the job moves to another worker, and the stale worker cannot overwrite the result (fencing token)
|
||||
|
||||
+12
-12
@@ -1,19 +1,19 @@
|
||||
python student-tests/outbox_crash.py
|
||||
A. api_after_commit: the client got 502 instead of 202, but the attachment 44f59913-f920-4d36-82d5-fea3d61ce5b7 and its outbox row were committed before the crash
|
||||
ready without creating a new job by hand; api restarted by Docker: ['ef44b0d4c0a1']
|
||||
outbox: row 41 published 2026-10-25T18:23:23.278264+00:00 by relay-b0db3e40abfe
|
||||
A. api_after_commit: the client got 502 instead of 202, but the attachment 68ccecb0-ae64-4a1d-a235-63219f66c403 and its outbox row were committed before the crash
|
||||
ready without creating a new job by hand; api restarted by Docker: ['48dc392933dc']
|
||||
outbox: row 130 published 2026-10-26T16:18:31.010950+00:00 by relay-c1b7e1ab5673
|
||||
events: queued -> claimed -> ready
|
||||
B. relay_before_publish: upload -> 202 (0d6338d9-fa65-459d-9d54-53cc385700d4); every relay that takes the row crashes before publishing
|
||||
crashed and restarted: ['b0db3e40abfe', 'ef44b0d4c0a1']; after restart the row was published once -> ready
|
||||
outbox: row 42 published 2026-10-25T18:23:32.331225+00:00 by relay-ef44b0d4c0a1
|
||||
B. relay_before_publish: upload -> 202 (780f7bd8-df89-4c70-84fa-9d90f35879fa); every relay that takes the row crashes before publishing
|
||||
crashed and restarted: ['48dc392933dc', 'c1b7e1ab5673']; after restart the row was published once -> ready
|
||||
outbox: row 131 published 2026-10-26T16:18:40.873234+00:00 by relay-48dc392933dc
|
||||
events: queued -> claimed -> ready
|
||||
C. relay_after_publish: upload -> 202 (cf7c7e33-78ee-48c1-9bc5-7acefbf49d40); the broker confirms, the relay crashes before marking the row
|
||||
crashed and restarted: ['b0db3e40abfe', 'ef44b0d4c0a1']; the same message was delivered again 1 time(s): duplicate_ignored
|
||||
outbox: row 43 published 2026-10-25T18:23:40.297286+00:00 by relay-ef44b0d4c0a1
|
||||
C. relay_after_publish: upload -> 202 (87559a9a-a61c-4a10-999c-516b5e1f481a); the broker confirms, the relay crashes before marking the row
|
||||
crashed and restarted: ['48dc392933dc', 'c1b7e1ab5673']; the same message was delivered again 1 time(s): duplicate_ignored
|
||||
outbox: row 132 published 2026-10-26T16:18:48.678466+00:00 by relay-48dc392933dc
|
||||
events: queued -> claimed -> ready -> duplicate_ignored
|
||||
still one set of variants: 3 rows, 3 objects
|
||||
D. broker stopped: upload -> 202 (094e50ca-898e-4c19-9d39-1b80721409ab), after 5 s status queued, outbox row 44 not published yet (it waits in PostgreSQL)
|
||||
broker started: the relay published the row, ready 6.4 s later
|
||||
outbox: row 44 published 2026-10-25T18:24:08.645165+00:00 by relay-ef44b0d4c0a1
|
||||
D. broker stopped: upload -> 202 (87e3efc2-e44b-4260-8129-7fadffec4811), after 5 s status queued, outbox row 133 not published yet (it waits in PostgreSQL)
|
||||
broker started: the relay published the row, ready 11.8 s later
|
||||
outbox: row 133 published 2026-10-26T16:19:07.785521+00:00 by relay-48dc392933dc
|
||||
events: queued -> claimed -> ready
|
||||
PASS: a crash between COMMIT and publish (A, B) loses nothing — the outbox row is published later and the job becomes ready without manual action; a crash after publish (C) only causes a duplicate delivery, which the worker acknowledges without a second set of variants; while the broker is down (D) uploads are still accepted and the jobs wait in the outbox
|
||||
|
||||
+29
-29
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -13,11 +13,11 @@ SeaweedFS admin/UI port 8888 inside the network: closed
|
||||
SeaweedFS admin/UI port 8080 inside the network: closed
|
||||
host 127.0.0.1:9000, :9333, :8888: closed (S3 is not published)
|
||||
attachments columns: id:uuid, chat_id:uuid, owner_id:uuid, filename:text, content_type:text, size_bytes:bigint, sha256:text, width:integer, height:integer, storage_key:text, status:text, created_at:timestamp with time zone, updated_at:timestamp with time zone, error_code:text, staging_key:text
|
||||
api b0db3e40abfe: files with the same SHA-256 on disk: 0
|
||||
api ef44b0d4c0a1: files with the same SHA-256 on disk: 0
|
||||
worker d9eced386d93: files with the same SHA-256 on disk: 0
|
||||
api 48dc392933dc: files with the same SHA-256 on disk: 0
|
||||
api c1b7e1ab5673: files with the same SHA-256 on disk: 0
|
||||
worker 292a36c54a41: files with the same SHA-256 on disk: 0
|
||||
broker message (243 bytes): ['attachment_id', 'attempt', 'created_at', 'job_id', 'pipeline_version', 'schema_version', 'type'] — only IDs and service fields
|
||||
s3-init run 1: exit 0: s3-init: bucket messenger-attachments already exists; anonymous access: 403 (private)
|
||||
s3-init run 2: exit 0: s3-init: bucket messenger-attachments already exists; anonymous access: 403 (private)
|
||||
objects in bucket before/after bootstrap: 164/164; the file still downloads
|
||||
objects in bucket before/after bootstrap: 360/360; the file still downloads
|
||||
PASS: bucket is private outside the API, the API S3 user has least privilege, the console is closed, bytes are only in S3, bucket bootstrap is idempotent
|
||||
|
||||
+16
-16
@@ -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: Миграции: новых нет, схема актуальна
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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, второе сообщение не создано
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -17,6 +17,8 @@
|
||||
Картинка НЕ декодируется и не уменьшается — это работа worker;
|
||||
3. PUT оригинала в staging/<id> (ключ назначает сервер);
|
||||
4. COMMIT: вложение + задание + outbox -> 202. После ответа будится relay этого же процесса.
|
||||
Шаги 3–4 — одна транзакция под блокировкой ID вложения (store.receiving): пока она идёт,
|
||||
уборщик этот staging не трогает (замечание к MR: уборка не должна удалять текущую работу).
|
||||
|
||||
Сбои:
|
||||
- S3 недоступен на шаге 3 -> 503, в БД ничего нет; объект мог успеть записаться — тогда это
|
||||
@@ -94,11 +96,15 @@ def accept(store: PostgresStore, user_id: str, chat_id: str, filename: str,
|
||||
info = images.inspect(spool, declared)
|
||||
attachment_id = str(uuid.uuid4())
|
||||
staging = objects.staging_key(attachment_id)
|
||||
objects.put(staging, spool, size, info.content_type, sha256) # сбой -> 503, строки в БД нет
|
||||
attachment = store.create_queued_attachment(
|
||||
attachment_id, user_id, chat_id, filename, info.content_type, size, sha256, info.width, info.height,
|
||||
staging_key=staging, storage_key=objects.original_key(attachment_id),
|
||||
actor="api-" + config.INSTANCE_ID)
|
||||
# Одна транзакция от PUT до COMMIT под блокировкой ID вложения (store.receiving): уборщик
|
||||
# не тронет staging, пока загрузка не закончилась, даже если строки в БД ещё нет.
|
||||
with store.receiving(attachment_id) as conn:
|
||||
objects.put(staging, spool, size, info.content_type, sha256) # сбой -> 503, транзакция откатывается
|
||||
faults.pause("api_pause_after_staging") # проверка окна «staging записан, строки ещё нет»
|
||||
attachment = store.create_queued_attachment(
|
||||
attachment_id, user_id, chat_id, filename, info.content_type, size, sha256, info.width, info.height,
|
||||
staging_key=staging, storage_key=objects.original_key(attachment_id),
|
||||
actor="api-" + config.INSTANCE_ID, conn=conn)
|
||||
faults.hit("api_after_commit") # проверка окна «COMMIT прошёл, до отправки в брокер» (faults.py)
|
||||
log.info("Вложение %s принято: %d байт, %s, задание в outbox", attachment_id, size, info.content_type)
|
||||
return attachment
|
||||
|
||||
+68
-31
@@ -4,26 +4,42 @@
|
||||
обработки больше не нужен. Уборщик сверяет содержимое bucket с базой и удаляет то, на что
|
||||
база не ссылается.
|
||||
|
||||
Что нужно и не удаляется (PostgresStore.storage_references):
|
||||
Что нужно и не удаляется:
|
||||
- оригинал ready-вложения (originals/<id>) и все его варианты (variants/<id>/...);
|
||||
- staging-оригинал задания в работе (queued, processing);
|
||||
- staging-оригинал failed-вложения, пока не прошёл STAGING_RETENTION_SECONDS (24 ч):
|
||||
оператор может сделать replay.
|
||||
Всё остальное удаляется, но только если объекту больше grace period (ATTACHMENT_GRACE_SECONDS,
|
||||
15 мин): так уборщик не заденет загрузку или обработку, которая идёт прямо сейчас (они длятся
|
||||
секунды, лимит попытки — 60 с). Под удаление попадают:
|
||||
- ВСЕ объекты вложения в работе (queued, processing): staging читает worker, а оригинал и
|
||||
варианты он, возможно, пишет прямо сейчас, до COMMIT результата;
|
||||
- все объекты failed-вложения, пока не прошёл STAGING_RETENTION_SECONDS (24 ч): оператор может
|
||||
сделать replay, и worker запишет оригинал и варианты заново в те же ключи;
|
||||
- staging загрузки, которая ещё идёт (PUT уже был, COMMIT строки вложения — ещё нет).
|
||||
Под удаление попадают объекты старше grace period (ATTACHMENT_GRACE_SECONDS, 15 мин):
|
||||
- staging уже готового вложения (worker удаляет его сам сразу после COMMIT, сюда попадает,
|
||||
только если тогда не получилось);
|
||||
- staging failed-вложения старше retention;
|
||||
- «сироты»: объекты без строки в БД (API упал между PUT в staging и COMMIT, или worker записал
|
||||
варианты, а задание потом ушло в failed).
|
||||
Готовые вложения без объекта (missing) только считаются и пишутся в лог: решает человек.
|
||||
Повторный и одновременный запуск безопасен: удаление идемпотентно.
|
||||
- объекты failed-вложения после retention (сначала staging помечается удалённым в БД);
|
||||
- «сироты»: объекты без строки в БД (API упал между PUT в staging и COMMIT).
|
||||
|
||||
Запуск вручную (внутри контейнера worker):
|
||||
Как уборщик не удаляет текущую работу (замечание к MR). Прежняя версия читала ссылки из БД
|
||||
один раз и удаляла по этому снимку: если между чтением и удалением оператор делал replay,
|
||||
staging уже queued-задания удалялся, и worker получал source_missing. Теперь:
|
||||
1. список объектов и снимок ссылок из БД только отбирают кандидатов (заведомо нужное не трогаем);
|
||||
2. по каждому вложению-кандидату решение принимается заново, в короткой транзакции под
|
||||
блокировками (PostgresStore.cleanup_attachment): advisory-блокировка ID вложения (её держит
|
||||
идущая загрузка), затем строки задания и вложения (их меняют worker и replay). Пока блокировки
|
||||
у уборщика, состояние не может поменяться;
|
||||
3. у failed-вложения после retention сначала в БД помечается, что исходника нет
|
||||
(staging_key = NULL, запись в журнале), и только после COMMIT объекты удаляются из S3:
|
||||
replay, ждавший блокировку или пришедший позже, видит это и безопасно отказывает;
|
||||
4. из S3 удаляется только то, что после COMMIT уже не может понадобиться никогда (сирота без
|
||||
загрузки, staging готового, объекты failed без исходника). Поэтому медленный S3 не держит
|
||||
блокировки, а оборванная сессия БД не открывает окно для гонки.
|
||||
Готовые вложения без объекта (missing) только считаются и пишутся в лог: решает человек.
|
||||
Повторный и одновременный запуск безопасен: удаление идемпотентно, вложение обрабатывает
|
||||
только тот, кто взял его блокировку.
|
||||
|
||||
Запуск вручную (внутри контейнера api или worker):
|
||||
python -m messenger.cleanup --dry-run # только показать, ничего не удалять
|
||||
python -m messenger.cleanup # удалить по правилам выше
|
||||
python -m messenger.cleanup --grace-seconds 5 # для теста: меньший grace period
|
||||
python -m messenger.cleanup --attachment <id> # только объекты одного вложения
|
||||
Вывод — одна строка JSON со счётчиками, без ключей доступа.
|
||||
"""
|
||||
import argparse
|
||||
@@ -31,35 +47,54 @@ import json
|
||||
import logging
|
||||
import sys
|
||||
import time
|
||||
import uuid
|
||||
from collections import Counter, defaultdict
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
from . import config, objects
|
||||
from . import config, faults, objects
|
||||
from .errors import AppError
|
||||
from .store import PostgresStore
|
||||
|
||||
log = logging.getLogger("messenger.cleanup")
|
||||
|
||||
|
||||
def run_once(store: PostgresStore, grace_seconds: int, retention_seconds: int, dry_run: bool = False) -> dict:
|
||||
def run_once(store: PostgresStore, grace_seconds: int, retention_seconds: int, dry_run: bool = False,
|
||||
attachment_id: str | None = None) -> dict:
|
||||
started = time.monotonic()
|
||||
# Сначала читаем bucket, потом БД: объект, появившийся между двумя чтениями, — свежий,
|
||||
# он моложе grace и удалён не будет.
|
||||
listed = objects.list_objects("")
|
||||
if attachment_id is None:
|
||||
listed = objects.list_objects("")
|
||||
else:
|
||||
listed = [item for prefix in objects.prefixes_of(attachment_id) for item in objects.list_objects(prefix)]
|
||||
refs = store.storage_references(retention_seconds)
|
||||
needed, done = refs["needed"], refs["done"]
|
||||
faults.pause("cleanup_pause") # проверка гонки: окно между чтением ссылок и удалением
|
||||
border = datetime.now(timezone.utc) - timedelta(seconds=grace_seconds)
|
||||
counts = {"staging_after_ready": 0, "staging_failed_expired": 0, "orphan": 0}
|
||||
deleted = 0
|
||||
candidates = defaultdict(list) # ID вложения -> его объекты, которые МОГУТ быть лишними
|
||||
for key, modified in listed:
|
||||
if key in needed or modified >= border:
|
||||
if key not in refs["needed"] and modified < border:
|
||||
candidates[objects.attachment_of(key)].append(key)
|
||||
counts = {"staging_after_ready": 0, "staging_failed_expired": 0, "orphan": 0}
|
||||
kept, busy, deleted = Counter(), 0, 0
|
||||
for owner, keys in candidates.items():
|
||||
if owner is None:
|
||||
# Ключ не того вида, что пишут API и worker: никакая текущая работа на него не ссылается.
|
||||
counts["orphan"] += len(keys)
|
||||
if not dry_run:
|
||||
for key in keys:
|
||||
objects.delete(key)
|
||||
deleted += len(keys)
|
||||
continue
|
||||
reason = done.get(key, "orphan")
|
||||
counts[reason] += 1
|
||||
outcome = store.cleanup_attachment(owner, keys, retention_seconds, None if dry_run else objects.delete)
|
||||
if outcome is None:
|
||||
busy += len(keys) # идёт загрузка или переход состояния: в следующий раз
|
||||
continue
|
||||
for _key, reason in outcome["delete"]:
|
||||
counts[reason] += 1
|
||||
for _key, why in outcome["keep"]:
|
||||
kept[why] += 1 # снимок говорил «лишний», а текущее состояние — «нужен»
|
||||
if not dry_run:
|
||||
objects.delete(key)
|
||||
deleted += 1
|
||||
deleted += len(outcome["delete"])
|
||||
in_bucket = {key for key, _ in listed}
|
||||
missing = len(refs["ready_originals"] - in_bucket)
|
||||
missing = len(refs["ready_originals"] - in_bucket) if attachment_id is None else 0
|
||||
if missing:
|
||||
log.error("В БД есть %d готовых вложений без оригинала в S3 (нужна ручная проверка)", missing)
|
||||
outbox_deleted = 0 if dry_run else store.delete_old_outbox(config.OUTBOX_RETENTION_SECONDS)
|
||||
@@ -68,9 +103,9 @@ def run_once(store: PostgresStore, grace_seconds: int, retention_seconds: int, d
|
||||
prefix = key.split("/", 1)[0] + "/"
|
||||
by_prefix[prefix] = by_prefix.get(prefix, 0) + 1
|
||||
return {"dry_run": dry_run, "grace_seconds": grace_seconds, "retention_seconds": retention_seconds,
|
||||
"to_delete": counts, "deleted": deleted, "missing_ready_originals": missing,
|
||||
"objects_in_bucket": len(listed), "by_prefix": by_prefix, "outbox_rows_deleted": outbox_deleted,
|
||||
"seconds": round(time.monotonic() - started, 3)}
|
||||
"to_delete": counts, "deleted": deleted, "kept_after_recheck": dict(kept), "skipped_busy": busy,
|
||||
"missing_ready_originals": missing, "objects_in_bucket": len(listed), "by_prefix": by_prefix,
|
||||
"outbox_rows_deleted": outbox_deleted, "seconds": round(time.monotonic() - started, 3)}
|
||||
|
||||
|
||||
def main(argv=None) -> int:
|
||||
@@ -78,6 +113,7 @@ def main(argv=None) -> int:
|
||||
parser.add_argument("--dry-run", action="store_true", help="только посчитать, ничего не удалять")
|
||||
parser.add_argument("--grace-seconds", type=int, default=config.ATTACHMENT_GRACE_SECONDS)
|
||||
parser.add_argument("--retention-seconds", type=int, default=config.STAGING_RETENTION_SECONDS)
|
||||
parser.add_argument("--attachment", type=uuid.UUID, help="только объекты одного вложения")
|
||||
args = parser.parse_args(argv)
|
||||
logging.basicConfig(level=logging.WARNING, format="%(levelname)s %(name)s: %(message)s")
|
||||
config.validate()
|
||||
@@ -86,7 +122,8 @@ def main(argv=None) -> int:
|
||||
pool = db.create_pool(application_name="messenger-cleanup", max_size=2)
|
||||
pool.open()
|
||||
try:
|
||||
print(json.dumps(run_once(PostgresStore(pool), args.grace_seconds, args.retention_seconds, args.dry_run)))
|
||||
print(json.dumps(run_once(PostgresStore(pool), args.grace_seconds, args.retention_seconds, args.dry_run,
|
||||
str(args.attachment) if args.attachment else None)))
|
||||
except AppError as exc:
|
||||
print(json.dumps({"error": exc.message}, ensure_ascii=False))
|
||||
return 1
|
||||
|
||||
+22
-1
@@ -3,7 +3,7 @@
|
||||
Окна отказа из contracts/attachment-states.md нужно не описать, а воспроизвести: процесс должен
|
||||
упасть ровно в нужном месте. Для этого в коде расставлены «точки отказа» hit("имя"). Точка
|
||||
срабатывает, только если:
|
||||
1. переменная FAULTS_ENABLED=1 (в compose.yaml для стенда; в рабочей среде её нет — точки молчат);
|
||||
1. переменная FAULTS_ENABLED=1 (в .env учебного стенда, см. .env.example; в рабочей среде её нет — точки молчат);
|
||||
2. внутри контейнера есть файл /tmp/faults/<имя>. Тест создаёт его через `docker exec`.
|
||||
|
||||
Срабатывание одноразовое: файл удаляется ДО падения, поэтому перезапущенный процесс
|
||||
@@ -19,9 +19,17 @@
|
||||
Ещё два файла не роняют процесс, а меняют поведение (содержимое файла — число):
|
||||
- worker_slow каждая обработка дополнительно «работает» N секунд (долгая задача);
|
||||
- worker_transient следующие N попыток завершаются временной ошибкой (как недоступный S3).
|
||||
Точки-паузы (замечание к MR про уборщика): процесс один раз ждёт N секунд в опасном месте, чтобы
|
||||
тест закрепил порядок событий («барьер») и вклинился в окно между двумя шагами:
|
||||
- cleanup_pause уборщик прочитал ссылки из БД, но ещё ничего не удалял;
|
||||
- cleanup_pause_locked уборщик под блокировкой вложения решил удалить и пометил staging удалённым,
|
||||
COMMIT ещё не сделан (replay в это время ждёт блокировку);
|
||||
- api_pause_after_staging API записал файл в staging, строки вложения в БД ещё нет;
|
||||
- worker_pause_after_objects worker записал оригинал и варианты в S3, COMMIT результата ещё нет.
|
||||
"""
|
||||
import logging
|
||||
import os
|
||||
import time
|
||||
|
||||
log = logging.getLogger("messenger.faults")
|
||||
|
||||
@@ -59,6 +67,19 @@ def number(name: str) -> float:
|
||||
return 0
|
||||
|
||||
|
||||
def pause(name: str) -> None:
|
||||
"""Точка-пауза: если включена, удалить её файл (сработает один раз) и подождать N секунд."""
|
||||
seconds = number(name)
|
||||
if seconds <= 0:
|
||||
return
|
||||
try:
|
||||
os.remove(_path(name))
|
||||
except FileNotFoundError:
|
||||
return
|
||||
log.warning("FAULT %s: пауза %.1f с (внедрённая задержка для проверки гонок)", name, seconds)
|
||||
time.sleep(seconds)
|
||||
|
||||
|
||||
def consume(name: str) -> bool:
|
||||
"""Для worker_transient: уменьшить счётчик на 1. True — эта попытка должна «упасть»."""
|
||||
left = int(number(name))
|
||||
|
||||
+341
-67
@@ -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()
|
||||
|
||||
@@ -96,8 +96,10 @@ def _strict_jpeg_check(data: bytes) -> None:
|
||||
_h, _w, colorspace, _sub = simplejpeg.decode_jpeg_header(data)
|
||||
target = "CMYK" if colorspace in ("CMYK", "YCCK") else ("GRAY" if colorspace == "Gray" else "RGB")
|
||||
simplejpeg.decode_jpeg(data, colorspace=target, strict=True, min_factor=8)
|
||||
except ValueError:
|
||||
raise InvalidImage("JPEG повреждён: libjpeg-turbo в строгом режиме нашёл ошибку") from None
|
||||
except (ValueError, KeyError):
|
||||
# KeyError: simplejpeg не знает некоторых схем субдискретизации TurboJPEG 3 (например, 4:4:1).
|
||||
# API такие JPEG отклоняет сам (images._subsampling_supported), здесь — вторая линия защиты.
|
||||
raise InvalidImage("JPEG повреждён или не поддерживается: libjpeg-turbo в строгом режиме нашёл ошибку") from None
|
||||
|
||||
|
||||
def _orientation(img) -> int:
|
||||
|
||||
+44
-24
@@ -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}
|
||||
|
||||
@@ -81,6 +81,23 @@ def variant_key(attachment_id: str, pipeline_version: int, name: str, extension:
|
||||
return f"{VARIANTS_PREFIX}{uuid.UUID(attachment_id)}/v{int(pipeline_version)}/{name}{extension}"
|
||||
|
||||
|
||||
def attachment_of(key: str) -> str | None:
|
||||
"""ID вложения, которому принадлежит ключ: staging/<id>, originals/<id>, variants/<id>/...
|
||||
Для ключа другого вида — None (уборщик решает по ключу, к какому вложению идти за блокировкой)."""
|
||||
for prefix in (STAGING_PREFIX, PREFIX, VARIANTS_PREFIX):
|
||||
if key.startswith(prefix):
|
||||
try:
|
||||
return str(uuid.UUID(key[len(prefix):].split("/", 1)[0]))
|
||||
except ValueError:
|
||||
return None
|
||||
return None
|
||||
|
||||
|
||||
def prefixes_of(attachment_id: str) -> list[str]:
|
||||
"""Префиксы всех объектов одного вложения (для уборки одного вложения: cleanup --attachment)."""
|
||||
return [staging_key(attachment_id), original_key(attachment_id), f"{VARIANTS_PREFIX}{uuid.UUID(attachment_id)}/"]
|
||||
|
||||
|
||||
def client():
|
||||
"""Один клиент на процесс (клиенты boto3 потокобезопасны), создаётся при первом обращении."""
|
||||
global _client
|
||||
|
||||
+148
-16
@@ -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:
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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():
|
||||
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -39,6 +39,27 @@ SAMPLE_JPEG = base64.b64decode(
|
||||
"8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDwGCw9q0ILD2rcgsPatCCw9q+pqYw4MFj9tTDgsPatCCw9q24LD2rQgsPauCpjD67BY/bU"
|
||||
"xILD2q/BYe1bkFh7VoQWHtXBUxh9dgsftqc3BYe1aEFh7VuQWHtWhBYe1cdTGH824LH7amHBYe1aEFh7VuQWHtWhBYe1cFTGH12C"
|
||||
"x+2phwWHtWhBYe1bkFh7VoQWHtXn1MYfXYLH7an/2Q==")
|
||||
# Ещё два синтетических JPEG 40×24 (созданы для курса Pillow): progressive и с маркерами RST (DRI = 1 MCU).
|
||||
PROGRESSIVE_JPEG = base64.b64decode(
|
||||
"/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAA0JCgsKCA0LCgsODg0PEyAVExISEyccHhcgLikxMC4pLSwzOko+MzZGNywtQFdBRkxOUlNS"
|
||||
"Mj5aYVpQYEpRUk//2wBDAQ4ODhMREyYVFSZPNS01T09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09P"
|
||||
"T0//wgARCAAYACgDASIAAhEBAxEB/8QAFwABAQEBAAAAAAAAAAAAAAAAAAMEBf/EABgBAAMBAQAAAAAAAAAAAAAAAAIDBAEG/9oADAMB"
|
||||
"AAIQAxAAAAHg11WxeWuqzbMreOuNSLlrVG22B1f/xAAWEAADAAAAAAAAAAAAAAAAAAAAAQL/2gAIAQEAAQUCUCgUCgUCgUCgUCgUCgUC"
|
||||
"gUH/xAAXEQADAQAAAAAAAAAAAAAAAAAAAQID/9oACAEDAQE/AY2I2FsRTIpipn//xAAXEQEBAQEAAAAAAAAAAAAAAAABABAR/9oACAEC"
|
||||
"AQE/ARhuxGf/xAAUEAEAAAAAAAAAAAAAAAAAAAAw/9oACAEBAAY/An//xAAUEAEAAAAAAAAAAAAAAAAAAAAw/9oACAEBAAE/IXAAAAA/"
|
||||
"/9oADAMBAAIAAwAAABBpk59wP//EABcRAQADAAAAAAAAAAAAAAAAABAAESH/2gAIAQMBAT8QKydq0//EABYRAQEBAAAAAAAAAAAAAAAA"
|
||||
"AAEAEP/aAAgBAgEBPxDPK2bC3//EABUQAQEAAAAAAAAAAAAAAAAAAABh/9oACAEBAAE/EJJJJJJJJJJJJJJJP//Z")
|
||||
RESTART_JPEG = base64.b64decode(
|
||||
"/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAA0JCgsKCA0LCgsODg0PEyAVExISEyccHhcgLikxMC4pLSwzOko+MzZGNywtQFdBRkxOUlNS"
|
||||
"Mj5aYVpQYEpRUk//2wBDAQ4ODhMREyYVFSZPNS01T09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09P"
|
||||
"T0//wAARCAAYACgDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQID"
|
||||
"AAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlq"
|
||||
"c3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3"
|
||||
"+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEI"
|
||||
"FEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImK"
|
||||
"kpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/90ABAAB/9oADAMBAAIR"
|
||||
"AxEAPwDg4rP2q3FZ+1akVn7Vbis/alCZz0MYf//Q5mKz9qtxWftWpFZ+1W4rP2rohM9GhjD/0c+Kz9qK34rP2orvUz6aGM0P/9J0Vn7V"
|
||||
"bis/aiiuSDZ8pQqyP//T2IrP2q3FZ+1FFTBs82hVkf/U66Kz9qKKK1TZcKsrH//Z")
|
||||
|
||||
|
||||
def _chunk(kind: bytes, data: bytes) -> bytes:
|
||||
@@ -87,6 +108,127 @@ def bad_filter_png() -> bytes:
|
||||
return b"\x89PNG\r\n\x1a\n" + _chunk(b"IHDR", ihdr) + _chunk(b"IDAT", zlib.compress(raw)) + _chunk(b"IEND", b"")
|
||||
|
||||
|
||||
# ---------- JPEG по сегментам: чтобы портить структуру точечно ----------
|
||||
|
||||
def jpeg_parts(data: bytes) -> list:
|
||||
"""JPEG -> [("seg", маркер, данные) | ("scan", заголовок SOS, сжатые данные) | ("eoi", хвост)]."""
|
||||
i, parts = 2, []
|
||||
while True:
|
||||
marker = data[i + 1]
|
||||
i += 2
|
||||
if marker == 0xD9:
|
||||
parts.append(("eoi", data[i:]))
|
||||
return parts
|
||||
length = int.from_bytes(data[i:i + 2], "big")
|
||||
payload, i = data[i + 2:i + length], i + length
|
||||
if marker != 0xDA:
|
||||
parts.append(("seg", marker, payload))
|
||||
continue
|
||||
j = i
|
||||
while data[j] != 0xFF or data[j + 1] == 0x00 or 0xD0 <= data[j + 1] <= 0xD7:
|
||||
j += 1
|
||||
parts.append(("scan", payload, data[i:j]))
|
||||
i = j
|
||||
|
||||
|
||||
def jpeg_join(parts: list) -> bytes:
|
||||
out = bytearray(b"\xff\xd8")
|
||||
for part in parts:
|
||||
if part[0] == "seg":
|
||||
out += bytes([0xFF, part[1]]) + struct.pack(">H", len(part[2]) + 2) + part[2]
|
||||
elif part[0] == "scan":
|
||||
out += b"\xff\xda" + struct.pack(">H", len(part[1]) + 2) + part[1] + part[2]
|
||||
else:
|
||||
out += b"\xff\xd9" + part[1]
|
||||
return bytes(out)
|
||||
|
||||
|
||||
def _edit(data: bytes, kind, fn, index: int = 0) -> bytes:
|
||||
"""Поменять index-й сегмент вида kind (маркер или "scan"): fn(bytearray) -> bytes."""
|
||||
parts, seen = jpeg_parts(data), 0
|
||||
for k, part in enumerate(parts):
|
||||
hit = part[0] == "scan" if kind == "scan" else part[0] == "seg" and part[1] == kind
|
||||
if hit:
|
||||
if seen == index:
|
||||
if kind == "scan":
|
||||
parts[k] = ("scan", fn(bytearray(part[1])), part[2])
|
||||
else:
|
||||
parts[k] = ("seg", kind, fn(bytearray(part[2])))
|
||||
return jpeg_join(parts)
|
||||
seen += 1
|
||||
raise AssertionError(f"segment {kind} #{index} not found")
|
||||
|
||||
|
||||
def _set(position: int, value: int):
|
||||
def change(payload: bytearray) -> bytes:
|
||||
payload[position] = value
|
||||
return bytes(payload)
|
||||
return change
|
||||
|
||||
|
||||
def teacher_bad_sos_jpeg() -> bytes:
|
||||
"""Воспроизведение из замечания: в первом SOS (FF DA по смещению i) байт i+5 — первый
|
||||
идентификатор компонента — заменить на 250, которого нет в SOF."""
|
||||
data = bytearray(SAMPLE_JPEG)
|
||||
i = data.index(b"\xff\xda")
|
||||
data[i + 5] = 250
|
||||
return bytes(data)
|
||||
|
||||
|
||||
def broken_structure_jpegs() -> list[tuple[str, bytes]]:
|
||||
"""JPEG, которые строгий декодер worker отвергает по маркерам и заголовкам (API: 415)."""
|
||||
def drop(data, test):
|
||||
return jpeg_join([p for p in jpeg_parts(data) if not test(p)])
|
||||
|
||||
def scans(data):
|
||||
return [p for p in jpeg_parts(data) if p[0] == "scan"]
|
||||
|
||||
def swap_rst(entropy: bytes) -> bytes:
|
||||
e = bytearray(entropy)
|
||||
positions = [k for k in range(len(e) - 1) if e[k] == 0xFF and 0xD0 <= e[k + 1] <= 0xD7]
|
||||
e[positions[0] + 1], e[positions[1] + 1] = e[positions[1] + 1], e[positions[0] + 1]
|
||||
return bytes(e)
|
||||
|
||||
seq_scan = scans(SAMPLE_JPEG)[0]
|
||||
first_progressive = scans(PROGRESSIVE_JPEG)[0]
|
||||
no_jfif = drop(SAMPLE_JPEG, lambda p: p[0] == "seg" and p[1] == 0xE0)
|
||||
restart_parts = jpeg_parts(RESTART_JPEG)
|
||||
return [
|
||||
("SOS: компонент 250, которого нет в SOF (замечание к MR)", teacher_bad_sos_jpeg()),
|
||||
("SOS: один компонент дважды в скане", _edit(SAMPLE_JPEG, "scan", _set(3, 1))),
|
||||
("SOS: таблица Хаффмана DC 2 не определена", _edit(SAMPLE_JPEG, "scan", _set(2, 0x20))),
|
||||
("SOS: номер таблицы Хаффмана AC 5", _edit(SAMPLE_JPEG, "scan", _set(4, 0x05))),
|
||||
("SOS: Se=62 в последовательном JPEG", _edit(SAMPLE_JPEG, "scan", _set(-2, 62))),
|
||||
("SOS: Ah/Al не нули в последовательном JPEG", _edit(SAMPLE_JPEG, "scan", _set(-1, 0x10))),
|
||||
("SOS: 5 компонентов в скане", _edit(SAMPLE_JPEG, "scan", _set(0, 5))),
|
||||
("SOF: таблица квантования 3 не определена", _edit(SAMPLE_JPEG, 0xC0, _set(8, 3))),
|
||||
("SOF: повторяется идентификатор компонента", _edit(SAMPLE_JPEG, 0xC0, _set(9, 1))),
|
||||
("SOF: субдискретизация 1×4 (не понимает декодер)", _edit(SAMPLE_JPEG, 0xC0, _set(7, 0x14))),
|
||||
("SOF: коэффициент субдискретизации 0", _edit(SAMPLE_JPEG, 0xC0, _set(10, 0x01))),
|
||||
("SOF: 12 бит на канал", _edit(SAMPLE_JPEG, 0xC0, _set(0, 12))),
|
||||
("SOF: 2 компонента", _edit(SAMPLE_JPEG, 0xC0, lambda p: bytes(p[:5]) + b"\x02" + bytes(p[6:12]))),
|
||||
("DHT: коды не помещаются в длину (3 кода по 1 биту)",
|
||||
_edit(SAMPLE_JPEG, 0xC4, lambda p: b"\x00" + bytes([3] + [0] * 15) + b"\x00\x01\x02")),
|
||||
("DHT: символ 16 в таблице DC", _edit(SAMPLE_JPEG, 0xC4, lambda p: bytes(p[:-1]) + b"\x10")),
|
||||
("DHT: номер таблицы 4", _edit(SAMPLE_JPEG, 0xC4, _set(0, 0x04))),
|
||||
("DQT: таблица обрезана", _edit(SAMPLE_JPEG, 0xDB, lambda p: bytes(p[:-1]))),
|
||||
("сегмент с зарезервированным маркером 0xF0",
|
||||
jpeg_join([("seg", 0xF0, b"\x00\x00")] + jpeg_parts(SAMPLE_JPEG))),
|
||||
("мусорные байты между сегментами", SAMPLE_JPEG.replace(b"\xff\xdb", b"\x00\x00\xff\xdb", 1)),
|
||||
("APP0: JFIF версии 3", _edit(SAMPLE_JPEG, 0xE0, _set(5, 3))),
|
||||
("APP14: неизвестное преобразование Adobe 7",
|
||||
jpeg_join([("seg", 0xEE, b"Adobe\x00\x64\x00\x00\x00\x00\x07")] + jpeg_parts(no_jfif))),
|
||||
("второй скан после полного скана",
|
||||
jpeg_join(jpeg_parts(SAMPLE_JPEG)[:-1] + [seq_scan, ("eoi", b"")])),
|
||||
("progressive: AC-скан раньше DC-скана", drop(PROGRESSIVE_JPEG, lambda p: p is not None and p == first_progressive)),
|
||||
("progressive: Al=14", _edit(PROGRESSIVE_JPEG, "scan", _set(-1, 14))),
|
||||
("RST: маркеры RST0 и RST1 поменяны местами",
|
||||
jpeg_join([("scan", p[1], swap_rst(p[2])) if p[0] == "scan" else p for p in restart_parts])),
|
||||
("RST: маркеры есть, а интервала DRI нет", drop(RESTART_JPEG, lambda p: p[0] == "seg" and p[1] == 0xDD)),
|
||||
("RST: интервал DRI 2 вместо 1", _edit(RESTART_JPEG, 0xDD, lambda p: b"\x00\x02")),
|
||||
]
|
||||
|
||||
|
||||
def garbage_scan_jpeg() -> bytes:
|
||||
"""SAMPLE_JPEG с мусором вместо сжатых данных скана: маркеры и длины целы, данные — нет."""
|
||||
sos = SAMPLE_JPEG.index(b"\xff\xda")
|
||||
|
||||
+26
-5
@@ -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]:
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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"
|
||||
|
||||
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user