feat: limit accepted attachment work and add queue overload bench

Reject uploads with 429 at [uploads] max_unfinished_jobs, counted by the existing partial indexes in the membership block. Add the bench_queue profile, hypotheses H1-H9 and the fifth failure-stand API.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-01 07:30:08 +03:00
co-authored by Claude Opus 5.5
parent 5b5f59aa3b
commit d667fa3c57
53 changed files with 5043 additions and 122 deletions
+7 -2
View File
@@ -84,6 +84,10 @@ FastAPI 0.141 из `uv.lock`:
| 500 | `internal_error` | необработанное исключение, без деталей; с лабы 4 ещё у готового вложения нет объекта в S3 или он другого размера, а сверка этого ещё не подтвердила (`AttachmentContentMissing`, причина — `error` в журнале); после пометки сверкой — 404 (раздел «Вложения») |
| 503 | `unavailable` | недоступен Postgres или хранилище сессий: ограниченная ошибка вместо 500 (`infra.md`); с лабы 4 — недоступен S3 на путях байтов вложений |
С change `track1-queue-overload` 429 у загрузки ещё при пределе незавершённых заданий
(`UploadBacklogFull`, `Retry-After: 5` — `UPLOAD_BACKLOG_RETRY_AFTER_SECONDS`); 5 с:
повтор через секунду почти всегда получил бы тот же отказ (вопрос 10 в `REPORT.md`).
`429` контракт описывает как ограничение частоты запросов и требует
`Retry-After` — положительное целое. У нас 429 — только у загрузки, когда
заняты места процесса (design change `upload-memory`, решение 2). Места
@@ -284,12 +288,13 @@ ACTION_SCRIPT=scripts/restart.sh` (`tests/README.md`), hook —
- Порядок проверок загрузки: 401 → 400 (`chat_id`, `filename`, их
проверяет FastAPI после зависимостей) → 404 (членство) → 415
(`Content-Type`: тип до `;`, без регистра) → 413 (`Content-Length`) →
429 (предел незавершённых заданий, с change `track1-queue-overload`) →
429 (место загрузки, с change `upload-memory`) → тело: 413 (счётчик
прочитанного), 400 (тело не пришло за `[uploads]
body_timeout_seconds` — `UploadTimedOut`, или обрыв —
`UploadInterrupted`) → 415/413 (содержимое: сигнатура и подмена MIME,
целостность, пиксели). Тело не читается до пройденных 1–6; отказ на
1–5 места не ждёт и не занимает (посторонний и заведомо большое тело не
целостность, пиксели). Тело не читается до пройденных 1–7; отказ на
1–6 места не ждёт и не занимает (посторонний и заведомо большое тело не
вытесняют живые загрузки). Пустое тело — 415.
- Места загрузки (спек `attachments`, «Одновременные загрузки реплики»;
`service-layer.md`): `[uploads] max_concurrent` (4) на процесс, очередь
+48 -5
View File
@@ -100,6 +100,7 @@ change `s3-storage`, решение 9): старт стенда перечисл
| `run.py` (профили `rollout`, `rollout_quick`), `rollout.py`, `resources.py`, `sampler.sh` (режим `scan`), `k6/failover.js`, `k6/retry.js`, `scripts/rolling-update.sh` | `make bench_rollout`, `make bench_rollout_quick` | две реплики с лимитами рабочего стенда на образе прежнего commit, та же постоянная нагрузка, посреди неё — поочерёдная замена на образ текущего checkout: посекундная шкала с ответами старых и новых реплик, шаги по каждой реплике, контейнеры, образы и ревизия схемы до и после, сверка записей, CPU и память каждого компонента по окнам замены; результаты — `evidence/rollout/<метка>/` |
| `run.py` (профили `uploads`, `uploads_quick`), `uploads.py`, `sampler.sh` (режим `peak`), `k6/uploads.js`, `k6/prepare.js` | `make bench_uploads [UPLOADS_LABEL=…]`, `make bench_uploads_quick` | память реплики при одновременных загрузках вложений (change `upload-memory`): одна реплика 1 CPU / 512 МБ без swap, S3 рабочего стенда, варианты «до» / «без лимита» / «с лимитом», тела PNG ~1 и ~10 MiB, 1 / 10 / 20 / 40 клиентов; пик `memory.peak` окна, OOM, ответы по кодам, загрузок/с и p50/p95/p99; результаты — `evidence/uploads/<метка>/` |
| `run.py` (профили `reconcile`, `reconcile_quick`), `reconcile.py`, `fill_objects.py`, `sampler.sh` (режим `scan`), `k6/background.js`, `k6/prepare.js` | `make bench_reconcile [RECONCILE_LABEL=…]`, `make bench_reconcile_quick` | стоимость сверки bucket и БД (change `track2-reconcile-cost`): наполнение мимо API (`\copy` и PUT в S3), разовые проходы уборщика — стратегии `batch` и `head`, глубокая, CPU уборщика, предел скорости, фоновая нагрузка, отказ по пределу «до» и «после»; счёт сверки против метрик шлюза S3, CPU и память за окно прохода; результаты — `evidence/reconcile/<метка>/` |
| `run.py` (профили `queue`, `queue_quick`), `overload.py`, `make_images.py`, `queue.compose.yml`, `rabbitmq/`, `sampler.sh` (режим `queue`), `k6/queue.js`, `k6/queue_sweep.js`, `k6/background.js`, `k6/prepare.js` | `make bench_queue [QUEUE_LABEL=…] [RESUME=1]`, `make bench_queue_quick` | очередь под перегрузкой (change `track1-queue-overload`): стенд с S3, брокером, relay, worker и уборщиком, настройки конкуренции и prefetch × классы изображений, блоки предела, приёма, второго worker и рестартов; результаты — `evidence/queue/<метка>/` |
| `run.py` (профили `scaling_*`), `scaling.py`, `sampler.sh`, `k6/mixed.js` | `make bench_scaling SERIES=a\|b\|pool\|ab\|db\|db4`, `make bench_scaling_quick`, `SERIES=db_quick` | серии трека 1: конфигурации реплик и лимитов, на каждую ячейку — свежий стенд, открытая модель, фиксированные уровни и поиск R* по SLO, посекундный сэмплер контейнеров, ВМ, LB и PostgreSQL; результаты — `evidence/bench/<метка>/` |
| `plots.py` | `make bench_plots LABELS="…"` | графики SVG и сводка серий (R* от числа реплик, p95 от интенсивности, CPU по компонентам, точка насыщения) — `evidence/plots/<PLOTS>/` |
| `compare.py` | `make bench_compare` | дельта двух меток стенда (ячейки матрицы или общие конфигурации серий), эффект или шум |
@@ -159,7 +160,7 @@ change `s3-storage`, решение 9): старт стенда перечисл
поля в паспорте не имеют. Там же исправлено: контейнер сэмплера (образ
PostgreSQL) удаляется с `-v`, иначе каждый запуск оставлял анонимный
volume `/var/lib/postgresql`;
- **S3** — запускают только профили `uploads` и `reconcile`: образ,
- **S3** — запускают только профили `uploads`, `reconcile` и `queue`: образ,
аргументы и лимиты рабочего стенда (`BENCH_S3_*`, 1 CPU / 512 МБ, swap =
память; у `reconcile` — ещё порт метрик шлюза на loopback), bucket
`bench` (`bench.env`) и пользователи — тот же `s3-bootstrap`; override
@@ -168,6 +169,10 @@ change `s3-storage`, решение 9): старт стенда перечисл
лимиты `BENCH_CLEANER_*` (`cleaner_cpus` 0,25, `cleaner_memory` 256m —
рабочего стенда, без swap) compose требует при разборе у всех профилей;
окружение реплик (`stand.app_env`) они не меняют;
- **брокер, relay и worker** — запускает только профиль очереди, лимиты
`BENCH_BROKER_*`, `BENCH_RELAY_*`, `BENCH_WORKER_*` рабочего стенда; плагин метрик
брокера и политика перезапуска worker — только его `queue.compose.yml`; остальные
профили меряют реплику;
- **PostgreSQL `max_connections`:** 100, как у образа (`-c
max_connections` в override); у серий — из конфигурации ячейки,
лимиты конфигурации в паспорте (`limits.<конфигурация>`);
@@ -336,10 +341,12 @@ change `s3-storage`, решение 9): старт стенда перечисл
docker — `bench/uploads.py` (`--selftest`). С change `pipeline-reliability`
(решение 16) брокер, relay и worker описаны в `bench.compose.yml` (лимиты
`BENCH_BROKER_*`, `BENCH_RELAY_*`, `BENCH_WORKER_*`, compose требует их при разборе
у всех профилей) и не запускаются ни одним профилем: реплика к брокеру не обращается,
задания ждут в PostgreSQL. Метка `baseline`, снятая на `ff1a83b` с брокером, с новыми
не сравнивается. `Stand.start_broker` и поля `Profile` оставлены для трека 1; поля
есть в `meta.profile` как часть определения стенда. Успех — 202, у варианта «до» —
у всех профилей) и здесь не запускаются: реплика к брокеру не обращается,
задания ждут в PostgreSQL. Поэтому у всех вариантов `UPLOADS__MAX_UNFINISHED_JOBS=0`
(change `track1-queue-overload`, решение 13): иначе профиль мерил бы предел, а не
память приёма; `app_env` вариантов — в паспорте. Метка `baseline`, снятая на
`ff1a83b` с брокером, с новыми
не сравнивается. Успех — 202, у варианта «до» —
201: столбец `s201` не переименован, код называет `success_code` в конце `runs.csv` и
раздел `uploads` паспорта.
@@ -516,6 +523,42 @@ design change `track2-reconcile-cost`, решения 1–3, 7–13. Метод
`make bench_reconcile` на тихом хосте, рабочий стенд остановлен (`make
stop`), гипотезы H1–H4 закоммичены раньше метки.
## Профиль очереди (`queue`, `queue_quick`)
Спек `load-benchmark`, «Профиль очереди»; design change `track1-queue-overload`, решения
5–11, 14. Методика — поля `Profile` (`queue_*`), `QUEUE_RATES`, конфигурации
`queue_matrix` и `queue_blocks` в `run.py`; разбор без docker — `bench/overload.py`
(`--selftest`), не `queue.py`: каталог скрипта первый в `sys.path`.
- **Стенд:** LB, две реплики 1 CPU / 512 МБ, PostgreSQL, Valkey, S3, брокер, relay, worker
и уборщик с лимитами рабочего стенда без swap; третий `-f` — `queue.compose.yml`
(плагин `rabbitmq_prometheus`, статистика в секунду, порт 15692 только в сети стенда;
`restart: unless-stopped` у worker), окружение ячейки — `.work/variant.compose.yml`.
У S3 остаётся `restart: "no"`: его гибель — пометка `storage_down`.
- **Ячейка** — свежий стенд, `prepare.js`, разогрев 12 файлов `s` до `ready` (готовые байты
контрольного потока), сэмплер `queue`, `background.js`, `queue.js`: окна `before` и `over`
одним запуском, затем ожидание нуля незавершённых, окно `after` отдельным запуском,
ожидание нуля, `queue_sweep.js`, чтение SQL и журналов. VU — заранее и без прибавления:
тело — `open` на VU. Ответ не повторяется.
- **Истина о готовности — `GET /attachments/{id}` после разбора:** `updated_at` у `ready`
не меняется, живого опроса нет. Новые исключения границы чёрного ящика, только этот
профиль и только чтение: `psql \watch` сэмплера и чтение SQL в конце ячейки, метрики
брокера по HTTP в сети стенда, журналы контейнеров (разбор без копирования в метку).
- **Сэмплер `queue`:** строки `cg`, `vm`, `lb` как в `scan` и `list`, `mp` (`memory.peak`,
`anon`, `oom_kill`), `mq` (метрики брокера, `missing`), `jobs.log` — `psql \watch`.
`rabbitmqctl` стоит 0,5 с CPU брокера на вызов: им не опрашивать. Перезапуск сбрасывает
cgroup того же контейнера: `overload.split_lives` — наибольшее и сумма по жизням.
- **Пометки:** `oom`, `worker_restart`, `failed` — результат настройки; `lost`, `stuck`,
`duplicate`, `sha_mismatch` — ненулевой код команды в конце метки, ячейки сняты;
`not_recovered`, `dropped`, `lb_down`, `host_swap`, `storage_down`. Запись «Started
worker» не совпала с ячейкой — отказ. Тиков сэмплера нет 3 с в нагрузке — отказ.
- **`RESUME=1`** — как у серий: тот же commit, готовая строка `cells.csv` — признак ячейки.
- **Результаты:** `evidence/queue/<метка>/` — `meta.json`, `cells.csv` (новые столбцы —
только в конец), `timeline.csv`, `summary.md`, четыре SVG, `raw/` — только итоги k6;
журналы не копируются, `.work/` удаляется. `quick-queue-*` — в `.gitignore`.
- **Время:** полный профиль — 57 ячеек, ~2 ч 10 мин; `queue_quick` — `s` (2, 2), `lp` (4, 4),
предел 40 и без него, `kill-worker`, `w2-p256`, ~11 мин. Рабочий стенд — `make stop`.
## Серии трека 1 (`scaling_*`)
Доказательство уровня «5», трек 1 «Цена масштабирования» (design change
+5 -2
View File
@@ -169,7 +169,8 @@ pass». Модуль `attachment_cleanup_service`: «Finished staging cleanup pa
с `s3_host`, `s3_port`, `s3_bucket`; пустые ключи — `warning`. С change
`upload-memory` в ней же `uploads_max_concurrent`,
`uploads_max_waiting`, `uploads_wait_timeout_seconds`,
`uploads_body_timeout_seconds` (спек `service-configuration`,
`uploads_body_timeout_seconds`, с change `track1-queue-overload` —
`uploads_max_unfinished_jobs` (спек `service-configuration`,
«Параметры загрузок»).
- С лабы 4 — `filename` вложений (его выбирает пользователь) и байты
изображений. Модуль `attachment_service` пишет `info` «Uploaded
@@ -178,7 +179,9 @@ pass». Модуль `attachment_cleanup_service`: «Finished staging cleanup pa
«Rejected attachment» с `reason` (`type`, `declared_size`, `size`,
`content`, `content_mismatch`, `damaged`, `pixels`, `interrupted`; с
change `upload-memory` — `busy` с `waited_ms`: места заняты, 429, и
`body_timeout` с `size` прочитанного: тело не пришло за срок, 400),
`body_timeout` с `size` прочитанного: тело не пришло за срок, 400; с
change `track1-queue-overload` — `backlog` с `unfinished` и `limit`: предел
заданий, 429; профиль очереди сверяет эти записи с числом 429),
`chat_id` и `filename_length`, `error` «Attachment content is missing» / «…size
differs» с `attachment_id` и `object_key`. С change
`upload-consistency`: `warning` «Attachment upload left pending» с
+4 -1
View File
@@ -74,7 +74,10 @@ paths:
`attachment_job.py` (`insert_job`, `lock_job` — `FOR UPDATE`, `get_job`,
`get_attachment_job`, `start_attempt`, `return_to_queued` с условием своей
попытки, `finish_job`; relay — `lock_due_jobs` (`FOR UPDATE SKIP LOCKED`,
порядок по выражению индекса), `count_published`, `mark_published` пакета,
порядок по выражению индекса), `count_published`, `count_unfinished` (сумма трёх
`count(*)` с `LIMIT` на группу по условиям частичных индексов outbox, опубликованных
и аренды: цена не растёт с превышением, число выше предела неточно, design change
`track1-queue-overload`, решение 3), `mark_published` пакета,
`recover_expired_leases`, `has_published_before`, `reset_published_before`;
`replay_job`, `list_failed` — состояние в выборках relay константой
`literal_execute`), `attachment_job_replay.py` (`insert_replay`,
+8 -1
View File
@@ -100,8 +100,15 @@ paths:
`object_storage` из зависимости, `slots` — глобал `upload_slots`
(места загрузок процесса, `infra.md`; в сервисе только тип под
`TYPE_CHECKING`);
- предел принятой работы (design change `track1-queue-overload`, решение 3): в том
же первом блоке, что членство, — `Content-Type`, `Content-Length`, затем
`self.uow.jobs.count_unfinished(limit=…)`; у предела `info` «Rejected attachment»
`reason=backlog`, `unfinished`, `limit` и `UploadBacklogFull`. Значение 0 — запроса
нет. Шаг с БД до тела один, поэтому граница молчания реплики и цепочка LB прежние.
Предел мягкий: превышение — только загрузки в полёте, жёсткая граница потребовала
бы блокировки на фиксацию;
- порядок записи загрузки: проверки (членство, `Content-Type`,
`Content-Length`) — без места → `async with self.slots.slot()` (429
`Content-Length`, предел заданий) — без места → `async with self.slots.slot()` (429
`UploadsBusy`: `info` «Rejected attachment», `reason=busy`,
`waited_ms`) → внутри `_store` весь остальной путь до ответа: чтение
тела со счётчиком под `asyncio.timeout([uploads]
+9 -1
View File
@@ -184,7 +184,15 @@ make env_setup»). Значение уже существующей переме
`uploads` — 1000 / 0 у варианта «без лимита»). Настройки, а не
константы: у установок разный лимит памяти. Неверное значение —
ошибка проверки настроек с именем поля, сервис не стартует. «Started
API» называет все четыре.
API» называет все пять (с `max_unfinished_jobs`).
- `max_unfinished_jobs` (int, `ge=0`, 250; 0 — без предела; design change
`track1-queue-overload`, решения 1–2): при каком числе незавершённых заданий стенда
(`queued` и `processing`) загрузка получает 429 `Retry-After: 5`. Выбран по худшему
классу: предел / потолок worker — срок ожидания, он меньше `[relay]
republish_after_seconds`; при другом числе worker предел другой. Разовая подмена —
`UPLOADS__MAX_UNFINISHED_JOBS` (стенд отказов и профиль `uploads` — 0, пятый API
стенда отказов — 3). `Retry-After` — константа `UPLOAD_BACKLOG_RETRY_AFTER_SECONDS`;
- `max_concurrent` 4 — бюджет реплики 512 МБ: база ~105 MiB + хэши
паролей 4 × 64 MiB + места до ~90 MiB при 40 клиентах ≈ 450 MiB; при
+23 -1
View File
@@ -412,6 +412,27 @@ paths:
`<проект>-test-relay`. После KILL новая попытка ждёт аренду 12 с. Время полного
прогона — design change `pipeline-reliability`, «Уточнения apply».
С change `track1-queue-overload` (design, решение 13):
- пятый API стенда отказов — «узкий по заданиям» (`<проект>-api-backlog`, `BACKLOG_ENV`
в `run_failures.py`: `UPLOADS__MAX_UNFINISHED_JOBS=3`), тестам — `FAULT_BACKLOG_BASE_URL`
(фикстура `backlog_api`, срок клиента 30 с) и `FAULT_BACKLOG_ENV`, сверка —
`assert_backlog_stand`; без адреса `pytest -m fault` останавливается до первого теста.
У четырёх прежних — `UPLOADS__MAX_UNFINISHED_JOBS=0`: их проверки копят задания при
остановленном worker, и предел отклонял бы чужие загрузки;
- hook: `unfinished-jobs` (число заданий `queued` и `processing`, полный счёт, без обрыва),
`backlog-api-log` (журнал пятого API); помощник `wait_no_unfinished` — перед проверкой
предела стенд должен разобрать чужой бэклог, до 120 с;
- тесты: `test_backlog_limit` («Предел достигнут», «Порядок проверок у предела»,
«Остальной API у предела», «Загрузки снова принимаются», запись «Started API» и «Rejected
attachment» по журналу), `test_backlog_ignores_finished`,
`test_backlog_counts_waiting_retry` (relay стоит, срок следующей попытки отодвинут
`set-next-attempt`), `test_backlog_without_broker`, `test_backlog_overshoot_bounded` (40
клиентов за барьером, принято от K до K + 20), `test_backlog_off` (обычный API без
предела);
- девять сценариев `queue-overload` с открытой нагрузкой и счётчиками — исключения сверки:
`make bench_queue` → `evidence/queue/baseline/summary.md`.
Проверки отказов реплик (остановка, kill, зависание, rolling update) —
не pytest, а `make test-failover`, профиль `failover` стенда `bench/`
(`make bench_failover`, `bench.md`), команды драйвера `kill-inflight`,
@@ -472,7 +493,8 @@ paths:
healthcheck PostgreSQL проверяет
служебную базу `postgres` (иначе каждая проверка — сессия в базе
приложения и шум счётчика `db-sessions`);
- четыре API на свободных портах `127.0.0.1`: обычный (`BASE_URL`; с
- пять API на свободных портах `127.0.0.1` (пятый — раздел change
`track1-queue-overload` выше): обычный (`BASE_URL`; с
лабы 4 в окружении `MAX_UPLOAD_BYTES=1` и `MAX_IMAGE_PIXELS=1` —
`LIMITS_ENV`, тест получает их в `FAULT_LIMITS_ENV` и грузит
`sample.png`: лимиты — константы, спек `service-configuration`),
+10
View File
@@ -77,6 +77,16 @@ change `async-attachments` (2, 6–8) и `pipeline-reliability` (1–9, 19). З
- **Prefetch и конкуренция:** `set_qos(prefetch)`, каждая доставка — задача,
`asyncio.Semaphore(concurrency)` вокруг `service.handle`: сообщение сверх
конкуренции ждёт без взятия и аренды, после сигнала попытка не начинается.
- **Подбор конкуренции и prefetch** (design change `track1-queue-overload`, решения
5, 12): `concurrency ≤ min(CPU + ожидание, (лимит − база) / пик процесса)`,
`prefetch = concurrency`. Сверх CPU конкуренция не ускоряет, а удлиняет процесс и
умножает память; больше prefetch только прячет очередь от брокера и второго worker.
Два ограничения сверху на `prefetch / потолок`: 30 мин (`consumer_timeout`
брокера: дольше — закрытие канала) и `[relay] republish_after_seconds` 300 с (иначе
копии потерянных). Конкуренция, которая не помещается в лимит памяти контейнера, —
не только повторы `render_killed`: ядро может завершить и процесс 1, контейнер
перезапускается, задания возвращаются по аренде (до 70 с). Защита — конкуренция, а
не `oom_score_adj`. Числа и проверка правила — метка `evidence/queue/baseline/`.
- **Варианты:** одно декодирование, `fit_size` (округление вниз, не
`Image.thumbnail`). `draft` у JPEG — под самый большой нужный размер. Основа 1280 —
для optimized и thumbnail; crop — из основы, если её короткая сторона ≥ 256, иначе
@@ -208,6 +208,7 @@ python3 $D --port 8080 s3-idle # клиент S3 после ска
python3 $D lb-upload-timeouts # сроки LB пути загрузки на заглушке: 202 после 12 с молчания, 504 через 10/30 с, 400 в формате контракта; ~35 с
python3 $D --port 8080 defense-scenario # защита лабы 5: worker стоит, 202, 201, 409, 201, сообщение в очереди, рестарт, worker, ready, оригинал и три варианта; ~1,5 мин
python3 $D --port 8080 defense-faults # шаг 4 защиты: crash до фиксации и до ack, relay убит до публикации и до отметки, replay; ~4 мин
make bench_queue_quick # шаг защиты «для 5 — выбранный эксперимент»: очередь под перегрузкой, ~11 мин (рабочий стенд — make stop); разбор — evidence/queue/baseline/summary.md
python3 $D broker-check # брокер: образ, volume, порт, предел памяти, очередь, пароль только у rabbitmq, relay, worker, остановка с кодом 0; ~30 с
python3 $D --port 8080 worker-process # процесс worker: PID 1, лимиты, Pillow, журнал, неверные настройки, остановка, рестарт хранилищ, остановка под нагрузкой; ~5 мин
python3 $D --port 8080 relay-process # процесс relay: то же, окружение без S3 и Valkey; ~2 мин
+2
View File
@@ -40,6 +40,8 @@ evidence/rollout/quick-*/
evidence/uploads/quick-*/
# make bench_reconcile_quick: то же для профиля сверки
evidence/reconcile/quick-reconcile-*/
# make bench_queue_quick: то же для профиля очереди
evidence/queue/quick-*/
# сравнения пробных меток
evidence/compare/*quick-*
# make bench_plots на пробных метках
+27 -9
View File
@@ -24,8 +24,10 @@ relay вместо публикации в запросе, варианты `cro
prefetch, очистка staging. Единица работы — change `unit-of-work` (заархивирован 2026-11-01,
`openspec/changes/archive/2026-11-01-unit-of-work/`, полный UoW по Cosmic Python, решение
пользователя, новая capability `unit-of-work`): сервисы на абстракциях
`src/core/ports/`, соединение на шаг, быстрые тесты `service-tests/`; следующий —
`track1-queue-overload` (уровень 5). Код перенесён из
`src/core/ports/`, соединение на шаг, быстрые тесты `service-tests/`. Очередь под
перегрузкой (уровень 5) — change `track1-queue-overload` (активный, новая capability
`queue-overload`): предел незавершённых заданий на входе API, профиль `make bench_queue`,
гипотезы H1–H9 в `REPORT.md`; метка `baseline` — на закоммиченном коде. Код перенесён из
лабы 4 (репозиторий `mtusi2026lab4-safronov`, ветка
`solution/bvt2301-safronov`, commit `2546deb`) по разделу «Переход в
следующую лабу»; отчёт и evidence лабы 4 остались в её репозитории. Дальше
@@ -85,15 +87,15 @@ max_objects_per_second` (2000 объектов S3/с), отказ по пред
`upload-consistency`, `upload-memory`, `track2-reconciler`,
`fix-upload-put-flake`, `track2-reconcile-cost` лабы 4, `async-attachments`,
`pipeline-reliability` и `unit-of-work` лабы 5 — в `openspec/changes/archive/`,
активных нет, следующий — `track1-queue-overload` (новые capability: с `s3-storage` —
активный — `track1-queue-overload` (новые capability: с `s3-storage` —
`object-storage`, с `attachments` — `attachments`, с
`upload-consistency` — `storage-consistency`, с `async-attachments` —
`attachment-processing`, `message-broker`, с `pipeline-reliability` — `job-outbox`,
с `unit-of-work` — `unit-of-work`);
в `KNOWN_ISSUES.md` восемь открытых записей (смесь версий при замене реплик на первый
с `unit-of-work` — `unit-of-work`, с `track1-queue-overload` — `queue-overload`);
в `KNOWN_ISSUES.md` девять открытых записей (смесь версий при замене реплик на первый
релиз с обработкой; bootstrap после удаления
bucket; уборщик
удаляет объект зависшей загрузки по ключу вне своего префикса; 408 LB на медленные заголовки текстом HAProxy; поля `float` настроек принимают `inf`; 504 LB на метаданных и скачивании вложения при зависшем PostgreSQL; ложный FAIL `driver.py reconcile-cycle` на наполненном стенде; остановка API при замороженном PostgreSQL дольше срока контейнера). Отчёт, evidence и рабочий план лабы 3 остались в её
удаляет объект зависшей загрузки по ключу вне своего префикса; 408 LB на медленные заголовки текстом HAProxy; поля `float` настроек принимают `inf`; 504 LB на метаданных и скачивании вложения при зависшем PostgreSQL; ложный FAIL `driver.py reconcile-cycle` на наполненном стенде; память S3 на долго живущем стенде; остановка API при замороженном PostgreSQL дольше срока контейнера). Отчёт, evidence и рабочий план лабы 3 остались в её
репозитории (`REPORT.md`, `evidence/`, `git show 063eedb:PLAN.md`).
Стек: Python 3.12, uv, FastAPI, pydantic v2, pydantic-settings,
structlog (JSON в stdout), redis-py (клиент Valkey), aiobotocore
@@ -276,6 +278,15 @@ structlog (JSON в stdout), redis-py (клиент Valkey), aiobotocore
staging_retention_seconds` вместе с частично записанными объектами, блокировка `FOR
NO KEY UPDATE`; сверка находит `orphan_staging`. Лимиты 0,25 CPU / 256 МБ у relay, пул
1. Цепочка LB — 26 с и 73 с (`balancer.md`).
- Лаба 5, предел принятой работы (change `track1-queue-overload`, спек `queue-overload`,
`service-layer.md`): загрузка при `[uploads] max_unfinished_jobs` (250, 0 — без предела)
и больше незавершённых заданий стенда (`queued`, `processing`) получает 429
`rate_limited` с `Retry-After: 5`, без тела и места, ни строки, ни объекта. Порядок: 404
→ 415 → 413 → 429 предела → 429 мест. Считает все реплики по PostgreSQL одним запросом
в первом блоке (три частичных индекса с `LIMIT` на группу, `count_unfinished`), шаг
с БД не прибавляется, цепочка LB прежняя. Предел мягкий: превышение — только загрузки в
полёте. Текст, история, метаданные, готовые байты и `/health/ready` от него не
зависят. Профиль `uploads` и четыре прежних API стенда отказов — с пределом 0.
- `.env`, `config.toml`, секреты, токены и реальные данные не попадают ни
в git, ни в образ. В `evidence/` и `REPORT.md` — только обезличенные
выводы команд.
@@ -488,7 +499,7 @@ structlog (JSON в stdout), redis-py (клиент Valkey), aiobotocore
| `make service_test_db` | `start_db` и `service-tests/db` на временной базе `test_uow_<db>`: настоящая единица работы, тот же контракт repo на SQL, соединение на шаг и общий срок JSON-запроса в процессе (S3 и кэш — фейки), замороженный сервер — TCP-прокси; база удаляется при любом исходе, имя не по шаблону — код 2 |
| `make test_isolated [KEEP_TEST_DB=1]` | образ на временной базе `test_<db>` с Valkey и S3 стенда (ключи кэша и объектов разделены именем базы): сборка, миграции, отдельный контейнер API на `TEST_APP_PORT`, `make test` + `make student_test EXPECT_REPLICAS=1` (тесты реплик пропускаются с причиной), уборка при любом исходе — база и объекты под префиксом `test_<db>/` (`student-tests.md`) |
| `make student_test [BASE_URL=...] [EXPECT_REPLICAS=...]` | собственные тесты `student-tests/` (pytest) против запущенного сервера, кроме проверок отказов (`-m 'not fault'`); `EXPECT_REPLICAS` (по умолчанию `API_REPLICAS`) — сколько реплик за `BASE_URL`, против одного процесса — 1; сервер недоступен — код 2 и одна строка с адресом |
| `make failure_checks [FAULT_ARGS=...]` | проверки отказов (`pytest -m fault`, 141 проверка, ~39 мин) на отдельном стенде: проект `<рабочий>-failures` со своими Postgres, Valkey и S3 (с bootstrap), уборщик (grace 20 с, интервал 1 с), четыре API — обычный, «тесный» (срок 2 с, пул 1), «узкий по загрузкам» и «с коротким сроком S3» (1 с), hook `student-tests/fault_hook.py`; после тестов — журнал PostgreSQL стенда: сводка (`crash markers`, «too many clients», «administrator command») и ненулевой код при признаках аварийного перезапуска; стенд и его volumes удаляются при любом исходе, рабочий не трогается (`student-tests.md`) |
| `make failure_checks [FAULT_ARGS=...]` | проверки отказов (`pytest -m fault`, 147 проверок, ~39 мин) на отдельном стенде: проект `<рабочий>-failures` со своими Postgres, Valkey и S3 (с bootstrap), уборщик (grace 20 с, интервал 1 с), пять API — обычный, «тесный» (срок 2 с, пул 1), «узкий по загрузкам», «с коротким сроком S3» (1 с) и «узкий по заданиям» (предел 3; у прочих предел выключен), hook `student-tests/fault_hook.py`; после тестов — журнал PostgreSQL стенда: сводка (`crash markers`, «too many clients», «administrator command») и ненулевой код при признаках аварийного перезапуска; стенд и его volumes удаляются при любом исходе, рабочий не трогается (`student-tests.md`) |
| `make bench [BENCH_LABEL=...]` | полная матрица 10k / 100k / 500k читаемого чата плюс 100 000 сообщений в 1 110 фоновых чатах разного размера (~35 мин, оценка по `bench_quick`) на своём проекте compose `mtusi-bench` (HAProxy и одна реплика API, Postgres, Valkey с лимитами, без портов хоста и без `.env` рабочего стенда; k6 ходит через LB); на каждый размер — свежий стенд, `VACUUM (ANALYZE)`, планы запроса истории (`auto_explain`) по уровням чатов с вариантами индекса и запроса, в конце — пробы стоимости записи по вариантам. Результаты в `evidence/bench/<метка>/`, занятая метка — отказ. Перед запуском — подготовка хоста (`bench.md`) |
| `make bench_quick` | самопроверка стенда на 1k / 5k / 10k и 3 500 фоновых сообщений (~3 мин), метка `quick-<время>`, в git не идёт |
| `make bench_restore [RESTORE_LABEL=...]` | трек 2, восстановление (~20 мин, метка `restore` по умолчанию): тот же стенд и данные, без матрицы прогонов; на каждый размер — `pg_dump` во время записи через HTTP, активность после backup, `pg_restore -j` в новый контейнер Postgres на новом volume, сверка обеих баз построчно, переключение API, проверки через HTTP до и после `FLUSHALL`; время dump / restore / RTO и потерянные сообщения — в `summary.md` |
@@ -501,6 +512,8 @@ structlog (JSON в stdout), redis-py (клиент Valkey), aiobotocore
| `make bench_scaling_quick` | самопроверка серий: 1 × 1 и 2 × 1 при `max_connections` 50, короткие окна (~4 мин), метка `quick-scaling-<время>`, в git не идёт |
| `make bench_uploads [UPLOADS_LABEL=...]` | уровень 4, память при одновременных загрузках (~50 мин, метка `baseline` по умолчанию; change `upload-memory`): стенд `mtusi-bench` с LB, одной репликой 1 CPU / 512 МБ без swap, PostgreSQL, Valkey и S3 рабочего стенда; варианты «до» (`Profile.uploads_before` — `04f8592`, commit переноса лабы 4: места загрузки уже есть, `bench.md`; `git archive`; commit вне истории — код 2), «без лимита» (1000 мест, без очереди) и «с лимитом» (по умолчанию) × тела PNG ~1 и ~10 MiB × 1 / 10 / 20 / 40 клиентов × 3 повтора, на прогон — новые реплика и volume S3; пик `memory.peak` окна со сбросом (сэмплер `peak`), `anon`, `sock`, OOM, ответы по кодам, загрузок/с, p50/p95/p99, пики S3 и LB, H1–H4 в сводке — `evidence/uploads/<метка>/`. Перед запуском — проверка хоста (`bench.md`), рабочий стенд — `make stop`, гипотезы закоммичены раньше |
| `make bench_uploads_quick` | то же короче (~4,5 мин): «без лимита» и «с лимитом», 10 MiB, 1 / 10 / 40 клиентов, один повтор, метка `quick-uploads-<время>`, в git не идёт |
| `make bench_queue [QUEUE_LABEL=...] [RESUME=1]` | уровень 5, трек 1, очередь под перегрузкой (~2 ч 10 мин, метка `baseline`; change `track1-queue-overload`): стенд `mtusi-bench` с S3, брокером, relay, worker и уборщиком, настройки (1, 1), (2, 2), (4, 4), (2, 256) × классы `s`, `m`, `lj`, `lp` × 3 повтора и блоки предела, приёма, второго worker, KILL worker, рестарта брокера; на ячейку — свежий стенд, открытая модель, контрольный поток, разбор очереди, обход метаданных; `evidence/queue/<метка>/` (`meta.json`, `cells.csv`, `timeline.csv`, `summary.md` с H1–H9 и рекомендацией, SVG). Рабочий стенд — `make stop`, гипотезы закоммичены раньше метки |
| `make bench_queue_quick` | то же короче (~11 мин): `s` (2, 2), `lp` (4, 4), предел 40 и без него, `kill-worker`, `w2-p256`, один повтор, метка `quick-queue-<время>`, в git не идёт; шаг защиты «для 5» |
| `make bench_plots LABELS="..." [PLOTS=scaling]` | графики SVG и сводка серий трека 1 из меток: R* от числа реплик, p95 от интенсивности, CPU по компонентам, эффективность и точка насыщения — `evidence/plots/<PLOTS>/` |
| `make bench_ab BEFORE=... AFTER=... REAPPLY=<commit> [SERIES=...]` | «до» и «после» одного изменения подряд (два прогона `bench`): `bench` для `BEFORE`, commit доказательств, `git revert` commit отката `REAPPLY`, `bench` для `AFTER`; с `SERIES` — серия трека 1 вместо матрицы (`make bench_scaling`). Нужно чистое рабочее дерево; сама делает два коммита |
| `make bench_compare BEFORE=... AFTER=... [AA=...] [CHANGE=...]` | дельта двух меток `make bench` по ячейкам матрицы, у серий трека 1 — по общим конфигурациям (R*, задержки на фиксированных уровнях, CPU на запрос) и таблица PostgreSQL на R* и первой нарушившей ступени (CPU на запрос, новые сессии, соединения); `CHANGE` — change в шапке сравнения серий (по умолчанию `scaling-bench`); метки с разной методикой не сравнивает (в том числе метку без LB с меткой стенда на LB и серию с матрицей); с `AA` (метка того же кода, что `BEFORE`) отделяет эффект от шума. Результат в `evidence/compare/<до>__<после>.md` |
@@ -541,7 +554,7 @@ src/
repos/<domain>.py # SqlAlchemy<Domain>Repository: одна атомарная операция на метод; chat_cache и attachment_object — модульные функции над клиентом
repos/idempotency.py # ключ идемпотентности: захват ON CONFLICT DO UPDATE WHERE просрочен, чтение сохранённого результата
repos/chat_cache.py # карточка чата в Valkey: ключ с именем базы, JSON ↔ ChatFullDTO
repos/attachment_job.py # задание вложения: вставка, lock_job FOR UPDATE, start_attempt, return_to_queued своей попытки, finish_job; relay — lock_due_jobs (SKIP LOCKED, порядок срока), count_published, mark_published пакета, recover_expired_leases, has_published_before, reset_published_before; replay_job, list_failed
repos/attachment_job.py # задание вложения: вставка, lock_job FOR UPDATE, start_attempt, return_to_queued своей попытки, finish_job; count_unfinished (предел принятой работы: сумма трёх count с LIMIT по частичным индексам); relay — lock_due_jobs (SKIP LOCKED, порядок срока), count_published, mark_published пакета, recover_expired_leases, has_published_before, reset_published_before; replay_job, list_failed
repos/attachment_job_replay.py # журнал replay: вставка записи аудита, чтение по заданию
repos/attachment_variant.py # варианты: вставка ON CONFLICT DO NOTHING по ключу эффекта, варианты вложения, один по имени
repos/attachment.py # строки вложений: вставка pending (created_at = updated_at), mark_queued (pending и непомеченная → queued RETURNING), mark_processing, return_to_queued, return_group_to_queued, replay_failed, lock_attachment (FOR NO KEY UPDATE), commit_ready, commit_failed, чтение одной и до 10; очистке staging — get_staging_candidates, lock_staging_candidate, clear_staging_key; уборщику — get_stale_pending (keyset по частичному индексу), lock_stale_pending (FOR UPDATE SKIP LOCKED), mark_removing (пометка updated_at), delete_attachment; сверке — get_attachments_for_objects (id = ANY OR object_key = ANY), get_ready_page (keyset ready по id), find_attachment_reference, mark_lost / clear_lost (условный UPDATE lost_at)
@@ -613,13 +626,17 @@ bench/ # нагрузочный стенд на HAProxy +
sampler.sh # сэмплер (только в контейнере mtusi-bench-sampler на образе PostgreSQL, --cgroupns host): режим list (серии) — cpu.stat, память и PSI заданных контейнеров, /proc/stat и PSI ВМ, статистика HAProxy, psql \watch по pg_stat_activity / database / wal / io; режим scan (failover, rollout) — обход cgroup всех контейнеров и /proc/stat, без сети, psql и LB; режим peak (uploads) — сброс memory.peak реплики, S3 и LB через свой дескриптор (perl), чтение пика в конце окна, выборка current / anon / sock / oom_kill раз в 0,2 с (--user 0, cgroupfs rw, без сети)
uploads.py # профиль uploads без docker: тела PNG из шума от зерна, план кругами, разбор строк k6 и сэмплера peak, строка runs.csv, пометки oom / host_swap / peak_sampled / s3_down, summary.md (медиана и min–max по ячейкам, сценарии спеков, H1–H4); --selftest
reconcile.py # профиль reconcile без docker (change track2-reconcile-cost): модель набора (id, содержимое и класс по номеру и зерну, строки CSV для \copy, ожидаемое по классам), план кругами, разбор записей уборщика, метрик шлюза S3, строк bg k6 и сэмплера, окна и r / a H4, passes.csv и windows.csv, вердикты H1–H4 и S4, summary.md и SVG (plots.Svg); --selftest
overload.py # профиль queue без docker (change track1-queue-overload): план кругами, разбор строк q/qs/qv, jobs, mq, mp и журналов, жизни контейнера, строка cells.csv и timeline.csv, пометки, вердикты H1–H9, правило рекомендации, summary.md и SVG; --selftest
make_images.py # файлы классов s, m, lj, lp профиля queue: только в контейнере mtusi-bench-images на образе стенда (Pillow образа, --network none), зерно из аргумента, JSON с размерами и SHA-256, больше лимита контракта — код 1
queue.compose.yml # третий -f только профиля queue: плагин метрик брокера и статистика в секунду (bench/rabbitmq/), restart: unless-stopped у worker
rabbitmq/ # enabled_plugins и 91-bench.conf профиля queue
fill_objects.py # загрузчик объектов профиля reconcile: только в контейнере mtusi-bench-fill на образе стенда (botocore образа, bench/ на чтение, ключи API из окружения), процессы × потоки PUT по модели reconcile.py
resources.py # ресурсы профилей failover и rollout без docker: интервалы контейнеров (сброс при новой cgroup, заморозка, новые контейнеры с момента запуска), окна, CPU / троттлинг / память по компонентам и ВМ, CPU на запрос в установившихся окнах, resources.csv / samples.csv, разделы summary.md; --selftest
failover.py # профиль failover без docker: строки k6 о запросах, статистика и журнал HAProxy, события Docker, посекундная шкала, величины фазы, summary.md
rollout.py # профиль rollout без docker: строки скрипта замены, события контейнеров проекта, состояния слотов LB (UP, drain, maint, ready), шаги по репликам, шкала со старыми и новыми ответами, окна до / во время / после, summary.md
bench.compose.yml # override стенда mtusi-bench: имена, BENCH_API_REPLICAS реплик api без container_name, haproxy с лимитами BENCH_LB_*, лимиты BENCH_* (deploy.resources), без портов и config.toml, auto_explain; s3 (лимиты BENCH_S3_*, swap = память) запускают профили uploads и reconcile, cleaner (mtusi-bench-cleaner, без порта, лимиты BENCH_CLEANER_* без swap) — только разовыми проходами профиля reconcile; буфер приёма реплики — sysctls основного compose
bench.env # подстановки compose стенда вместо .env рабочего стенда (без паролей и секретов S3: их генерирует run.py)
k6/ # сценарии k6 (через LB http://haproxy:8080): prepare (вход по Basic, фоновые чаты), prefill (по расписанию), cursors, plan_cursors (страницы плана фоновых чатов), explain, read, tail, write, after_backup и restore_check (этап восстановления), failover (постоянная интенсивность записи и чтения, строка на запрос) и retry (повтор неуспешных записей с тем же ключом), mixed (ступень серии трека 1: ramping-arrival-rate 70/20/10, тег окна, распределение по X-Instance-Id, досрочный выход), uploads (constant-vus загрузок тела из /work, пауза Retry-After на 429 и 1 с на прочие ошибки, строка на запрос, WARMUP — одна загрузка), background (профиль reconcile: constant-arrival-rate скачиваний, записи и чтения истории, строка bg на запрос, остановка SIGINT); lib.js — Bearer, messageHeaders (новый или заданный Idempotency-Key) и хелперы
k6/ # сценарии k6 (через LB http://haproxy:8080): prepare (вход по Basic, фоновые чаты), prefill (по расписанию), cursors, plan_cursors (страницы плана фоновых чатов), explain, read, tail, write, after_backup и restore_check (этап восстановления), failover (постоянная интенсивность записи и чтения, строка на запрос) и retry (повтор неуспешных записей с тем же ключом), mixed (ступень серии трека 1: ramping-arrival-rate 70/20/10, тег окна, распределение по X-Instance-Id, досрочный выход), uploads (constant-vus загрузок тела из /work, пауза Retry-After на 429 и 1 с на прочие ошибки, строка на запрос, WARMUP — одна загрузка), background (профили reconcile и queue: constant-arrival-rate скачиваний, записи и чтения истории, строка bg на запрос, остановка SIGINT), queue (окна constant-arrival-rate загрузок, VU заранее, ответ не повторяется, строка q на загрузку; WARM — разогрев) и queue_sweep (метаданные каждого принятого вложения, SHA-256 выборки, строки qs и qv); lib.js — Bearer, messageHeaders (новый или заданный Idempotency-Key) и хелперы
compare.py # make bench_compare: дельта двух меток (ячейки матрицы или общие конфигурации серий), уровень шума, эффект или шум; отказ при разной методике, в том числе метке без LB и серии против матрицы
ab.py # make bench_ab: прогоны «до» и «после» одного изменения подряд, с --series — серии трека 1
migrations/, alembic.ini # ревизии alembic, async env.py; применяет одноразовый сервис compose; 739b8f04d5fb — частичный индекс pending CONCURRENTLY в autocommit_block; 5c3e1f0a9b7d — attachments.lost_at (NULL, SET LOCAL lock_timeout); c7e2f1a04b56 — attempt_base и attachment_job_replays; d3f9a6b2c1e7 — индексы outbox, аренды и очистки staging CONCURRENTLY
@@ -657,6 +674,7 @@ evidence/bench/<метка>/ # результаты make bench / bench_rest
evidence/bench/scaling-*/ # серии трека 1 (a, b, pool, A/A scaling-aa, db — насыщение PostgreSQL; db4 — «до/после» пула без переполнения: scaling-db-aa*, -before*, -nooverflow*, окончательные — с суффиксом 2): паспорт с планом, бюджетом и лимитами по конфигурациям, runs.csv (строка на ступень), searches.csv (строка на ячейку), samples.csv (посекундно в окнах), summary.md, p95-by-rate.svg, cpu-by-component.svg, итоги k6 ступеней и журналы 5xx
evidence/plots/scaling/ # make bench_plots по сериям a и b: графики SVG и summary.md (R*, эффективность, точка насыщения, цена запроса, память)
evidence/plots/scaling-db/ # make bench_plots по серии db: R* по лимитам PostgreSQL и раздел «Насыщение PostgreSQL»
evidence/queue/<метка>/ # результаты make bench_queue (change track1-queue-overload): meta.json (классы, план, окна, app_env по конфигурациям), cells.csv, timeline.csv, summary.md (H1–H9, рекомендация), SVG, raw/ — итоги k6
evidence/uploads/ # change upload-memory: <метка>/ — make bench_uploads (meta.json, runs.csv, summary.md, raw/), lb-timeouts.md — driver.py lb-upload-timeouts, rollout-upload.md — медленная загрузка во время make rolling_update
evidence/bench/unit-of-work-*/ # change unit-of-work, профиль quick с именной меткой (идёт в git): before и aa на b2fb88f, after на 6ba74b1
evidence/rollout/unit-of-work*/ # change unit-of-work: unit-of-work (замена с Profile.rollout_from), unit-of-work-previous (--from b2fb88f: CPU на запрос старых и новых реплик)
+17
View File
@@ -400,6 +400,23 @@ bench_uploads:
bench_uploads_quick:
$(KEEP_AWAKE) uv run python bench/run.py --profile uploads_quick --label quick-uploads-$(shell date -u +%Y%m%dT%H%M%SZ)
# Очередь под перегрузкой (лаба 5, трек 1; design change track1-queue-overload):
# стенд mtusi-bench с S3, брокером, relay, worker и уборщиком, настройки
# конкуренции и prefetch × классы изображений × 3 повтора и блоки предела, приёма,
# второго worker и рестартов, на каждую ячейку — свежий стенд; ~2 ч 10 мин;
# результат — evidence/queue/$(QUEUE_LABEL)/. RESUME=1 — продолжить прерванную метку
# на том же commit
QUEUE_LABEL ?= baseline
.PHONY: bench_queue
bench_queue:
$(KEEP_AWAKE) uv run python bench/run.py --profile queue --label $(QUEUE_LABEL) $(if $(RESUME),--resume)
# то же коротко (самопроверка, защита): две настройки, предел с пределом 40 и без
# него, рестарт worker, второй worker, окна короче, ~11 мин; в git не идёт
.PHONY: bench_queue_quick
bench_queue_quick:
$(KEEP_AWAKE) uv run python bench/run.py --profile queue_quick --label quick-queue-$(shell date -u +%Y%m%dT%H%M%SZ)
RECONCILE_LABEL ?= baseline
# трек 2 «5» лабы 4: стоимость сверки bucket и БД на стенде mtusi-bench
+9
View File
@@ -42,6 +42,11 @@
`mtusi-rsig_postgres_data`, `mtusi-rsig_rabbitmq_data`, `mtusi-rsig_s3_data`.
Прогон их не удалял. Перед удалением убедиться, что контейнеров на них нет
(`docker ps -a --filter volume=<имя>`), затем `docker volume rm <имя>`.
- `make student_test` красный по `test_exclusion_evidence_exists` не только из-за
`evidence/queue/baseline/summary.md`: в репозитории нет и `evidence/auth/passwords-and-tokens.md`,
`evidence/cache/hits.md`, `evidence/idempotency/replay-after-restart.md` (их нет и на
`5b5f59a`; снимаются по AGENTS.md, «Переход в следующую лабу»). Стадия apply в `evidence/` не
пишет: снять перед отчётом.
- На хосте 150 анонимных volumes. Чьи они, не проверялось, часть может быть
чужой, поэтому `docker volume prune` без просмотра запускать не стоит.
- Остались volumes пробы стадии propose `track1-queue-overload`:
@@ -240,6 +245,10 @@
- **Worker в профиле очереди перезапускается, как на рабочем стенде (`restart: unless-stopped`):** пробы — при (4, 4) на `lp` ядро может убить и процесс 1 (журнал ядра, `exit 137`), и с `restart: "no"` ячейка простаивала бы с ложными `stuck`. Перезапуски — столбец и пометка (решение 10). У S3 остаётся `"no"`: его гибель должна быть видна.
- **Блок приёма — `m`, 15/с, 45 с, с пределом по умолчанию:** пробы показали всю цепочку: S3, с ~10-й секунды 429 от мест, с ~35-й 429 от предела, а готовых/с падает с 2,9 до ~0,6. S3 — общий ресурс приёма и worker: гипотеза H9 (решения 4, 8, 12).
- **Время полной метки — ~2 ч 10 мин** при трёх повторах 19 конфигураций, `RESUME=1` как у серий: окна выбраны по пробам так, чтобы уложиться (решение 14).
- **Apply: перезапуск worker считается завершением ядром, пометка `oom`:** счётчик `oom_kill` умершей жизни прочитать нельзя, cgroup уходит раньше тика. Другие причины аварийного выхода в метке от него не отличаются (design, «Уточнения apply», п. 1).
- **Apply: доля второго worker считается только по разбору накопленного,** без окна `after`: иначе H3 ложно не подтверждалась бы. Порог не менялся (там же, п. 2).
- **Apply: CPU окна — с интерполяцией на краях;** разность только по внутренним отсчётам занижала его на ~10 % (там же, п. 3).
- **Apply: блоки, которых нет в быстром профиле, проверены разово** скриптом в scratchpad поверх `run.main` (там же, п. 4).
### Вопросы
+55 -1
View File
@@ -321,6 +321,8 @@ CPU на успешный запрос при постоянных 200 запр
5. **Допустим ли на уровне 3 ответ 503 при недоступном брокере?** Закрыт уровнем 4: отказ брокера больше не даёт 503, на загрузке 503 только от S3 и PostgreSQL. На уровне 3 был 503: relay ещё не было.
6. **Контракт требует EXIF orientation и alpha на белый только у thumbnail. Как с `crop` и `optimized`?** Сделано: ориентация применяется у обоих (иначе EXIF, удалённый из WebP, повернул бы изображение), `crop` компонуется на белый (JPEG), `optimized` сохраняет прозрачность. Другой ответ правит одну функцию и сценарий.
7. **Контракт называет replay «явным операторским», но не говорит, как его вызывать.** Достаточно ли команды в контейнере? Сделано: `make replay`, HTTP-ручки нет: в API нет роли оператора. Другой ответ добавляет ручку поверх той же транзакции.
10. **Предел незавершённых заданий: 429 или 503?** Контракт называет 429 «ограничением частоты запросов», здесь ограничено количество принятой работы; 503 — «зависимость недоступна». Сделано: 429 `rate_limited` с `Retry-After: 5`, как у занятых мест: зависимости живы, реплика готова. Другой ответ меняет строку `DOMAIN_ERRORS` и сценарии.
11. **Как долго загрузка обязана отвечать 202 при остановленном worker?** Рубрика уровня 3 показывает «worker остановлен → upload 202», трек 1 требует ограничить принятую работу. Сделано: пока незавершённых меньше предела (250); дальше 429, а текст, история, метаданные, готовые байты и `/health/ready` работают. Другой ответ — значение настройки.
8. **Изображение, не уложившееся в лимиты времени или памяти обработки, — это `invalid_image` или отдельный код?** Сделано: `invalid_image`, точная причина — в записи для оператора. Другой ответ добавляет значение enum и требует обновить реплики раньше worker.
9. **Контракт требует retention «неуспешных и непривязанных исходников», но молчит о конечных объектах, которые успела записать неудачная попытка.** Сделано: по истечении срока удаляются и они, метаданные `failed` остаются. Другой ответ убирает один шаг очистки.
@@ -429,7 +431,7 @@ CPU на успешный запрос при постоянных 200 запр
### Трек 1 уровня 5
Не закрыт на этом шаге: закрывает change `track1-queue-overload`.
Change `track1-queue-overload`: предел принятой работы и профиль `make bench_queue` реализованы, гипотезы — раздел «Очередь под перегрузкой»; метка `baseline` и выводы по ней — следующий шаг.
## Эксперименты и отказы
@@ -477,6 +479,58 @@ CPU API на запрос до и после замены у `unit-of-work`: 308
H1 (пик ограничен местами) и H4 (нет 503 по сроку S3) выполнены. H2 в сводке — «нет»: вариант «до» теперь `04f8592`, где места уже есть, поэтому прежнее поведение он не показывает; настоящее «до» — отчёт лабы 4. H3 в сводке — «нет»: на 1 MiB «с лимитом» даёт 85–89 % «без лимита» при пороге 90 %, на 10 MiB — 117–121 %. Память приёма после перехода на брокер в границах прежних сценариев спека: ~185 MiB из 512 при 40 клиентах.
### Очередь под перегрузкой
Трек 1 уровня 5, change `track1-queue-overload`. Гипотезы и правило записаны и закоммичены раньше первой метки; числа метки появятся ниже, когда она будет снята (`evidence/queue/baseline/summary.md`). Числа порогов — из проб стадии propose (design, раздел «Пробы»): это пробы, а не результат.
**Команда:** `make bench_queue` (метка `baseline`, ~2 ч 10 мин, `RESUME=1`), самопроверка — `make bench_queue_quick` (~11 мин, метка в git не идёт).
**Методика.** Стенд `mtusi-bench`: LB, две реплики API 1 CPU / 512 МБ, PostgreSQL 2 CPU / 1 ГБ, Valkey, S3 1 CPU / 512 МБ, брокер 1 CPU / 512 МБ, relay 0,25 CPU / 256 МБ, worker 1 CPU / 1 ГБ, уборщик 0,25 CPU / 256 МБ — лимиты рабочего стенда, без swap; у worker — `restart: unless-stopped`, как на рабочем стенде. Каждая ячейка — свежий стенд на новых volume.
- **Настройки** (конкуренция, prefetch): (1, 1), (2, 2) — значения по умолчанию, (4, 4), (2, 256).
- **Классы:** `s` — JPEG 1600 × 1200, q85, ~0,5 MiB; `m` — PNG из шума ~3,5 Мпкс, ~10 MiB; `lj` — JPEG 8000 × 5000, q88, ~8,6 MiB; `lp` — PNG RGBA 8000 × 5000, значащие 4 бита на канал, ~10 MiB. Файлы детерминированы от зерна, размеры и SHA-256 — в паспорте.
- **Матрица:** (2, 2) и (4, 4) на всех классах; (1, 1) на `m` и `lp`; (2, 256) на `s` и `lp`, по три повтора, круги с перестановкой от зерна; план — в паспорте до первой ячейки.
- **Интенсивность** одна на класс для всех настроек, низкая / высокая, загрузок/с: `s` 1,5 / 8, `m` 1,5 / 6, `lj` 1,2 / 6, `lp` 0,5 / 2,5. Открытая модель (`constant-arrival-rate`), ответ не повторяется: 429 — отказ.
- **Окна:** `before` 10 с низкой λ; `over` 20 с высокой (блоки предела и рестартов — 25 с, приёма — 45 с); `recovery` — до нуля незавершённых, не дольше 420 с; `after` 10 с низкой λ.
- **Контрольный поток** всё время: запись 10/с, чтение истории 10/с, скачивание готовых 5/с.
- **Блоки:** `gate-on` и `gate-off` — `s`, (2, 2), 20/с, предел по умолчанию и выключен; `accept` — `m`, (2, 2), 15/с, 45 с; `w2-p2`, `w2-p256` — второй worker в конце `over`; `kill-worker` — KILL и запуск посреди `over`; `restart-broker` — `compose restart` посреди `over`.
- **Шум:** разброс — min–max трёх повторов. Разница двух конфигураций считается эффектом, только если их разбросы не пересекаются и разница медиан больше наибольшего разброса пары; иначе «в пределах шума». Отдельной метки A/A нет: настройка по умолчанию повторяется в каждом круге.
**Определения.**
| Что | Как считается | Откуда |
|---|---|---|
| Очередь, `outbox` | `queued`, не опубликовано, срок наступил | PostgreSQL |
| `waiting` | `queued`, не опубликовано, срок не наступил: пауза следующей попытки | PostgreSQL |
| `published` | `queued`, брокер подтвердил, никто не взял | PostgreSQL |
| `broker_ready`, `broker_unacked` | сообщения в очереди брокера и выданные, не подтверждённые | метрики брокера |
| `processing` | взято, идёт аренда | PostgreSQL |
| `prefetched` | `max(0, broker_unacked − processing)`: у worker, ждёт места конкуренции | вычисляется |
| `unfinished` | `outbox + waiting + published + processing`: то, что считает предел | PostgreSQL |
| `oldest_s` | возраст старейшего незавершённого | PostgreSQL |
| Throughput | вложений с `updated_at` статуса `ready` в окне `over` и в окне `recovery`, делённые на длину окна | `GET /attachments/{id}` |
| Время до `ready` | `updated_at` у `ready` минус момент ответа 202; p50, p95, p99 по окну прихода; `before` и `after` — повторы сводятся вместе | `GET /attachments/{id}`, k6 |
| Восстановление | от последней загрузки окна `over` до нуля незавершённых | k6, PostgreSQL |
| RSS | `VmHWM` процесса 1 worker, `render_peak_kib` процесса обработки (p50, наибольший), `memory.peak`, наибольшая `anon`, `oom_kill`; у перезапущенного контейнера — наибольшее и сумма по жизням | `/proc`, журнал, cgroup |
**Гипотезы.**
| № | Гипотеза | Подтверждено, если |
|---|---|---|
| H1 | Потолок при 1 CPU — CPU worker; конкуренция сверх двух его не поднимает | на всех классах медиана throughput окна `recovery` (4, 4) / (2, 2) ≤ 1,05; CPU worker в окне `over` при c ≥ 2 ≥ 0,85 ядра; на `m` и `lp` (1, 1) / (2, 2) ≤ 1,0 |
| H2 | Обработка задания дольше пропорционально конкуренции, память растёт на пик процесса | `duration_ms` p50 (4, 4) / (2, 2) ≥ 1,5 на всех классах; `memory.peak` (2, 2) < 1 ГБ без `oom` на всех классах; (4, 4) на `lp`: `memory.peak` ≥ 95 % лимита во всех повторах, `oom_kill` > 0 хотя бы в одном; (4, 4) на `lj`: без `oom`, пик ≤ 500 МиБ |
| H3 | Большой prefetch не меняет throughput одного worker и прячет очередь от брокера и второго worker | (2, 256) / (2, 2): throughput в [0,85; 1,15], p95 до `ready` в [0,8; 1,25] на `s` и `lp`; пик `broker_ready` ≤ 10 % пика незавершённых у (2, 256), ≥ 70 % у (2, 2); блок второго worker: доля второго среди заданий, завершённых после его запуска, ≥ 30 % при `prefetch` 2 и ≤ 5 % при 256, восстановление p256 / p2 ≥ 1,4 |
| H4 | Задержка под перегрузкой — это очередь | на всех ячейках матрицы без `oom` p95 до `ready` окна `over` в [0,8; 1,25] × пик незавершённых / throughput |
| H5 | Предел ограничивает принятую работу и срок ожидания | `gate-on`: пик незавершённых ≤ 290, 429 > 0, у всех `Retry-After` 5, 5xx нет, 429 = записи `backlog`; `gate-off`: пик ≥ 375; `gate-on` / `gate-off`: p95 до `ready` и восстановление ≤ 0,75; p95 до `ready` `gate-on` в [0,8; 1,25] × предел / throughput; загрузка `before` p50 `gate-on` − `gate-off` ≤ 3 мс |
| H6 | Восстановление: система приходит в норму сама и никого не теряет | во всех ячейках `lost`, `stuck`, `duplicate`, `sha_mismatch` нет; восстановление ≤ 1,3 × пик незавершённых / throughput окна `over` (матрица без `oom`, предел); p95 `after` ≤ 1,5 × p95 `before` по конфигурации; `failed` только при `oom` и только `retry_exhausted` |
| H7 | Перегрузка очереди не задевает остальной API | во всех окнах всех ячеек, кроме `accept`: p95 записи и чтения ≤ 200 мс, скачивания ≤ 500 мс; 5xx контрольного потока нет; `lb_down` нет |
| H8 | Рестарты под перегрузкой не теряют работу | `kill-worker`: всё `ready`, заданий с повторной попыткой ≤ 2, очередь разобрана не позже большего из «конец `over` + 1,3 × пик / throughput» и «KILL + аренда 70 с + 15 с»; `restart-broker`: всё `ready`, заданий с повторной попыткой нет, 5xx на загрузке нет, восстановление ≤ 1,3 × пик / throughput + 15 с |
| H9 | Приём ограничен S3, местами и затем пределом, а не падением; S3 общий с worker | `accept`: первый 429 `busy` раньше первого `backlog`, оба есть, 5xx нет; CPU S3 в первые 30 с окна ≥ 0,85; принято за окно / длина окна ≥ 6/с; пик незавершённых ≤ 290; готовых/с в окне ≤ 1,5 при ≥ 2,4 в окне восстановления; контрольный поток: запись и чтение p95 ≤ 200 мс, скачивание ≤ 1 с, без 5xx |
Вердикт считает `bench/overload.py` в сводке метки: «подтверждено», «нет», «нет данных».
**Правило рекомендации.** Кандидат — настройка без `oom` и `failed` ни на одном классе, с throughput не ниже 90 % лучшей на каждом классе; из кандидатов — наименьшая конкуренция, а `prefetch` равен конкуренции. Значения по умолчанию меняются, только если рекомендация отличается от (2, 2), и выигрыш по throughput или памяти на каком-либо классе вне шума при том, что на остальных она не хуже в пределах шума; такая правка — отдельный commit после метки с повтором `make bench_queue_quick`. Компромисс latency и ресурсов — вывод из таблиц метки; проверяемая формула: `concurrency ≤ min(CPU + доля ожидания, (лимит − база) / пик процесса)`.
### Отказы
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
+113
View File
@@ -0,0 +1,113 @@
// Профиль очереди (design change track1-queue-overload, решение 6): открытая
// модель загрузок через LB. Окна — сценарии constant-arrival-rate, timeUnit 10 с
// для дробной интенсивности; VU заранее и без прибавления: тело — open на VU,
// создание на ходу с телом 10 MiB теряет итерации. Ответ не повторяется: 429 —
// отказ, недосланные итерации — dropped_iterations. Строка на загрузку
// «q,<окно>,<отправка мс>,<длительность мс>,<статус>,<Retry-After>,<X-Instance-Id>,
// <id>» — в файл консоли (--console-output); setup() пишет «q-t0,<мс>». WINDOWS —
// «имя:интенсивность:секунды:VU», окна идут подряд; WARM=N — N загрузок подряд.
import exec from "k6/execution";
import http from "k6/http";
import {
API,
SUMMARY_THRESHOLDS,
SUMMARY_TREND_STATS,
WORK_DIR,
summaryFiles,
} from "./lib.js";
const fixture = JSON.parse(open(`${WORK_DIR}/fixture.json`));
const BODY = open(`${WORK_DIR}/${__ENV.BODY}`, "b");
const MEDIA = __ENV.MEDIA;
const WARM = Number(__ENV.WARM || 0);
const WINDOWS = (__ENV.WINDOWS || "")
.split(",")
.filter((item) => item !== "")
.map((item) => {
const [name, rate, seconds, vus] = item.split(":");
return {
name,
rate: Number(rate),
seconds: Number(seconds),
vus: Number(vus),
};
});
// больше timeout server LB пути загрузки (30 с): клиент видит ответ LB
const TIMEOUT = "60s";
const URL = `${API}/chats/${fixture.readChatId}/attachments?filename=bench`;
const HEADERS = {
Authorization: `Bearer ${fixture.tokens[fixture.readerId]}`,
"Content-Type": MEDIA,
};
function scenarios() {
if (WARM) {
return {
warm: { executor: "shared-iterations", vus: 1, iterations: WARM },
};
}
const out = {};
let start = 0;
for (const item of WINDOWS) {
out[item.name] = {
executor: "constant-arrival-rate",
rate: Math.round(item.rate * 10),
timeUnit: "10s",
startTime: `${start}s`,
duration: `${item.seconds}s`,
preAllocatedVUs: item.vus,
maxVUs: item.vus,
gracefulStop: "45s",
};
start += item.seconds;
}
return out;
}
export const options = {
scenarios: scenarios(),
summaryTrendStats: SUMMARY_TREND_STATS,
// порог всегда выполняется: итерации попадают в итог, run.py сверяет с ними
// число строк
thresholds: {
...SUMMARY_THRESHOLDS,
iterations: ["count>=0"],
dropped_iterations: ["count>=0"],
},
};
export function setup() {
const t0 = Date.now();
console.log(`q-t0,${t0}`);
return t0;
}
export default function () {
const start = Date.now();
const res = http.post(URL, BODY, {
headers: HEADERS,
timeout: TIMEOUT,
responseCallback: http.expectedStatuses(202, 429),
});
const t = res.timings;
const measured = t.blocked + t.connecting + t.tls_handshaking + t.duration;
const duration = Math.max(
0,
Math.round(res.status === 0 ? Date.now() - start : measured),
);
let id = "-";
if (res.status === 202) {
id = res.json("id");
}
const retry = res.headers["Retry-After"] || "-";
const instance = res.headers["X-Instance-Id"] || "-";
console.log(
`q,${exec.scenario.name},${start},${duration},${res.status},${retry},` +
`${instance},${id}`,
);
}
export function handleSummary(data) {
return summaryFiles(data);
}
+81
View File
@@ -0,0 +1,81 @@
// Обход принятых вложений профиля очереди (design change track1-queue-overload,
// решение 9): истина о готовности — метаданные GET /attachments/{id}, опрос в
// замере не нужен: updated_at у ready не меняется после фиксации. Строка на
// вложение «qs,<id>,<http>,<status>,<error_code>,<variants>,<updated_at>»; у
// выборки (первые SAMPLE ids, порядок задал оркестратор от зерна) — оригинал и
// варианты с SHA-256 из метаданных: «qv,<id>,<имя>,<1|0>».
import { sha256 } from "k6/crypto";
import exec from "k6/execution";
import http from "k6/http";
import { SharedArray } from "k6/data";
import { API, WORK_DIR, authHeaders, summaryFiles } from "./lib.js";
const fixture = JSON.parse(open(`${WORK_DIR}/fixture.json`));
const ids = new SharedArray("ids", () =>
JSON.parse(open(`${WORK_DIR}/${__ENV.IDS}`)),
);
const SAMPLE = Number(__ENV.SAMPLE || 10);
const READER = authHeaders(fixture.tokens[fixture.readerId]);
const VARIANTS = ["thumbnail", "crop", "optimized"];
export const options = {
scenarios: {
sweep: {
executor: "shared-iterations",
vus: 4,
iterations: Math.max(1, ids.length),
maxDuration: "10m",
},
},
thresholds: { iterations: ["count>=0"] },
};
function checkBytes(id, name, expected) {
const query = name === "original" ? "" : `?variant=${name}`;
const res = http.get(`${API}/attachments/${id}/content${query}`, {
headers: READER,
responseType: "binary",
timeout: "60s",
});
let good = 0;
if (res.status === 200) {
good = sha256(res.body, "hex") === expected ? 1 : 0;
}
console.log(`qv,${id},${name},${good}`);
}
export default function () {
const index = exec.scenario.iterationInTest;
if (index >= ids.length) {
return;
}
const id = ids[index];
const res = http.get(`${API}/attachments/${id}`, {
headers: READER,
timeout: "30s",
responseCallback: http.expectedStatuses(200, 404),
});
if (res.status !== 200) {
console.log(`qs,${id},${res.status},-,-,0,-`);
return;
}
const meta = res.json();
const variants = meta.variants || [];
console.log(
`qs,${id},200,${meta.status},${meta.error_code || "-"},` +
`${variants.length},${meta.updated_at}`,
);
if (index < SAMPLE && meta.status === "ready") {
checkBytes(id, "original", meta.sha256);
for (const item of variants) {
if (VARIANTS.includes(item.name)) {
checkBytes(id, item.name, item.sha256);
}
}
}
}
export function handleSummary(data) {
return summaryFiles(data);
}
+161
View File
@@ -0,0 +1,161 @@
"""Файлы классов профиля очереди (design change `track1-queue-overload`,
решение 5): `s`, `m`, `lj`, `lp`, детерминированно от зерна.
Только в контейнере `mtusi-bench-images` на образе стенда: Pillow образа и та же
его версия, что у процесса обработки; `src` не импортируется. На stdout — JSON с
размерами, пикселями и SHA-256; файл больше лимита контракта — код 1.
python make_images.py <зерно> <каталог>
"""
import hashlib
import io
import json
import random
import sys
from pathlib import Path
from PIL import Image, ImageChops
from uploads import png_noise
MAX_BYTES = 10_485_760
MAX_PIXELS = 40_000_000
LARGE = (8000, 5000)
SMALL = (1600, 1200)
NOISE_HEIGHT = 3409
CELLS_LOW = 64
CELLS_HIGH = 512
FINE_DIVISOR = 6
TILE = 512
AMPLITUDE = 24
POSTERIZE_MASK = 0xF0
def noise_l(width: int, height: int, seed: int) -> Image.Image:
data = random.Random(seed).randbytes(width * height)
return Image.frombytes("L", (width, height), data)
def clouds(
width: int,
height: int,
seed: int,
cells: int = CELLS_LOW,
) -> Image.Image:
"""Гладкое поле из шума низкого разрешения: низкие частоты фото."""
return noise_l(cells, max(2, cells * height // width), seed).resize(
(width, height),
Image.Resampling.BICUBIC,
)
def detail_tile(
width: int,
height: int,
seed: int,
amplitude: int,
) -> Image.Image:
"""Плитка шума амплитуды `amplitude`, повторённая на всё поле."""
tile = noise_l(TILE, TILE, seed).point(lambda v: v * amplitude // 255)
field = Image.new("L", (width, height))
for y in range(0, height, TILE):
for x in range(0, width, TILE):
field.paste(tile, (x, y))
return field
def bands(
width: int,
height: int,
seed: int,
amplitude: int,
) -> list[Image.Image]:
out = []
for number in range(3):
band = ImageChops.add(
clouds(width, height, seed + number),
clouds(
width,
height,
seed + 10 + number,
cells=CELLS_HIGH,
).point(lambda v: v // FINE_DIVISOR),
)
if amplitude:
band = ImageChops.add(
band,
detail_tile(width, height, seed + 20 + number, amplitude),
)
out.append(band)
return out
def jpeg(image: Image.Image, quality: int) -> bytes:
out = io.BytesIO()
image.save(out, format="JPEG", quality=quality, subsampling="4:2:0")
return out.getvalue()
def build_s(seed: int) -> bytes:
return jpeg(Image.merge("RGB", bands(*SMALL, seed, AMPLITUDE)), 85)
def build_lj(seed: int) -> bytes:
return jpeg(Image.merge("RGB", bands(*LARGE, seed + 200, AMPLITUDE)), 88)
def build_lp(seed: int) -> bytes:
colour = [
band.point(lambda v: v & POSTERIZE_MASK)
for band in bands(*LARGE, seed + 200, 0)
]
alpha = clouds(*LARGE, seed + 300).point(
lambda v: (128 + v // 2) & POSTERIZE_MASK,
)
out = io.BytesIO()
Image.merge("RGBA", (*colour, alpha)).save(
out,
format="PNG",
compress_level=6,
)
return out.getvalue()
def build_m(seed: int) -> bytes:
return png_noise(NOISE_HEIGHT, seed + NOISE_HEIGHT)
BUILDERS = {
"s": (build_s, "s.jpg", "image/jpeg"),
"m": (build_m, "m.png", "image/png"),
"lj": (build_lj, "lj.jpg", "image/jpeg"),
"lp": (build_lp, "lp.png", "image/png"),
}
def main() -> int:
seed, directory = int(sys.argv[1]), Path(sys.argv[2])
report = {}
code = 0
for name, (build, filename, media) in BUILDERS.items():
data = build(seed)
with Image.open(io.BytesIO(data)) as image:
width, height = image.size
(directory / filename).write_bytes(data)
report[name] = {
"file": filename,
"media_type": media,
"bytes": len(data),
"width": width,
"height": height,
"sha256": hashlib.sha256(data).hexdigest(),
}
if len(data) > MAX_BYTES or width * height > MAX_PIXELS:
print(f"{name}: over the contract limit", file=sys.stderr)
code = 1
print(json.dumps(report))
return code
if __name__ == "__main__":
sys.exit(main())
+2173
View File
File diff suppressed because it is too large Load Diff
+21
View File
@@ -0,0 +1,21 @@
# Override профиля очереди (третий -f, только этот профиль; design change
# track1-queue-overload, решение 10). Плагин метрик брокера и интервал
# статистики в секунду: порт 15692 — только сеть стенда, порты брокера сброшены
# в bench.compose.yml. Worker перезапускается, как на рабочем стенде: ядро может
# завершить его процесс 1, когда конкуренция не помещается в лимит памяти, и без
# перезапуска ячейка простояла бы до срока окна с ложными stuck. Пути — от
# каталога первого файла compose (корень репозитория)
services:
rabbitmq:
volumes:
- type: bind
source: ./bench/rabbitmq/enabled_plugins
target: /etc/rabbitmq/enabled_plugins
read_only: true
- type: bind
source: ./bench/rabbitmq/91-bench.conf
target: /etc/rabbitmq/conf.d/91-bench.conf
read_only: true
worker:
restart: unless-stopped
+2
View File
@@ -0,0 +1,2 @@
# Профиль очереди: значения метрик свежие за секунду (проба: 4,7 мс CPU на опрос)
collect_statistics_interval = 1000
+1
View File
@@ -0,0 +1 @@
[rabbitmq_prometheus].
+1085 -13
View File
File diff suppressed because it is too large Load Diff
+73 -3
View File
@@ -34,6 +34,14 @@
# `pk <нс> <роль> <id12> missing`. Появился /work/<имя>.stop — perl
# читает пик через тот же дескриптор (`peak <роль> <байт>|missing`),
# строка `end <нс>`, выход 0. Всё — в /work/<имя>.log.
# queue (профиль очереди, design change track1-queue-overload, решение 10):
# <интервал, с> queue <имя очереди>
# Сеть mtusi-bench. Обход cgroup, как scan (`cg`), `vm`, `lb`; ещё `mp <нс>
# <id12> <memory.peak> <anon> <oom_kill>` на контейнер и `mq <нс> <ready>
# <unacked>` — метрики брокера HTTP/1.0 по /dev/tcp (брокер недоступен —
# `mq <нс> missing`). В фоне psql с \watch пишет /work/jobs.log (одно
# соединение): jobs|<мс>|outbox|waiting|published|processing|oldest_s|
# staging_ready. Разбор — bench/overload.py.
set -u
interval=$1
@@ -42,6 +50,10 @@ mode=list
if [[ ${1:-} == scan ]]; then
mode=scan
shift
elif [[ ${1:-} == queue ]]; then
mode=queue
queue_name=$2
shift 2
elif [[ ${1:-} == peak ]]; then
mode=peak
name=$2
@@ -83,6 +95,25 @@ FROM pg_stat_io WHERE object = 'wal'
SQL
fi
if [[ $mode == queue ]]; then
export PGPASSWORD="$POSTGRES_PASSWORD"
psql "host=postgres user=$POSTGRES_USER dbname=$POSTGRES_DB \
application_name=bench-sampler" -XAtq -F '|' >/work/jobs.log 2>&1 <<SQL &
SELECT 'jobs', (extract(epoch FROM clock_timestamp()) * 1000)::bigint,
count(*) FILTER (WHERE state = 'queued' AND published_at IS NULL
AND coalesce(next_attempt_at, created_at) <= clock_timestamp()),
count(*) FILTER (WHERE state = 'queued' AND published_at IS NULL
AND coalesce(next_attempt_at, created_at) > clock_timestamp()),
count(*) FILTER (WHERE state = 'queued' AND published_at IS NOT NULL),
count(*) FILTER (WHERE state = 'processing'),
coalesce(round(extract(epoch FROM clock_timestamp() - min(created_at))::numeric, 1), 0),
(SELECT count(*) FROM attachments
WHERE status = 'ready' AND staging_key IS NOT NULL)
FROM attachment_jobs WHERE state IN ('queued', 'processing')
\watch $interval
SQL
fi
if [[ $mode == peak ]]; then
log=/work/$name.log
stop=/work/$name.stop
@@ -219,16 +250,54 @@ lb_lines() {
exec 3<&-
}
mp_line() {
local id=$1 dir=/sys/fs/cgroup/docker/$1
local key val peak= anon= oom=
{
read -r peak <"$dir/memory.peak"
while read -r key val; do
[[ $key == anon ]] && { anon=$val; break; }
done <"$dir/memory.stat"
while read -r key val; do
[[ $key == oom_kill ]] && oom=$val
done <"$dir/memory.events"
} 2>/dev/null
[[ -n $peak && -n $anon && -n $oom ]] &&
printf 'mp %s %s %s %s %s\n' "$ns" "${id:0:12}" "$peak" "$anon" "$oom" >&4
}
mq_line() {
local line ready= unacked=
if ! exec 3<>/dev/tcp/rabbitmq/15692 2>/dev/null; then
printf 'mq %s missing\n' "$ns" >&4
return
fi
printf 'GET /metrics/detailed?vhost=%%2F&family=queue_coarse_metrics HTTP/1.0\r\nHost: x\r\n\r\n' >&3
while IFS= read -r line; do
line=${line%$'\r'}
case $line in
rabbitmq_detailed_queue_messages_ready\{*"$queue_name"*) ready=${line##* } ;;
rabbitmq_detailed_queue_messages_unacked\{*"$queue_name"*) unacked=${line##* } ;;
esac
done <&3
exec 3<&-
# очередь ещё не объявлена — нули, а брокер отвечает
printf 'mq %s %s %s\n' "$ns" "${ready:-0}" "${unacked:-0}" >&4
}
hex64='^[0-9a-f]{64}$'
while :; do
# EPOCHREALTIME bash 5 — часы ВМ без запуска date
ns=${EPOCHREALTIME/./}000
if [[ $mode == scan ]]; then
if [[ $mode == scan || $mode == queue ]]; then
for dir in /sys/fs/cgroup/docker/*/; do
dir=${dir%/}
id=${dir##*/}
[[ $id =~ $hex64 ]] && cg_line - "$id"
if [[ $id =~ $hex64 ]]; then
cg_line - "$id"
[[ $mode == queue ]] && mp_line "$id"
fi
done
else
for i in "${!ids[@]}"; do
@@ -236,6 +305,7 @@ while :; do
done
fi
vm_line
[[ $mode == list ]] && lb_lines
[[ $mode == list || $mode == queue ]] && lb_lines
[[ $mode == queue ]] && mq_line
sleep "$interval"
done
+4
View File
@@ -93,6 +93,10 @@ max_waiting = 16
wait_timeout_seconds = 5
# секунды на всё тело с момента, как загрузка заняла место; иначе 400
body_timeout_seconds = 30
# незавершённых заданий стенда (queued и processing), при которых загрузка
# сразу получает 429 rate_limited с Retry-After: 5; 0 — без предела. Срок
# ожидания = предел / потолок worker; при другом числе worker предел другой
max_unfinished_jobs = 250
[cleaner]
# Уборщик незавершённых загрузок (сервис compose cleaner); реплики API
@@ -419,6 +419,17 @@ CPU — снимок `docker stats`. Очередь и задержка согл
3. Откат: `make rolling_update COMMIT=<прежний> MIGRATE=0`. Данные не менялись.
4. После проб в scratchpad остаётся `track1/` (кандидаты, скрипты, журналы). Контейнеры, сети и образы проекта `q1probe` удалены. Остались его volumes `q1probe_postgres_data`, `q1probe_rabbitmq_data`, `q1probe_s3_data`: при уборке автопроверка отказала в команде с `docker compose … down -v`, обход не применялся; удалить вручную — `QUESTIONS.md`, «Для пользователя после прогона».
## Уточнения apply
1. **`oom_kill` — сумма по жизням плюс перезапуски.** На `make bench_queue_quick` (`lp`, (4, 4)) контейнер перезапустился, а счётчик показал 0: ядро завершает процесс 1, cgroup уходит раньше следующего тика, и прочитать счётчик умершей жизни нельзя. Перезапуск по политике `unless-stopped` бывает только при аварийном выходе, `docker kill` блока `kill-worker` демон считает ручной остановкой, поэтому перезапуск считается завершением ядром, и ячейка получает `oom`. Причина перезапуска в метке не проверяется отдельно: `.State.OOMKilled` после нового старта сброшен.
2. **Доля второго worker — только разбор накопленного:** от его запуска до нуля незавершённых. Окно `after` приходит после разбора и делится поровну при любом `prefetch`; с ним доля при `prefetch` 256 была 6,7 % при нуле заданий из бэклога, и H3 ложно не подтверждалась бы. Порог H3 (≤ 5 %) не менялся, уточнено только, какие задания считаются, — как и сказано в таблице решения 8: «второй берёт 0 заданий».
3. **CPU за окно — с линейной интерполяцией на краях.** Разность только по отсчётам внутри окна при тике ~1,1 с занижала CPU на ~10 %, и H1 на 10-секундном окне давала 0,84 вместо ~0,95. Порог H1 не менялся.
4. **Прокрутка блоков до метки:** в `queue_quick` нет `accept`, `restart-broker` и `w2-p2`, поэтому они один раз проверены скриптом в scratchpad поверх `run.main` с подменённым набором конфигураций (метка `quick-queue-blocks-*`, в git не идёт). Изменений в инструментах это не требует.
5. **`second_jobs`** — столбец решения 8; `broker_refused` — число проходов relay с неподтверждёнными сообщениями: так сработавший предел памяти виден в метке без разбора текста журнала.
6. **Журнал пятого API в тесте:** добавлено действие hook `backlog-api-log`, которого нет в задаче 4.2: сценарий «журнал реплики называет отказ» и запись о старте проверяются в `test_backlog_limit`, как обещает раздел «Покрытие сценариев».
7. **Красное в `make student_test` шире, чем ждёт задача 7.2:** `test_exclusion_evidence_exists` называет не только `evidence/queue/baseline/summary.md`, но и `evidence/auth/passwords-and-tokens.md`, `evidence/cache/hits.md`, `evidence/idempotency/replay-after-restart.md`. Их нет и на `5b5f59a`: не следствие этого change. Стадия apply в `evidence/` не пишет, снять их — до отчёта (`QUESTIONS.md`, «Для пользователя после прогона»).
## Open Questions
Вопросы преподавателю — `QUESTIONS.md`, раздел `track1-queue-overload`: ни один не меняет подход и задачи; другой ответ меняет строку таблицы ошибок и сценарий.
+29 -29
View File
@@ -14,112 +14,112 @@
## 1. Настройка и ответ 429
- [ ] 1.1 `Uploads.max_unfinished_jobs: int = Field(default=250, ge=0)` с комментарием (`src/config/settings.py`), строка в `config_example.toml` (`[uploads]`), `uploads_max_unfinished_jobs` в записи «Started API» (`src/main.py`).
- [x] 1.1 `Uploads.max_unfinished_jobs: int = Field(default=250, ge=0)` с комментарием (`src/config/settings.py`), строка в `config_example.toml` (`[uploads]`), `uploads_max_unfinished_jobs` в записи «Started API» (`src/main.py`).
Проверка: `uv run python -c "from src.config import settings; print(settings.uploads.max_unfinished_jobs)"` — 250; `UPLOADS__MAX_UNFINISHED_JOBS=-1` — ошибка проверки с именем поля.
- [ ] 1.2 Константа `UPLOAD_BACKLOG_RETRY_AFTER_SECONDS = 5` с обоснованием решения 2 (`src/utils/constants.py`), `UploadBacklogFull` (`src/core/exceptions/attachment.py`, реэкспорт), строки в `DOMAIN_ERRORS` и `RETRY_AFTER` (`src/api/errors.py`).
- [x] 1.2 Константа `UPLOAD_BACKLOG_RETRY_AFTER_SECONDS = 5` с обоснованием решения 2 (`src/utils/constants.py`), `UploadBacklogFull` (`src/core/exceptions/attachment.py`, реэкспорт), строки в `DOMAIN_ERRORS` и `RETRY_AFTER` (`src/api/errors.py`).
Проверка: тест задачи 3.2 видит 429 `rate_limited` и `Retry-After: 5`; `make service_test`.
## 2. Счёт незавершённых
- [ ] 2.1 `count_unfinished(*, limit: int) -> int` по решению 3: порт с докстрингом-контрактом («сумма не меньше `limit` тогда и только тогда…»), `SqlAlchemyAttachmentJobRepository` — сумма трёх `SELECT count(*) FROM (SELECT … LIMIT :limit)` по условиям трёх частичных индексов, состояния `literal_execute`, один `execute`; фейк в `service-tests/fakes/repos.py`.
- [x] 2.1 `count_unfinished(*, limit: int) -> int` по решению 3: порт с докстрингом-контрактом («сумма не меньше `limit` тогда и только тогда…»), `SqlAlchemyAttachmentJobRepository` — сумма трёх `SELECT count(*) FROM (SELECT … LIMIT :limit)` по условиям трёх частичных индексов, состояния `literal_execute`, один `execute`; фейк в `service-tests/fakes/repos.py`.
Проверка: `service-tests/unit/test_architecture.py` зелёный; `EXPLAIN` на базе стенда — три Index Only Scan по `ix_attachment_jobs_outbox`, `ix_attachment_jobs_published`, `ix_attachment_jobs_lease`, без Seq Scan.
- [ ] 2.2 `check_count_unfinished` в `service-tests/repo_contract.py`: `queued` без отметки, с отметкой и со сроком, `processing` считаются; `succeeded` и `failed` — нет; решение «не меньше предела» верно при счётах ниже, на и выше предела, в том числе когда одна группа больше предела. Строка `count_unfinished` в `test_status_is_a_constant_in_statement`.
- [x] 2.2 `check_count_unfinished` в `service-tests/repo_contract.py`: `queued` без отметки, с отметкой и со сроком, `processing` считаются; `succeeded` и `failed` — нет; решение «не меньше предела» верно при счётах ниже, на и выше предела, в том числе когда одна группа больше предела. Строка `count_unfinished` в `test_status_is_a_constant_in_statement`.
Проверка: `make service_test`, `make service_test_db`.
## 3. Сервис загрузки
- [ ] 3.1 `AttachmentService.upload` по решению 3: 415, 413 и счёт — в первом блоке единицы работы, после `require_member`; при `max_unfinished_jobs == 0` запроса нет; `info` «Rejected attachment» `reason=backlog`, `unfinished`, `limit`; докстринг — новый порядок. `_store` и места — без изменений.
- [x] 3.1 `AttachmentService.upload` по решению 3: 415, 413 и счёт — в первом блоке единицы работы, после `require_member`; при `max_unfinished_jobs == 0` запроса нет; `info` «Rejected attachment» `reason=backlog`, `unfinished`, `limit`; докстринг — новый порядок. `_store` и места — без изменений.
Проверка: `make lint`; `driver.py lb-upload-timeouts` — без изменений (цепочка та же).
- [ ] 3.2 Быстрые тесты `service-tests/unit/test_attachment_service.py`: у предела — `UploadBacklogFull`, тело не читается, место не занято, строк и объектов нет; ниже предела и при 0 — загрузка идёт; при 0 метод не вызывается (`database.events`); порядок: посторонний, тип и `Content-Length` раньше предела. `settings.uploads.max_unfinished_jobs` — в `fixed_settings` `unit/conftest.py`.
- [x] 3.2 Быстрые тесты `service-tests/unit/test_attachment_service.py`: у предела — `UploadBacklogFull`, тело не читается, место не занято, строк и объектов нет; ниже предела и при 0 — загрузка идёт; при 0 метод не вызывается (`database.events`); порядок: посторонний, тип и `Content-Length` раньше предела. `settings.uploads.max_unfinished_jobs` — в `fixed_settings` `unit/conftest.py`.
Проверка: `make service_test` — зелёный; временная регрессия (убрать проверку) делает новые тесты красными.
## 4. Проверки отказов
- [ ] 4.1 `student-tests/run_failures.py` по решению 13: `UPLOADS__MAX_UNFINISHED_JOBS=0` у четырёх прежних API, пятый `<проект>-api-backlog` с `BACKLOG_ENV` (`UPLOADS__MAX_UNFINISHED_JOBS=3`), `FAULT_BACKLOG_BASE_URL`, `FAULT_BACKLOG_ENV`, журнал при падении, уборка. `conftest.py`: фикстура `backlog_api`, отказ `pytest -m fault` без адреса.
- [x] 4.1 `student-tests/run_failures.py` по решению 13: `UPLOADS__MAX_UNFINISHED_JOBS=0` у четырёх прежних API, пятый `<проект>-api-backlog` с `BACKLOG_ENV` (`UPLOADS__MAX_UNFINISHED_JOBS=3`), `FAULT_BACKLOG_BASE_URL`, `FAULT_BACKLOG_ENV`, журнал при падении, уборка. `conftest.py`: фикстура `backlog_api`, отказ `pytest -m fault` без адреса.
Проверка: `make failure_checks FAULT_ARGS='-k upload_slots_busy'` — поднимаются пять API, прежний тест зелёный.
- [ ] 4.2 `fault_hook.py`: действие `unfinished-jobs` (число заданий `queued` и `processing`); `test_failures.py`: `assert_backlog_stand`, помощник «дождаться нуля незавершённых» при работающем worker.
- [x] 4.2 `fault_hook.py`: действие `unfinished-jobs` (число заданий `queued` и `processing`); `test_failures.py`: `assert_backlog_stand`, помощник «дождаться нуля незавершённых» при работающем worker.
Проверка: `make failure_checks FAULT_ARGS='-k backlog'` выводит число.
- [ ] 4.3 `test_backlog_limit` (fault) — сценарии `queue-overload` «Предел достигнут», «Порядок проверок у предела», «Остальной API у предела», «Загрузки снова принимаются»: worker остановлен, незавершённых ноль, `sample.png` до K: 202, следующая — 429, `assert_error(resp, 429)`, `Retry-After` 5, быстрее секунды, `attachment-ids` и `object-ids` те же; посторонний, 30 MiB по `Content-Length`, `text/plain` — 404, 413, 415; текст, история, метаданные и байты готового, сообщение со ссылкой на принятое, `/health/ready` — без ошибок; запуск worker, ноль незавершённых — 202 и все `ready`.
- [x] 4.3 `test_backlog_limit` (fault) — сценарии `queue-overload` «Предел достигнут», «Порядок проверок у предела», «Остальной API у предела», «Загрузки снова принимаются»: worker остановлен, незавершённых ноль, `sample.png` до K: 202, следующая — 429, `assert_error(resp, 429)`, `Retry-After` 5, быстрее секунды, `attachment-ids` и `object-ids` те же; посторонний, 30 MiB по `Content-Length`, `text/plain` — 404, 413, 415; текст, история, метаданные и байты готового, сообщение со ссылкой на принятое, `/health/ready` — без ошибок; запуск worker, ноль незавершённых — 202 и все `ready`.
Проверка: `make failure_checks FAULT_ARGS='-k test_backlog_limit'` зелёный; на временной регрессии (`DOMAIN_ERRORS` без строки, 400) — красный.
- [ ] 4.4 `test_backlog_ignores_finished`: `ready` и `failed` больше K, незавершённых ноль — 202. `test_backlog_counts_waiting_retry`: задание со сроком следующей попытки в будущем (`set-next-attempt`) считается: 429; срок снят — обрабатывается. `test_backlog_without_broker`: брокер и relay остановлены — 202 быстрее секунды до K, затем 429; после запуска брокера, relay и worker все `ready`.
- [x] 4.4 `test_backlog_ignores_finished`: `ready` и `failed` больше K, незавершённых ноль — 202. `test_backlog_counts_waiting_retry`: задание со сроком следующей попытки в будущем (`set-next-attempt`) считается: 429; срок снят — обрабатывается. `test_backlog_without_broker`: брокер и relay остановлены — 202 быстрее секунды до K, затем 429; после запуска брокера, relay и worker все `ready`.
Проверка: `make failure_checks FAULT_ARGS='-k backlog'`.
- [ ] 4.5 `test_backlog_overshoot_bounded`: worker остановлен, 40 клиентов за `threading.Barrier` (больше мест и очереди реплики) по малому PNG: ответы 202 или 429, 5xx нет; принято не меньше K и не больше K + (`max_concurrent` + `max_waiting`) реплики; запуск worker — все `ready`. `test_backlog_off`: обычный API при K незавершённых и больше — 202.
- [x] 4.5 `test_backlog_overshoot_bounded`: worker остановлен, 40 клиентов за `threading.Barrier` (больше мест и очереди реплики) по малому PNG: ответы 202 или 429, 5xx нет; принято не меньше K и не больше K + (`max_concurrent` + `max_waiting`) реплики; запуск worker — все `ready`. `test_backlog_off`: обычный API при K незавершённых и больше — 202.
Проверка: `make failure_checks FAULT_ARGS='-k backlog'`.
- [ ] 4.6 Прочее: `images` и `contract.py` без изменений, если хватает; маркеры `@pytest.mark.spec("queue-overload", …)` на всех тестах; прежние тесты не правятся (решение 13).
- [x] 4.6 Прочее: `images` и `contract.py` без изменений, если хватает; маркеры `@pytest.mark.spec("queue-overload", …)` на всех тестах; прежние тесты не правятся (решение 13).
Проверка: `uv run pytest student-tests --collect-only -q -m fault` видит новые тесты; `git diff --stat student-tests/` — только новые тесты, `run_failures.py`, `conftest.py`, `fault_hook.py`, `spec_coverage.py`.
- [ ] 4.7 Сверка покрытия: `queue-overload` в `CAPABILITIES`; исключения девяти сценариев (нужны открытая нагрузка, счётчики и рестарт контейнера) со ссылкой `evidence/queue/baseline/summary.md` и командой `make bench_queue`; sync всех дельт в основные спеки (`/opsx:sync`): сверка читает только `openspec/specs/`.
- [x] 4.7 Сверка покрытия: `queue-overload` в `CAPABILITIES`; исключения девяти сценариев (нужны открытая нагрузка, счётчики и рестарт контейнера) со ссылкой `evidence/queue/baseline/summary.md` и командой `make bench_queue`; sync всех дельт в основные спеки (`/opsx:sync`): сверка читает только `openspec/specs/`.
Проверка: `make student_test` — сверка: нет ни «no test», ни «marker points»; `test_exclusion_evidence_exists` называет только `evidence/queue/baseline/summary.md`.
## 5. Стенд `bench/`
- [ ] 5.1 `bench/make_images.py` по решению 5: stdlib и Pillow образа, зерно из аргумента, файлы `s`, `m`, `lj`, `lp`, JSON с размерами и SHA-256 на stdout; больше 10 485 760 байт или 40 млн пикселей — код 1. `Stand.make_images` — контейнер `mtusi-bench-images` на образе стенда, `--network none`, запись в `.work/`. Построение и зерно — решение 5.
- [x] 5.1 `bench/make_images.py` по решению 5: stdlib и Pillow образа, зерно из аргумента, файлы `s`, `m`, `lj`, `lp`, JSON с размерами и SHA-256 на stdout; больше 10 485 760 байт или 40 млн пикселей — код 1. `Stand.make_images` — контейнер `mtusi-bench-images` на образе стенда, `--network none`, запись в `.work/`. Построение и зерно — решение 5.
Проверка: дважды подряд — те же SHA-256; размеры в границах; `python -m src.worker.render` на каждом — код 0; `make_images` не импортирует `src`.
- [ ] 5.2 `bench/overload.py` (`--selftest`, только stdlib, без docker; не `queue.py`: затенил бы модуль stdlib) по решениям 5–8 и 11–12: план кругами `plan_cells`; разбор строк `q,…`, `qs,…`, `qv,…`, строк `jobs`, `mq`, `mp` и журналов контейнеров (записи — по `event`); окна, throughput, время до `ready`, очередь, пики; жизни контейнера: сброс счётчиков cgroup после перезапуска (решение 10); 429 по причинам из журнала реплик и моменты первого `busy` и первого `backlog`; строка `cells.csv` (`CELL_FIELDS`, в том числе `worker_restarts`) и посекундная `timeline.csv`; пометки решения 11; вердикты H1–H9 по таблице решения 12 («подтверждено», «нет», «нет данных»); правило рекомендации; `render_summary` и графики на `plots.Svg`. Новая метрика — столбец в конце.
- [x] 5.2 `bench/overload.py` (`--selftest`, только stdlib, без docker; не `queue.py`: затенил бы модуль stdlib) по решениям 5–8 и 11–12: план кругами `plan_cells`; разбор строк `q,…`, `qs,…`, `qv,…`, строк `jobs`, `mq`, `mp` и журналов контейнеров (записи — по `event`); окна, throughput, время до `ready`, очередь, пики; жизни контейнера: сброс счётчиков cgroup после перезапуска (решение 10); 429 по причинам из журнала реплик и моменты первого `busy` и первого `backlog`; строка `cells.csv` (`CELL_FIELDS`, в том числе `worker_restarts`) и посекундная `timeline.csv`; пометки решения 11; вердикты H1–H9 по таблице решения 12 («подтверждено», «нет», «нет данных»); правило рекомендации; `render_summary` и графики на `plots.Svg`. Новая метрика — столбец в конце.
Проверка: `uv run python bench/overload.py --selftest` покрывает: план без повтора подряд, окна на границе, `updated_at` в микросекундах, потерянное и зависшее вложение, `oom`, перезапуск контейнера посреди ячейки (наибольшее и сумма по жизням), каждый вердикт в обе стороны и «нет данных», рекомендацию (2, 2) и другую.
- [ ] 5.3 `bench/k6/queue.js` по решению 6 (сценарии окон `constant-arrival-rate`, `timeUnit: "10s"`, VU заранее `queue_pre_vus` без прибавления, 429 не повторяется, строка `q,…` с `Retry-After`, порог итераций для сверки строк) и `bench/k6/queue_sweep.js` по решению 9 (`shared-iterations`, ids из `.work/`, строка `qs,…` на вложение, у выборки — SHA-256 оригинала и вариантов, строка `qv,…`). Идентификация — как в `uploads.js`.
- [x] 5.3 `bench/k6/queue.js` по решению 6 (сценарии окон `constant-arrival-rate`, `timeUnit: "10s"`, VU заранее `queue_pre_vus` без прибавления, 429 не повторяется, строка `q,…` с `Retry-After`, порог итераций для сверки строк) и `bench/k6/queue_sweep.js` по решению 9 (`shared-iterations`, ids из `.work/`, строка `qs,…` на вложение, у выборки — SHA-256 оригинала и вариантов, строка `qv,…`). Идентификация — как в `uploads.js`.
Проверка: `make bench_queue_quick` (задача 5.7): число строк `q,…` равно итерациям; выборка сошлась.
- [ ] 5.4 `bench/sampler.sh`, режим `queue` по решению 10; `bench/queue.compose.yml` (плагин брокера, `restart: unless-stopped` у worker), `bench/rabbitmq/enabled_plugins`, `bench/rabbitmq/91-bench.conf`. Режимы `list`, `scan`, `peak` и их разбор не меняются.
- [x] 5.4 `bench/sampler.sh`, режим `queue` по решению 10; `bench/queue.compose.yml` (плагин брокера, `restart: unless-stopped` у worker), `bench/rabbitmq/enabled_plugins`, `bench/rabbitmq/91-bench.conf`. Режимы `list`, `scan`, `peak` и их разбор не меняются.
Проверка: `uv run python bench/scaling.py --selftest`, `uv run python bench/resources.py --selftest`; на стенде строки `mq` идут раз в секунду, `missing` при остановленном брокере; значение совпадает с `rabbitmqctl list_queues`; порт 15692 не опубликован на хосте; `docker inspect` контейнера worker — политика `unless-stopped`, контейнеров других профилей — прежняя; разбор перезапуска — `--selftest` задачи 5.2 (завершение ядром случайно, по команде его не вызвать: `docker kill` демон считает ручной остановкой и не перезапускает).
- [ ] 5.5 `bench/run.py`: `Profile` (`queue_*`, `is_queue`), профили `queue` и `queue_quick` по решениям 5, 6, 8, 14; `Stand.start` при `is_queue` и `queue.compose.yml`; `leftovers`, `stop`, `vm_warnings`, `limits` — новые роли и `mtusi-bench-worker-2`, `mtusi-bench-images`; `compose kill` перед `down`; бюджет CPU — код 2 до стенда; каталог `evidence/queue/<метка>/`; `--resume` у `is_queue` (`resume_problems`, готовая строка `cells.csv`).
- [x] 5.5 `bench/run.py`: `Profile` (`queue_*`, `is_queue`), профили `queue` и `queue_quick` по решениям 5, 6, 8, 14; `Stand.start` при `is_queue` и `queue.compose.yml`; `leftovers`, `stop`, `vm_warnings`, `limits` — новые роли и `mtusi-bench-worker-2`, `mtusi-bench-images`; `compose kill` перед `down`; бюджет CPU — код 2 до стенда; каталог `evidence/queue/<метка>/`; `--resume` у `is_queue` (`resume_problems`, готовая строка `cells.csv`).
Проверка: `make bench_uploads_quick` и `make bench_quick` — код 0, паспорт без изменений, кроме `.work/variant.compose.yml` у `uploads` (задача 5.8); `make bench_queue` на чужой занятой метке — код 2.
- [ ] 5.6 `Bench.run_queue` и `queue_cell`: разогрев, сэмплер, контрольный `background.js` (остановка SIGINT, `reconcile.line_problems`), `queue.js`, ожидание нуля незавершённых по строкам `jobs` со сроком, окно `after`, `queue_sweep.js`, чтение SQL, журналы (сверка «Started worker» с ячейкой — отказ при расхождении), строка `cells.csv`; блоки решения 8: пределы, приём (15/с, 45 с, причины 429 из журнала реплик), второй worker в конце `over`, KILL worker и рестарт брокера посреди `over`; сторож сэмплера; код команды по пометкам решения 11. Секреты в метку не попадают: `raw/` — только итоги k6, журналы не копируются.
- [x] 5.6 `Bench.run_queue` и `queue_cell`: разогрев, сэмплер, контрольный `background.js` (остановка SIGINT, `reconcile.line_problems`), `queue.js`, ожидание нуля незавершённых по строкам `jobs` со сроком, окно `after`, `queue_sweep.js`, чтение SQL, журналы (сверка «Started worker» с ячейкой — отказ при расхождении), строка `cells.csv`; блоки решения 8: пределы, приём (15/с, 45 с, причины 429 из журнала реплик), второй worker в конце `over`, KILL worker и рестарт брокера посреди `over`; сторож сэмплера; код команды по пометкам решения 11. Секреты в метку не попадают: `raw/` — только итоги k6, журналы не копируются.
Проверка: `make bench_queue_quick`; в каталоге метки нет значений паролей и токенов (`meta.json` — через фильтр `SECRET_ENV_MARKS`, `raw/` — только итоги k6, журналы не копируются); прерывание Ctrl+C — стенд удалён, метка «незавершена»; `RESUME=1` — готовые ячейки не снимаются.
- [ ] 5.7 `Makefile`: `bench_queue [QUEUE_LABEL=...] [RESUME=1]`, `bench_queue_quick` (метка `quick-queue-<время>`), `$(KEEP_AWAKE)`, комментарии в стиле соседних; `.gitignore`: `evidence/queue/quick-*/`.
- [x] 5.7 `Makefile`: `bench_queue [QUEUE_LABEL=...] [RESUME=1]`, `bench_queue_quick` (метка `quick-queue-<время>`), `$(KEEP_AWAKE)`, комментарии в стиле соседних; `.gitignore`: `evidence/queue/quick-*/`.
Проверка: `make bench_queue_quick` — код 0 за ~11 мин, все вердикты посчитаны (на коротких окнах часть — «нет данных»), `git status` не видит каталога метки.
- [ ] 5.8 Профиль `uploads` по решению 13: `UPLOADS__MAX_UNFINISHED_JOBS=0` в override всех вариантов, `app_env` в паспорте.
- [x] 5.8 Профиль `uploads` по решению 13: `UPLOADS__MAX_UNFINISHED_JOBS=0` в override всех вариантов, `app_env` в паспорте.
Проверка: `make bench_uploads_quick` — код 0, все 429 — от мест (`reason=busy`), ни одного `backlog`.
## 6. Правила и карта кода
- [ ] 6.1 `.claude/rules/`: `bench.md` — раздел «Профиль очереди», таблица инструментов, новая роль в «что не меняется», граница чёрного ящика; `worker.md` — правило concurrency и prefetch: `concurrency ≤ min(CPU + ожидание, (лимит − база) / пик)`, `prefetch = concurrency`, ограничения `prefetch / потолок` (30 мин, 300 с), завершение процесса 1 ядром при превышении лимита и перезапуск, ссылка на метку; `settings.md`, `api-contract.md` (таблица кодов, порядок проверок), `service-layer.md`, `repo-layer.md`, `logging.md`, `student-tests.md` (пятый API, hook, тесты), `run-modes.md` по необходимости.
- [x] 6.1 `.claude/rules/`: `bench.md` — раздел «Профиль очереди», таблица инструментов, новая роль в «что не меняется», граница чёрного ящика; `worker.md` — правило concurrency и prefetch: `concurrency ≤ min(CPU + ожидание, (лимит − база) / пик)`, `prefetch = concurrency`, ограничения `prefetch / потолок` (30 мин, 300 с), завершение процесса 1 ядром при превышении лимита и перезапуск, ссылка на метку; `settings.md`, `api-contract.md` (таблица кодов, порядок проверок), `service-layer.md`, `repo-layer.md`, `logging.md`, `student-tests.md` (пятый API, hook, тесты), `run-modes.md` по необходимости.
Проверка: `grep -n "max_unfinished_jobs\|UploadBacklogFull\|bench_queue" .claude/rules/*.md` находит правила; новых утверждений о числах метки нет: они — в `REPORT.md`.
- [ ] 6.2 `AGENTS.md`: статус лабы и change, инвариант предела (уровень 5), команды `make bench_queue`, `make bench_queue_quick`, карта кода: `bench/overload.py`, `make_images.py`, `queue.compose.yml`, `k6/queue*.js`, `evidence/queue/`, `count_unfinished`; в `KNOWN_ISSUES.md` теперь девять открытых записей (запись о памяти S3 добавлена стадией propose).
- [x] 6.2 `AGENTS.md`: статус лабы и change, инвариант предела (уровень 5), команды `make bench_queue`, `make bench_queue_quick`, карта кода: `bench/overload.py`, `make_images.py`, `queue.compose.yml`, `k6/queue*.js`, `evidence/queue/`, `count_unfinished`; в `KNOWN_ISSUES.md` теперь девять открытых записей (запись о памяти S3 добавлена стадией propose).
Проверка: `graphify update .` без ошибок; команды из таблицы существуют (`make -n bench_queue_quick`).
- [ ] 6.3 `.claude/skills/run-mtusi-messenger/SKILL.md` — строка о `make bench_queue_quick` для защиты. `QUESTIONS.md` — решения apply.
- [x] 6.3 `.claude/skills/run-mtusi-messenger/SKILL.md` — строка о `make bench_queue_quick` для защиты. `QUESTIONS.md` — решения apply.
Проверка: `make check`; `make lint`.
## 7. Регресс на рабочем дереве
- [ ] 7.1 `make lint`, `make check`, `make validate PYTHON=.venv/bin/python`, `make service_test`, `make service_test_db`.
- [x] 7.1 `make lint`, `make check`, `make validate PYTHON=.venv/bin/python`, `make service_test`, `make service_test_db`.
Проверка: всё зелёное; `tests/`, `contracts/`, `README.md`, `lab.json` без изменений (`git status`).
- [ ] 7.2 Рабочий стенд на дереве: `make run_docker`, `make test`, `make student_test`; `make test_isolated`.
- [x] 7.2 Рабочий стенд на дереве: `make run_docker`, `make test`, `make student_test`; `make test_isolated`.
Проверка: `PASS: lab5`; красное только `test_exclusion_evidence_exists` по метке группы 9.
- [ ] 7.3 Полный `make failure_checks` (рабочий стенд остановлен: `make stop`).
- [x] 7.3 Полный `make failure_checks` (рабочий стенд остановлен: `make stop`).
Проверка: все проверки зелёные, число и время — в отчёт apply; `crash markers 0`.
- [ ] 7.4 `make bench_queue_quick`, `make bench_uploads_quick`, `make bench_rollout_quick`.
- [x] 7.4 `make bench_queue_quick`, `make bench_uploads_quick`, `make bench_rollout_quick`.
Проверка: код 0 у всех, очередь поднимается и опускается на шкале, у `kill-worker` две попытки у взятых, нет `lost`, `stuck`, `duplicate`.
## 8. Гипотезы до меток (основная сессия)
- [ ] 8.1 `REPORT.md`, новый раздел «Очередь под перегрузкой»: гипотезы H1–H9 с порогами из решения 12, методика, определения решения 7, правило рекомендации. Числа метки — пока нет. Вопросы из `QUESTIONS.md` — в «Открытые вопросы преподавателю».
- [x] 8.1 `REPORT.md`, новый раздел «Очередь под перегрузкой»: гипотезы H1–H9 с порогами из решения 12, методика, определения решения 7, правило рекомендации. Числа метки — пока нет. Вопросы из `QUESTIONS.md` — в «Открытые вопросы преподавателю».
Проверка: раздел называет порог у каждой гипотезы; `make lint`.
- [ ] 8.2 Коммит кода, правил и гипотез на ветке `feat/track1-queue-overload`.
+7 -5
View File
@@ -289,14 +289,16 @@ U+FFFD MUST NOT превращать отказ в принятое имя.
3. 404 — чата нет или пользователь в нём не состоит;
4. 415 — `Content-Type` запроса;
5. 413 — `Content-Length` запроса;
6. 429 — нет места для загрузки (требование «Одновременные загрузки
6. 429 — незавершённых заданий не меньше предела (`queue-overload`, «Предел
незавершённых заданий»);
7. 429 — нет места для загрузки (требование «Одновременные загрузки
реплики»);
7. тело: 413 — прочитано больше лимита; 400 — тело не пришло за срок
8. тело: 413 — прочитано больше лимита; 400 — тело не пришло за срок
(требование «Срок передачи тела») или клиент оборвал передачу;
8. 415 или 413 — содержимое: формат и целостность или число пикселей.
9. 415 или 413 — содержимое: формат и целостность или число пикселей.
Тело MUST NOT читаться, пока не пройдены проверки 1–6. Загрузка,
отклонённая на проверках 1–5, MUST NOT ждать места и занимать его.
Тело MUST NOT читаться, пока не пройдены проверки 1–7. Загрузка,
отклонённая на проверках 1–6, MUST NOT ждать места и занимать его.
Ошибка клиента MUST NOT давать 500.
#### Scenario: Посторонний с большим файлом
+3
View File
@@ -37,6 +37,9 @@ MUST NOT зависеть от состояния хранилища.
- relay — публикация заданий: без него задания ждут в PostgreSQL;
- worker — фоновая обработка: без него загрузки ждут в очереди.
Предел незавершённых заданий (`queue-overload`) на готовность MUST NOT влиять: реплика, которая
отвечает на загрузку 429, обслуживает остальные запросы и остаётся готовой.
Проверка MUST NOT обращаться к S3 и брокеру и MUST NOT требовать
идентификации. Перечень критичных и некритичных зависимостей с причинами
SHALL быть в `REPORT.md`.
+9 -4
View File
@@ -20,8 +20,11 @@ Transactional outbox заданий обработки вложений с ла
записи»). Зафиксированное задание без времени подтверждения брокером — это намерение:
оно уже не может потеряться, его SHALL довести до брокера relay.
Ответ на загрузку MUST NOT зависеть от состояния брокера и relay: их отказ, заморозка и
остановка не меняют ни кода ответа, ни срока, в который он приходит.
Ответ на загрузку MUST NOT зависеть от состояния брокера и relay напрямую: их отказ,
заморозка и остановка не меняют ни кода ответа, ни срока, в который он приходит. Косвенно
они на него влияют только через принятую работу: пока задания не завершаются, их число
растёт, и у предела незавершённых заданий загрузка получает 429 (`queue-overload`, «Предел
незавершённых заданий»).
#### Scenario: Загрузка при остановленном брокере
@@ -152,9 +155,11 @@ Relay MUST NOT публиковать новые задания, пока зад
меньше `[relay] max_published_backlog`: остальные ждут в PostgreSQL. Значение 0 — без предела.
Так длина очереди брокера ограничена настройкой, а накопление видно в PostgreSQL. Срабатывание
предела памяти брокера SHALL сдерживать публикацию так же: relay получает отказ по сроку, задания
ждут в PostgreSQL, а загрузки по-прежнему отвечают 202.
ждут в PostgreSQL, а загрузки по-прежнему отвечают 202, пока не достигнут предел незавершённых
заданий.
Ограничение принятой работы на входе API здесь не вводится: это `track1-queue-overload`.
Ограничение принятой работы на входе API — другая граница: `queue-overload`, «Предел незавершённых
заданий». Здесь ограничена только доля принятой работы, которую видит брокер.
#### Scenario: Очередь ограничена пределом
+134 -5
View File
@@ -70,8 +70,9 @@ run_dev` / `make run_docker`). После завершения, в том чис
Стенд SHALL состоять из балансировщика (LB), реплик приложения,
PostgreSQL и Valkey. В профилях загрузок и сверки к ним SHALL
добавляться S3 с его bootstrap, а в профиле сверки — разовые проходы процесса
уборщика. Брокер, relay и worker стенд не запускает: профили этого спека меряют
реплику, а не обработку, и реплика к брокеру не обращается. Число реплик SHALL
уборщика. В профиле очереди к ним SHALL добавляться S3 с его bootstrap, брокер, relay, worker и
уборщик: этот профиль меряет обработку. Остальные профили брокер, relay и worker не запускают: они
меряют реплику, а реплика к брокеру не обращается. Число реплик SHALL
задаваться методикой, по умолчанию одна. Приложение SHALL запускаться в контейнерах из образа,
собранного из текущего checkout тем же `Dockerfile`. Исключения — профиль
поочерёдной замены и варианты «до» профилей загрузок и сверки. Они берут
@@ -86,7 +87,9 @@ PostgreSQL и Valkey. В профилях загрузок и сверки к н
аргументами сервера, что у рабочего стенда, а bucket и пользователей
создаёт тот же bootstrap. В профиле сверки к аргументам S3 добавляется
порт метрик шлюза: он слушает только loopback контейнера S3, и по нему
оркестратор считает запросы к S3. В сериях трека 1 предел соединений
оркестратор считает запросы к S3. Брокер SHALL запускаться из того же образа и с той же
конфигурацией, что у рабочего стенда; в профиле очереди к ней добавляются плагин метрик и
интервал статистики в секунду: порт метрик доступен только в сети стенда, на хост не публикуется. В сериях трека 1 предел соединений
PostgreSQL (`max_connections`) — параметр конфигурации серии, по
умолчанию 100, как у образа. Схема БД SHALL применяться миграциями до
наполнения.
@@ -96,7 +99,7 @@ PostgreSQL (`max_connections`) — параметр конфигурации с
- у каждой реплики приложения — лимит CPU и памяти без swap, заданный
методикой (в профилях лабы 2 — 1 CPU и 2 ГБ, в серии трека 1 — по
конфигурации);
- у LB, PostgreSQL, Valkey, S3 и уборщика — свои лимиты CPU и памяти
- у LB, PostgreSQL, Valkey, S3, брокера, relay, worker и уборщика — свои лимиты CPU и памяти
без swap, заданные методикой; в серии трека 1 они одинаковы во всех
конфигурациях; у уборщика в управляемом опыте профиля сверки — другой
лимит CPU, тоже заданный методикой;
@@ -190,6 +193,13 @@ docker-сети и обращаться к приложению через LB п
завершился успешно, а аргументы S3, образы и лимиты S3 и уборщика
записаны в паспорт
#### Scenario: Конвейер в профиле очереди
- **WHEN** запускается профиль очереди
- **THEN** S3, брокер, relay, worker и уборщик запущены из образов рабочего стенда с его лимитами без swap, у worker — политика перезапуска
рабочего стенда, порт метрик брокера не опубликован на хосте, а образы, лимиты, значения конкуренции и prefetch и окружение worker и relay
записаны в паспорт
### Requirement: Сценарии нагрузки
Стенд SHALL поддерживать два сценария с синтетическими данными
@@ -1874,7 +1884,9 @@ change `pipeline-reliability`. Commit SHALL меняться при перехо
Стенд — LB и одна реплика с лимитами рабочего стенда (1 CPU, 512 МБ без
swap), PostgreSQL, Valkey и S3 с лимитами рабочего стенда. Брокер, relay и
worker не запускаются: задания ждут в PostgreSQL.
worker не запускаются: задания ждут в PostgreSQL. Поэтому у всех вариантов предел
незавершённых заданий выключен (`queue-overload`): иначе он отклонял бы загрузки, и профиль мерил бы не память
приёма, а этот предел.
Варианты кода:
- «до» — образ commit из методики; у лабы 5 это commit переноса лабы 4, в
@@ -1950,6 +1962,11 @@ bootstrap между прогонами. К bucket и объектам он не
- **WHEN** реплика при старте заняла больше памяти, чем в окне прогона
- **THEN** пик прогона отражает только окно, а не старт процесса
#### Scenario: Предел заданий не участвует
- **WHEN** выполнен профиль загрузок, задания не обрабатываются, и их больше значения предела по умолчанию
- **THEN** ни один ответ 429 не вызван пределом незавершённых заданий: все 429 — от мест загрузки, а в паспорте вариантов предел равен 0
### Requirement: Загрузки в отчёте
`REPORT.md` SHALL содержать по профилю загрузок:
@@ -2140,3 +2157,115 @@ bench_reconcile_quick` — то же на малом наборе и одним
- **WHEN** проверяющий открывает раздел стоимости сверки в `REPORT.md`
- **THEN** у каждой гипотезы есть вывод со ссылкой на ячейки сводки
метки, а числа совпадают со сводкой
### Requirement: Профиль очереди
Команда `make bench_queue` (метка `QUEUE_LABEL`, по умолчанию `baseline`) SHALL мерить конвейер обработки вложений под перегрузкой.
Команда `make bench_queue_quick` — то же на части ячеек и с короткими окнами, метка `quick-queue-…`, в git не идёт. Результаты SHALL
сохраняться в `evidence/queue/<метка>/`. Занятая метка SHALL давать отказ до запуска стенда, кроме продолжения прерванной метки на том же
commit (`RESUME=1`), как у серий трека 1.
Стенд — требование «Фиксированный стенд»: LB, две реплики, PostgreSQL, Valkey, S3, брокер, relay, worker и уборщик с лимитами рабочего стенда (worker
— 1 CPU и 1 ГБ без swap). Worker перезапускается по той же политике, что на рабочем стенде: настройка, которая не помещается в лимит памяти, может стоить завершения его
процесса 1 ядром, и ячейка показывает это, а не простаивает. Каждая ячейка — свежий стенд на новых volume.
**Настройки** (конкуренция, prefetch): 1 и 1; 2 и 2 — значения по умолчанию; 4 и 4; 2 и 256 — большой prefetch.
**Классы изображений** — настоящие файлы, детерминированно от зерна методики, ни один не тривиален для декодера, размер и SHA-256 — в паспорте:
- `s` — JPEG около 1,9 млн пикселей и 0,5 MiB;
- `m` — PNG из шума около 3,5 млн пикселей на границе байтов контракта;
- `lj` — JPEG на границе пикселей контракта, около 9 MiB;
- `lp` — PNG с альфа-каналом на границе пикселей и байтов контракта.
**Ячейки матрицы** — настройка × класс × повтор, повторов три, круги с перестановкой от зерна, повтор одной ячейки не идёт подряд. План — в паспорте до первой
ячейки. Большой prefetch — на `s` и `lp`, конкуренция 1 — на `m` и `lp`, остальные — на всех классах.
**Нагрузка ячейки** — открытая модель загрузок через LB, интенсивность задана методикой на класс и одинакова для всех настроек: окно ниже потолка worker; окно перегрузки
выше потолка; спад до нуля, пока незавершённых заданий нет; снова окно ниже потолка. Ответ не повторяется: 429 считается отказом. Рядом всё время идёт контрольный поток:
отправка текста, чтение истории и скачивание готовых вложений с постоянной интенсивностью.
**Блоки сверх матрицы**, по три повтора, класс `s`, настройка по умолчанию, если не сказано иное:
- предел: предел незавершённых заданий по умолчанию и выключенный, перегрузка, которая его превышает;
- приём: класс `m`, интенсивность выше того, что принимают реплики и S3, окно перегрузки такой длины, что после мест загрузки срабатывает и предел незавершённых заданий;
- второй worker: в конце окна перегрузки запускается ещё один worker с теми же настройками, настройки 2 и 2 и 2 и 256;
- рестарты: посреди перегрузки worker завершён сигналом KILL и снова запущен; брокер перезапущен с сохранённым volume.
Для каждой ячейки SHALL сохраняться:
- throughput — готовых вложений в секунду в окне перегрузки и в окне восстановления;
- очередь посекундно и её пики, в трёх местах: неопубликованные задания (outbox) и ждущие срока; очередь брокера — готовые и неподтверждённые сообщения, опубликованные и не
взятые задания; взятые worker — `processing` и выданные, но не взятые;
- возраст старейшего незавершённого задания, пик и посекундно;
- время от ответа 202 до `ready` по метаданным: p50, p95 и p99 по окнам прихода;
- время восстановления: от конца окна перегрузки до нуля незавершённых заданий;
- RSS: пик процесса worker, пик процесса обработки по его отчёту (p50 и наибольший), `memory.peak` и наибольшая анонимная память контейнера, завершения ядром из-за памяти, перезапуски контейнера worker; у перезапущенного контейнера — наибольшее и сумма по его жизням;
- CPU и троттлинг worker, S3, PostgreSQL, реплик, relay, брокера и уборщика по окнам;
- память брокера и наличие сработавшего предела памяти;
- ответы на загрузку по кодам, недосланные итерации, `failed` по кодам и причинам, попытки сверх одной, пропущенные сообщения по причинам;
- контрольный поток: число ответов, ошибки, p50, p95 и p99 по окнам.
Граница чёрного ящика: генератор обращается к приложению только по HTTP через LB, истина о готовности — метаданные `GET /attachments/{id}`, запрошенные у каждого принятого
вложения после разбора очереди. Сверх этого оркестратор читает: счётчики cgroup; журналы worker, relay, реплик и уборщика; состояние заданий в PostgreSQL стенда — только для измерения; метрики очереди
брокера. Приложение он не импортирует.
Достоверность:
- принятые вложения SHALL совпасть с вложениями стенда: потерянное или зависшее — пометка ячейки, у ячейки блока рестартов и матрицы — и ненулевой код команды в конце метки;
- второго набора вариантов и второго задания у вложения SHALL не быть, иначе так же;
- выборка оригиналов и вариантов SHALL скачиваться с SHA-256 из метаданных;
- k6 с недосланными итерациями, выгрузка хоста в swap и упавшее хранилище — пометки ячейки;
- конкуренция и prefetch в записи о старте worker SHALL совпасть с ячейкой, иначе отказ.
В паспорте метки SHALL быть: лимиты и образы; значения конкуренции, prefetch и окружение worker и relay по ячейкам без секретов; классы и их параметры; интенсивности и окна; контрольный поток; план; версия ядра ВМ;
состояние хоста; посторонние контейнеры.
Сводка SHALL давать по каждой ячейке медиану и разброс повторов, таблицы блоков, вывод по каждой гипотезе (требование «Очередь под перегрузкой в отчёте»), рекомендуемую настройку по её правилу и графики.
#### Scenario: Полный профиль очереди
- **WHEN** выполнен `make bench_queue`
- **THEN** в `evidence/queue/<метка>/` есть паспорт, таблица ячеек, посекундная шкала, сводка с выводами по гипотезам и графики, код выхода 0
#### Scenario: Быстрый профиль очереди
- **WHEN** выполнен `make bench_queue_quick`
- **THEN** за несколько минут проходят ячейки перегрузки на двух классах, большой конкуренции на классе с наибольшей памятью, предела, второго worker и рестарта worker, код выхода 0, каталог метки в git не попадает
#### Scenario: Вложение потеряно
- **WHEN** на вложение ответили 202, а после разбора очереди метаданных нет или они не `ready` и не `failed`
- **THEN** ячейка помечена, число потерянных и зависших названо в сводке, а код команды в конце метки ненулевой
#### Scenario: Завершение ядром из-за памяти
- **WHEN** ядро завершает процесс обработки или процесс 1 worker по памяти контейнера
- **THEN** ячейка помечена `oom`, контейнер worker перезапускается сам, если завершён его процесс 1, число завершений, перезапусков и повторов записано как результат настройки, а не как сбой
команды, а принятые вложения дошли до `ready` или названного `failed`
#### Scenario: Прерванная метка
- **WHEN** длинный прогон прерван, и он запущен снова с `RESUME=1` на том же commit
- **THEN** готовые ячейки не снимаются заново, а незавершённая снимается с новой попыткой
### Requirement: Очередь под перегрузкой в отчёте
`REPORT.md` SHALL содержать по профилю очереди:
- гипотезы с числовыми порогами «подтверждено / нет», записанные и зафиксированные commit раньше меток замера;
- методику: стенд, лимиты, настройки, классы, интенсивности и окна, контрольный поток, повторы и как читается шум;
- определения: что считается очередью в трёх местах, throughput, время до `ready`, восстановление;
- таблицы результатов метки: throughput, очередь, p50, p95 и p99 времени до `ready`, RSS, `memory.peak`, CPU и троттлинг — по настройкам и классам; блоки предела, второго worker и рестартов;
- backpressure и ограничение принятой работы: где работа перестаёт приниматься и ускоряться и что видит клиент;
- восстановление: время, отсутствие потерянных, зависших и дублей эффекта, контрольный поток;
- вывод по каждой гипотезе, компромисс latency и ресурсов как вывод из данных, рекомендуемую настройку с условиями и решение о значениях по умолчанию с обоснованием;
- обоснование предела незавершённых заданий по измеренному потолку;
- ограничения: один хост, ВМ Docker Desktop, генератор на том же хосте, одна нода S3 на свежем volume, число worker, лимиты контейнеров, синтетические изображения.
Числа в отчёт SHALL переноситься из сводки метки, а не пересчитываться вручную. Метка SHALL быть снята с закоммиченного кода, commit — в шапке.
#### Scenario: Гипотезы очереди до прогонов
- **WHEN** проверяющий смотрит историю `REPORT.md` и каталога метки
- **THEN** commit с гипотезами раньше commit с результатами метки
#### Scenario: Выводы по метке очереди
- **WHEN** проверяющий открывает раздел очереди в `REPORT.md`
- **THEN** у каждой гипотезы есть вывод со ссылкой на ячейки сводки, числа совпадают со сводкой, а рекомендуемая настройка следует из правила и таблиц
+3 -2
View File
@@ -76,8 +76,9 @@ PostgreSQL, и следующий проход публикует его сно
Отдельный вызов публикации MUST NOT зависать дольше этого срока.
Брокер не критичен для обязательного пути и для приёма файлов: без него SHALL работать
загрузка (202), отправка текста, история, метаданные, скачивание готового вложения и
`/health/ready` (`health`, «Readiness»).
загрузка (202, пока не достигнут предел незавершённых заданий — `queue-overload`), отправка
текста, история, метаданные, скачивание готового вложения и `/health/ready` (`health`,
«Readiness»).
После возврата брокера публикация SHALL проходить без перезапуска процесса.
+159
View File
@@ -0,0 +1,159 @@
# queue-overload Specification
## Purpose
Поведение конвейера вложений под перегрузкой с лабы 5, трек 1: предел незавершённых заданий на входе API и что видит
клиент у предела, где и как сдерживается работа, что происходит с остальным API, восстановление после перегрузки и
рестарты worker и брокера под ней. Как это меряется — `load-benchmark`, «Профиль очереди».
## Requirements
### Requirement: Предел незавершённых заданий
Незавершённое задание — задание в состоянии `queued` или `processing`, в том числе ожидающее следующей попытки или
неопубликованное. Загрузка, прошедшая проверки 1–5 (`attachments`, «Порядок проверок загрузки»), SHALL получать ответ 429
`rate_limited` в формате ошибки с заголовком `Retry-After` — положительным целым числом секунд, если незавершённых заданий
стенда не меньше `[uploads] max_unfinished_jobs` (`service-configuration`, «Параметры загрузок»). Значение 0 — предела нет.
Такая загрузка MUST NOT читать тело, занимать место загрузки и ждать его, MUST NOT оставлять ни метаданных, ни объекта. Ответ
SHALL приходить сразу: без ожидания освобождения работы. Клиент повторяет загрузку сам, после `Retry-After`: это новая загрузка,
она ничего не дублирует, потому что отклонённая ничего не сохранила. Балансировщик такой ответ не повторяет (`load-balancing`).
Предел SHALL быть один на стенд: его считают по PostgreSQL все реплики, память процесса в подсчёте не участвует. Предел мягкий:
загрузки, которые уже прошли проверку и ещё не зафиксировали задание, могут превысить его, но не больше чем на число загрузок в
полёте: реплик × (`[uploads] max_concurrent` + `[uploads] max_waiting`).
Проверка MUST NOT добавлять загрузке шаг с PostgreSQL сверх прежних: цепочка сроков пути загрузки в балансировщике не меняется. Её
цена MUST NOT расти с числом завершённых заданий и с превышением предела.
Журнал реплики SHALL называть отказ: причина «предел заданий», предел и найденное число, без `filename`.
#### Scenario: Предел достигнут
- **WHEN** worker остановлен, предел равен K, и участник последовательно загружает настоящие PNG
- **THEN** первые загрузки до K незавершённых заданий получают 202, следующая — 429 `rate_limited` с `Retry-After` не меньше 1,
с непустыми `X-Request-Id` и `X-Instance-Id`, быстрее секунды, и нового вложения нет ни в PostgreSQL, ни в bucket
#### Scenario: Загрузки снова принимаются
- **WHEN** предел достигнут, worker запущен, и незавершённых заданий стало меньше предела
- **THEN** следующая загрузка получает 202, а все принятые раньше вложения становятся `ready`
#### Scenario: Завершённые задания не считаются
- **WHEN** незавершённых заданий нет, а вложений `ready` и `failed` больше предела
- **THEN** загрузка получает 202
#### Scenario: Ожидание следующей попытки считается
- **WHEN** задание ждёт следующую попытку, её срок ещё не наступил, а незавершённых заданий вместе с ним столько же, сколько предел
- **THEN** загрузка получает 429
#### Scenario: Порядок проверок у предела
- **WHEN** предел достигнут, и посторонний загружает файл в чат, участник загружает 30 MiB с `Content-Length` 31 457 280, а затем PNG с
`Content-Type: text/plain`
- **THEN** ответы 404, 413 и 415, а не 429
#### Scenario: Остальной API у предела
- **WHEN** предел достигнут
- **THEN** отправка текста — 201, история — 200, метаданные и скачивание готового вложения — 200, сообщение со ссылкой на принятое
вложение — 201, а `/health/ready` — 200
#### Scenario: Предел при остановленных брокере и relay
- **WHEN** брокер и relay остановлены, и участник загружает файлы до предела
- **THEN** загрузки до предела получают 202 быстрее секунды, следующая — 429, а после запуска брокера, relay и worker все принятые
вложения становятся `ready`
#### Scenario: Превышение ограничено
- **WHEN** незавершённых заданий нет, предел равен K, и участники одновременно загружают заметно больше K файлов
- **THEN** каждый ответ — 202 или 429, принятых не меньше K и не больше K плюс числа загрузок в полёте, и каждое принятое вложение
становится `ready`
#### Scenario: Предел выключен
- **WHEN** сервис запущен с `UPLOADS__MAX_UNFINISHED_JOBS=0`, worker остановлен, и участник загружает файлы
- **THEN** каждый ответ 202, сколько бы заданий ни ждало
### Requirement: Сдерживание работы по уровням
Работа под перегрузкой SHALL сдерживаться последовательно, и на каждом уровне SHALL быть видно, сколько её там:
- приём: места загрузки реплики и предел незавершённых заданий — клиент видит 429;
- outbox: задания, которые relay ещё не опубликовал, — в PostgreSQL;
- очередь брокера: не больше `[relay] max_published_backlog` опубликованных и не взятых заданий, остальные ждут в outbox;
- worker: брокер выдаёт не больше `[worker] prefetch` неподтверждённых сообщений, а взято в работу не больше `[worker] concurrency` заданий;
- процесс обработки: лимиты памяти и CPU на задание, лимит памяти контейнера worker.
Сдерживание за входом клиент MUST NOT видеть иначе, чем дольше не меняющееся `queued`: ни одного кода ошибки оно не даёт.
#### Scenario: Работа копится там, где положено
- **WHEN** загрузки идут быстрее потолка worker, и предел незавершённых заданий не достигнут
- **THEN** в каждый момент заданий `processing` не больше `concurrency`, неподтверждённых сообщений не больше `prefetch`, заданий в очереди
брокера не больше предела опубликованных, а незавершённых заданий столько же, сколько принято и не завершено
#### Scenario: Приём упирается в места загрузки
- **WHEN** загрузки на границе байтов контракта идут быстрее, чем реплики и S3 успевают их принимать, а предел незавершённых заданий не достигнут
- **THEN** лишние загрузки получают 429 от мест загрузки, принятые — 202, ответов 5xx нет, а принято не меньше, чем при интенсивности ниже этой границы
#### Scenario: Сначала места, затем предел
- **WHEN** загрузки на границе байтов контракта идут быстрее, чем реплики и S3 успевают их принимать, столько времени, что незавершённых заданий набирается до предела
- **THEN** сначала лишние загрузки получают 429 от мест загрузки, затем — 429 от предела незавершённых заданий, журнал реплик называет обе причины, ответов 5xx нет, а незавершённых заданий не больше предела плюс загрузок в полёте
### Requirement: API под перегрузкой
Пока работа копится, остальной API SHALL обслуживаться: отправка сообщений, чтение истории, метаданные и скачивание готовых вложений
MUST NOT получать ответы 5xx из-за перегрузки очереди, а реплики API MUST NOT выводиться из балансировщика. Загрузка SHALL отвечать 202 или
429, а 5xx на ней — только при отказе S3 или PostgreSQL.
#### Scenario: Контрольный поток под перегрузкой
- **WHEN** загрузки идут быстрее потолка worker, но не быстрее, чем принимают реплики и S3, а рядом идёт постоянный поток отправки текста, чтения
истории и скачивания готовых вложений (`load-benchmark`, «Профиль очереди»)
- **THEN** ответов 5xx контрольного потока нет, его p95 при отправке и чтении истории не больше 200 мс, при скачивании — не больше 500 мс, а все
реплики остаются в балансировщике
### Requirement: Восстановление после перегрузки
Восстановление — состояние после спада нагрузки, в котором незавершённых заданий нет, очередь брокера пуста, а время до `ready` новой работы
вернулось к значению до перегрузки. После снятия нагрузки конвейер SHALL приходить в него сам, без действий оператора. Каждое принятое вложение
(ответ 202) SHALL дойти до `ready` или названного `failed`: потерянных и зависших MUST NOT быть. Эффект MUST NOT дублироваться: на вложение одно
задание и по одному варианту каждого имени. Время восстановления SHALL быть измерено и не больше времени обработки накопленного при
потолке worker с запасом, заданным гипотезой (`load-benchmark`, «Очередь под перегрузкой в отчёте»).
#### Scenario: Бэклог уходит за измеренное время
- **WHEN** загрузки шли быстрее потолка worker, и нагрузка снята
- **THEN** незавершённых заданий становится ноль без действий оператора, очередь брокера пуста, время восстановления записано, а скорость обработки в окне
восстановления не ниже скорости в окне перегрузки с запасом разброса
#### Scenario: Никого не теряем
- **WHEN** нагрузка снята, и проверяющий по HTTP запрашивает метаданные каждого вложения, на которое ответили 202
- **THEN** каждое `ready` с тремя вариантами или `failed` с `error_code`, зависших нет, а выборочные оригинал и варианты скачиваются с SHA-256 из метаданных
#### Scenario: Время до готовности вернулось
- **WHEN** очередь разобрана, и загрузки снова идут ниже потолка worker
- **THEN** p95 времени до `ready` новых вложений не больше чем в полтора раза выше p95 до перегрузки
### Requirement: Рестарты под перегрузкой
Остановка процессов конвейера под перегрузкой MUST NOT терять принятую работу и MUST NOT создавать второй набор вариантов.
#### Scenario: Worker убит под перегрузкой
- **WHEN** загрузки идут быстрее потолка worker, worker завершён сигналом KILL и снова запущен
- **THEN** каждое принятое вложение становится `ready`, новых попыток сверх взятых к моменту KILL не появилось, одна попытка на задание у остальных, а
взятые заканчиваются не позже срока аренды с запасом
#### Scenario: Брокер перезапущен под перегрузкой
- **WHEN** загрузки идут быстрее потолка worker, и брокер перезапущен с сохранённым volume
- **THEN** загрузки отвечают 202 и во время рестарта, каждое принятое вложение становится `ready`, сообщения в очереди после разбора нет, а счётчики
перезапусков relay и worker не изменились
+13 -8
View File
@@ -423,8 +423,8 @@ grace и срока хранения SHALL быть описаны в `REPORT.md
### Requirement: Параметры загрузок
Ограничения загрузок вложений процесса API (capability `attachments`,
«Одновременные загрузки реплики», «Срок передачи тела») SHALL
задаваться в секции `[uploads]`:
«Одновременные загрузки реплики», «Срок передачи тела»; capability `queue-overload`, «Предел
незавершённых заданий») SHALL задаваться в секции `[uploads]`:
- `max_concurrent` — сколько загрузок процесс обрабатывает одновременно,
по умолчанию 4;
- `max_waiting` — сколько загрузок может ждать места, по умолчанию 16;
@@ -432,27 +432,31 @@ grace и срока хранения SHALL быть описаны в `REPORT.md
- `wait_timeout_seconds` — сколько секунд загрузка ждёт места, по
умолчанию 5;
- `body_timeout_seconds` — за сколько секунд после того, как загрузка
заняла место, должно прийти её тело, по умолчанию 30.
заняла место, должно прийти её тело, по умолчанию 30;
- `max_unfinished_jobs` — при каком числе незавершённых заданий стенда загрузка получает 429,
по умолчанию 250; 0 — без предела.
`max_concurrent` SHALL быть целым не меньше 1, `max_waiting` — целым не
`max_concurrent` SHALL быть целым не меньше 1, `max_waiting` и `max_unfinished_jobs` — целыми не
меньше 0, сроки — положительными числами. Иначе сервис MUST NOT
стартовать (требование «Некорректное значение останавливает запуск»).
Значения SHALL одинаково действовать в консоли и в docker. Разовая
подмена SHALL работать через окружение `UPLOADS__*` без правки файлов.
Запись журнала о старте API SHALL называть все четыре значения.
Запись журнала о старте API SHALL называть все пять значений.
Значения по умолчанию и их обоснование SHALL быть описаны в `REPORT.md`:
- бюджет памяти реплики: интерпретатор, хэши паролей и места загрузок в
лимите контейнера;
- сроки пути загрузки в балансировщике (`load-balancing`, «Загрузки
через балансировщик»).
через балансировщик»);
- предел незавершённых заданий: измеренный потолок worker на худшем классе изображений, срок
ожидания и объём staging при заполненном пределе.
#### Scenario: Параметры загрузок по умолчанию
- **WHEN** сервис запущен без секции `[uploads]` и без переменных
`UPLOADS__*`
- **THEN** запись журнала о старте называет 4 места, 16 ожидающих,
ожидание 5 с и срок тела 30 с
ожидание 5 с, срок тела 30 с и предел 250 незавершённых заданий
#### Scenario: Подмена параметров загрузок окружением
@@ -464,7 +468,8 @@ grace и срока хранения SHALL быть описаны в `REPORT.md
#### Scenario: Неверный параметр загрузок
- **WHEN** сервис запускается с `UPLOADS__MAX_CONCURRENT=0`,
`UPLOADS__MAX_WAITING=-1` или `UPLOADS__BODY_TIMEOUT_SECONDS=abc`
`UPLOADS__MAX_WAITING=-1`, `UPLOADS__MAX_UNFINISHED_JOBS=-1` или
`UPLOADS__BODY_TIMEOUT_SECONDS=abc`
- **THEN** сервис не стартует, в журнале — ошибка проверки настроек с
именем поля
+9 -5
View File
@@ -236,7 +236,7 @@ MUST NOT считаться пройденными. При `EXPECT_REPLICAS` ≥
`identification`, `sessions`, `users`, `chats`, `messages`,
`pagination`, `data-storage`, `chat-cache`, `health`, `idempotency`, с
лабы 4 `attachments` и `storage-consistency` и с лабы 5
`attachment-processing`, `message-broker` и `job-outbox`, который воспроизводится
`attachment-processing`, `message-broker`, `job-outbox` и `queue-overload`, который воспроизводится
по HTTP против работающего сервера, в том числе на стенде отказов,
SHALL быть тест. Из имени или описания теста SHALL быть понятно, какой
capability и сценарий он проверяет. Сценарий, который проверяет тест
@@ -384,22 +384,25 @@ PostgreSQL стенда, с Valkey, S3 и брокером стенда. Ком
S3, сбой внутри обработки, запуск worker с другими параметрами или команда replay;
- `message-broker`: все сценарии, которые не названы исключениями сверки покрытия;
- `job-outbox`: все сценарии;
- `storage-consistency`: все сценарии.
- `storage-consistency`: все сценарии;
- `queue-overload`: все сценарии требования «Предел незавершённых заданий».
Команда SHALL:
- собрать образ из рабочего дерева;
- поднять отдельный стенд со своими PostgreSQL, Valkey, S3 и брокером, применить
миграции и bootstrap S3;
- запустить четыре API:
- запустить пять API. У первых четырёх предел незавершённых заданий выключен: проверки копят
задания при остановленном worker и под нагрузкой, и предел отклонял бы загрузки чужих проверок:
- с настройками по умолчанию;
- «тесный» — с коротким сроком сессии и ключа идемпотентности и пулом
из одного соединения;
- «узкий по загрузкам» — с одним местом загрузки, одной загрузкой в
очереди, коротким сроком ожидания места и коротким сроком тела;
- «с коротким сроком S3» — со сроком вызова S3 в одну секунду: простой
дольше срока вызова в проверке длится полторы секунды, а не шесть.
дольше срока вызова в проверке длится полторы секунды, а не шесть;
- «узкий по заданиям» — с малым пределом незавершённых заданий.
Значения «узкого» API и API с коротким сроком S3 SHALL передаваться
Значения «узких» API и API с коротким сроком S3 SHALL передаваться
проверкам, и проверки SHALL сверять с ними стенд;
- запустить уборщика с коротким grace, интервалом и сроком хранения staging, сравнимыми со
временем теста, без плановой сверки, и передать их значения
@@ -421,6 +424,7 @@ Hook стенда отказов SHALL уметь:
- сообщить задание вложения: идентификатор, состояние, число начатых попыток, число
попыток до последнего replay, причину последней ошибки, время следующей попытки, срок
аренды и время подтверждения брокером, а также записи аудита replay;
- сообщить число незавершённых заданий стенда;
- сообщить, у каких вложений есть объект в конечном префиксе и в staging bucket
стенда, и сколько у вложения объектов вариантов, — по самим объектам, а не по
каталогам хранилища, и SHA-256 объекта по ключу;
+4
View File
@@ -471,6 +471,8 @@ async def _statements(engine, action) -> list[str]:
[
("lock_due_jobs", "'queued'"),
("count_published", "'queued'"),
("count_unfinished", "'processing'"),
("count_unfinished", "'queued'"),
("lock_stale_pending", "'pending'"),
("get_staging_candidates", "'ready'"),
],
@@ -487,6 +489,8 @@ async def test_status_is_a_constant_in_statement(
await uow.jobs.lock_due_jobs(now=NOW, limit=1)
elif method == "count_published":
await uow.jobs.count_published()
elif method == "count_unfinished":
await uow.jobs.count_unfinished(limit=1)
elif method == "lock_stale_pending":
await uow.attachments.lock_stale_pending(
attachment_id=user_dto().id,
+17
View File
@@ -683,6 +683,23 @@ class FakeAttachmentJobRepository(
) -> dataclasses.AttachmentJobDTO | None:
return self._db.jobs.get(job_id)
async def count_unfinished(self, *, limit: int) -> int:
groups = (
[
job
for job in self._db.jobs.values()
if job.state == AttachmentJobState.QUEUED
and job.published_at is None
],
self._published(),
[
job
for job in self._db.jobs.values()
if job.state == AttachmentJobState.PROCESSING
],
)
return sum(min(len(group), limit) for group in groups)
async def get_attachment_job(
self,
*,
+58
View File
@@ -880,6 +880,64 @@ async def check_count_and_mark_published(new_uow: NewUow) -> None:
assert other.published_at is None
async def check_count_unfinished(new_uow: NewUow) -> None:
world = await _world(new_uow)
async def count(limit: int) -> int:
async with new_uow() as uow:
return await uow.jobs.count_unfinished(limit=limit)
assert await count(1) == 0
# завершённые не считаются
await _failed_job(new_uow, world)
succeeded = await _started_job(new_uow, world)
async with new_uow() as uow:
await uow.jobs.finish_job(
job_id=succeeded.id,
state=AttachmentJobState.SUCCEEDED,
reason=None,
now=at(1),
)
await uow.commit()
assert await count(10) == 0
# queued без отметки
outbox = await _job(new_uow, world)
assert await count(10) == 1
# queued с отметкой
published = await _job(new_uow, world)
async with new_uow() as uow:
await uow.jobs.mark_published(job_ids=[published.id], now=at(1))
await uow.commit()
assert await count(10) == 2
# processing
await _started_job(new_uow, world, lease_expires_at=at(100))
assert await count(10) == 3
# queued со сроком следующей попытки: ждёт, но считается
retrying = await _started_job(new_uow, world, lease_expires_at=at(100))
async with new_uow() as uow:
assert await uow.jobs.return_to_queued(
job_id=retrying.id,
attempt=retrying.attempt,
reason=AttachmentJobReason.STORAGE_UNAVAILABLE,
next_attempt_at=at(1000),
now=at(1),
)
await uow.commit()
assert await count(10) == 4
# решение «не меньше предела»: ниже, на пределе и выше
assert await count(5) < 5
assert await count(4) >= 4
assert await count(3) >= 3
# одна группа больше предела: счёт обрывается, решение то же
assert outbox is not None
extra = [await _job(new_uow, world) for _ in range(3)]
assert len(extra) == 3
assert await count(2) >= 2
# в outbox теперь 5 строк (retrying с outbox), две другие группы по одной
assert await count(3) == 3 + 1 + 1
assert await count(1) == 3
async def check_recover_expired_leases(new_uow: NewUow) -> None:
world = await _world(new_uow)
expired = await _started_job(new_uow, world, lease_expires_at=at(-5))
+4 -1
View File
@@ -39,7 +39,10 @@ def fixed_settings(monkeypatch: pytest.MonkeyPatch) -> None:
(settings.auth, {"session_ttl_seconds": 3600}),
(settings.idempotency, {"ttl_seconds": 86400}),
(settings.cache, {"chat_ttl_seconds": 600}),
(settings.uploads, {"body_timeout_seconds": 1}),
(
settings.uploads,
{"body_timeout_seconds": 1, "max_unfinished_jobs": 0},
),
(settings.app, {"instance_id": "test-instance"}),
)
for section, fields in fixed:
+132 -1
View File
@@ -8,8 +8,18 @@ from uuid import UUID, uuid4
import pytest
from builders import NOW, attachment_dto, chat_dto, user_dto, variant_dto
from builders import (
NOW,
attachment_dto,
chat_dto,
job_dto,
user_dto,
variant_dto,
)
from fakes import FakeCache, FakeDatabase, FakeObjectStorage, FakeUnitOfWork
from src.api.errors import DOMAIN_ERRORS, RETRY_AFTER
from src.api.schemas import ErrorCode
from src.config import settings
from src.core import exceptions
from src.core.services import AttachmentService
from src.infra.upload_slots import UploadSlots
@@ -130,6 +140,127 @@ async def test_upload_order_and_events(
assert not database.inside_block("storage.put")
def _fill_backlog(database: FakeDatabase, count: int) -> None:
"""`count` незавершённых заданий: `queued` и `processing` поровну."""
for number in range(count):
state = (
AttachmentJobState.QUEUED
if number % 2 == 0
else AttachmentJobState.PROCESSING
)
job = job_dto(attachment_id=uuid4())
database.jobs[job.id] = replace(job, state=state)
async def test_backlog_full_rejects_without_body_or_slot(
uow: FakeUnitOfWork,
cache: FakeCache,
storage: FakeObjectStorage,
database: FakeDatabase,
world: tuple[UUID, UUID, UUID],
monkeypatch: pytest.MonkeyPatch,
) -> None:
monkeypatch.setattr(settings.uploads, "max_unfinished_jobs", 3)
_fill_backlog(database, 3)
slots = _slots()
service = AttachmentService(uow, cache, storage, slots)
# все места заняты: 429 предела приходит раньше очереди мест
async with slots.slot():
with pytest.raises(exceptions.UploadBacklogFull):
await _upload(service, world, body=_Untouched())
assert database.attachments == {}
assert storage.objects == {}
assert "jobs.count_unfinished" in database.events
# отказ не занял места: занятое выше освобождено, новая берётся
async with slots.slot():
pass
async def test_backlog_below_limit_accepts(
service: AttachmentService,
database: FakeDatabase,
world: tuple[UUID, UUID, UUID],
monkeypatch: pytest.MonkeyPatch,
) -> None:
monkeypatch.setattr(settings.uploads, "max_unfinished_jobs", 3)
_fill_backlog(database, 2)
attachment = await _upload(service, world)
assert attachment.status == AttachmentStatus.QUEUED
assert database.events.index("jobs.count_unfinished") < (
database.events.index("attachments.insert_attachment")
)
# счёт — в первом блоке, рядом с членством: шаг с БД до тела один
first_block = database.events[
database.events.index("enter") : database.events.index("exit")
]
assert "jobs.count_unfinished" in first_block
async def test_backlog_finished_jobs_not_counted(
service: AttachmentService,
database: FakeDatabase,
world: tuple[UUID, UUID, UUID],
monkeypatch: pytest.MonkeyPatch,
) -> None:
monkeypatch.setattr(settings.uploads, "max_unfinished_jobs", 2)
for state in (AttachmentJobState.SUCCEEDED, AttachmentJobState.FAILED):
for _ in range(3):
job = job_dto(attachment_id=uuid4())
database.jobs[job.id] = replace(job, state=state)
attachment = await _upload(service, world)
assert attachment.status == AttachmentStatus.QUEUED
async def test_backlog_off_makes_no_query(
service: AttachmentService,
database: FakeDatabase,
world: tuple[UUID, UUID, UUID],
monkeypatch: pytest.MonkeyPatch,
) -> None:
monkeypatch.setattr(settings.uploads, "max_unfinished_jobs", 0)
_fill_backlog(database, 5)
attachment = await _upload(service, world)
assert attachment.status == AttachmentStatus.QUEUED
assert "jobs.count_unfinished" not in database.events
@pytest.mark.parametrize(
("kind", "error"),
[
("stranger", exceptions.ChatNotFound),
("type", exceptions.UnsupportedMediaType),
("size", exceptions.PayloadTooLarge),
],
)
async def test_backlog_checked_after_cheap_checks(
service: AttachmentService,
database: FakeDatabase,
world: tuple[UUID, UUID, UUID],
monkeypatch: pytest.MonkeyPatch,
kind: str,
error: type[Exception],
) -> None:
monkeypatch.setattr(settings.uploads, "max_unfinished_jobs", 1)
_fill_backlog(database, 1)
_, bob, _ = world
arguments = {
"stranger": {"owner": bob},
"type": {"media_type": "text/plain"},
"size": {"content_length": ATTACHMENT_MAX_BYTES + 1},
}[kind]
with pytest.raises(error):
await _upload(service, world, body=_Untouched(), **arguments)
assert "jobs.count_unfinished" not in database.events
async def test_backlog_error_maps_to_429_with_retry_after() -> None:
assert DOMAIN_ERRORS[exceptions.UploadBacklogFull] == (
429,
ErrorCode.RATE_LIMITED,
)
assert RETRY_AFTER[exceptions.UploadBacklogFull] == 5
async def test_not_member_404_before_everything(
service: AttachmentService,
database: FakeDatabase,
+6
View File
@@ -20,6 +20,7 @@ from src.utils.constants import (
AUTH_REALM,
INSTANCE_ID_HEADER,
REQUEST_ID_HEADER,
UPLOAD_BACKLOG_RETRY_AFTER_SECONDS,
UPLOAD_RETRY_AFTER_SECONDS,
)
@@ -43,6 +44,10 @@ DOMAIN_ERRORS: dict[type[exceptions.DomainError], tuple[int, ErrorCode]] = {
# места загрузки процесса заняты (design change upload-memory,
# решение 2); заголовок Retry-After — RETRY_AFTER ниже
exceptions.UploadsBusy: (429, ErrorCode.RATE_LIMITED),
# предел незавершённых заданий (design change track1-queue-overload,
# решение 1): ограничено количество работы, а не частота — вопрос
# преподавателю, другой ответ меняет эту строку
exceptions.UploadBacklogFull: (429, ErrorCode.RATE_LIMITED),
exceptions.UnsupportedMediaType: (
415,
ErrorCode.UNSUPPORTED_MEDIA_TYPE,
@@ -65,6 +70,7 @@ CHALLENGES: dict[type[exceptions.DomainError], str] = {
# Retry-After у 429: через сколько секунд повторить запрос
RETRY_AFTER: dict[type[exceptions.DomainError], int] = {
exceptions.UploadsBusy: UPLOAD_RETRY_AFTER_SECONDS,
exceptions.UploadBacklogFull: UPLOAD_BACKLOG_RETRY_AFTER_SECONDS,
}
HTTP_ERRORS: dict[int, tuple[ErrorCode, str]] = {
+5
View File
@@ -246,6 +246,11 @@ class Uploads(BaseModel):
wait_timeout_seconds: float = Field(default=5, gt=0)
# секунды на всё тело с момента, как загрузка заняла место; иначе 400
body_timeout_seconds: float = Field(default=30, gt=0)
# незавершённых заданий стенда, при которых загрузка получает 429; 0 — без
# предела (design change `track1-queue-overload`, решения 1–2): предел /
# потолок worker — срок ожидания, поэтому 250 при ~0,9 задания/с на самом
# дорогом классе меньше `[relay] republish_after_seconds`
max_unfinished_jobs: int = Field(default=250, ge=0)
class Cleaner(BaseModel):
+2
View File
@@ -8,6 +8,7 @@ from .attachment import (
PayloadTooLarge,
RenderInterrupted,
UnsupportedMediaType,
UploadBacklogFull,
UploadInterrupted,
UploadsBusy,
UploadTimedOut,
@@ -46,6 +47,7 @@ __all__ = [
"StoredObjectMissing",
"Unauthenticated",
"UnsupportedMediaType",
"UploadBacklogFull",
"UploadInterrupted",
"UploadTimedOut",
"UploadsBusy",
+9
View File
@@ -45,6 +45,15 @@ class UploadsBusy(DomainError):
default_message = "Too many uploads in progress, retry later"
class UploadBacklogFull(DomainError):
"""Незавершённых заданий стенда не меньше предела: новая работа не
принимается (429 с `Retry-After`), тело не читается, места не занимает."""
default_message = (
"Too many attachments are waiting for processing, retry later"
)
class UploadTimedOut(DomainError):
"""Тело загрузки не пришло целиком за срок после занятия места."""
+8
View File
@@ -100,6 +100,14 @@ class AbstractAttachmentJobRepository(abc.ABC):
async def count_published(self) -> int:
"""Опубликованные и не взятые задания: то, что считает предел."""
@abc.abstractmethod
async def count_unfinished(self, *, limit: int) -> int:
"""Незавершённые задания (`queued` и `processing`) со счётом, оборванным
на `limit` в каждой группе (`queued` без отметки публикации, с ней,
`processing`): сумма не меньше `limit` тогда и только тогда, когда
незавершённых не меньше `limit`. Цена не растёт с превышением, само
число выше `limit` неточно."""
@abc.abstractmethod
async def mark_published(
self,
+32
View File
@@ -25,6 +25,7 @@ from sqlalchemy import (
func,
insert,
literal,
literal_column,
select,
update,
)
@@ -263,6 +264,37 @@ class SqlAlchemyAttachmentJobRepository(AbstractAttachmentJobRepository):
)
return (await self._session.execute(statement)).scalar_one()
async def count_unfinished(self, *, limit: int) -> int:
"""Сумма трёх счётов, каждый оборван на `limit`, по условиям частичных
индексов outbox, опубликованных и аренды: Index Only Scan, один запрос
(design change `track1-queue-overload`, решение 3). Без `LIMIT` цена
росла бы с бэклогом; новый индекс не быстрее, а запись дороже (проба)."""
groups = (
_outbox_condition(),
(_queued(), AttachmentJob.published_at.is_not(None)),
(
AttachmentJob.state
== literal(
AttachmentJobState.PROCESSING.value,
literal_execute=True,
),
),
)
counts = [
select(func.count())
.select_from(
select(literal_column("1").label("one"))
.select_from(AttachmentJob)
.where(*condition)
.limit(limit)
.subquery(),
)
.scalar_subquery()
for condition in groups
]
statement = select(counts[0] + counts[1] + counts[2])
return (await self._session.execute(statement)).scalar_one()
async def mark_published(
self,
*,
+34 -18
View File
@@ -95,11 +95,14 @@ class AttachmentService:
задание зафиксированы. Брокера в пути запроса нет: намерение до него
доводит relay (design change `pipeline-reliability`, решение 1).
Порядок проверок — спек «Порядок проверок загрузки»: членство
(404), `Content-Type` (415), `Content-Length` (413) — без места;
затем место загрузки (429, design change `upload-memory`, решения
1–3), тело со счётчиком и сроком (413, 400) и содержимое (415 или
413). Место держится до ответа, включая запись и компенсацию.
Порядок проверок — спек «Порядок проверок загрузки»: одним блоком и
без места членство (404), `Content-Type` (415), `Content-Length` (413)
и предел незавершённых заданий (429, design change
`track1-queue-overload`, решение 3); затем место загрузки (429, design
change `upload-memory`, решения 1–3), тело со счётчиком и сроком (413,
400) и содержимое (415 или 413). Шаг с БД до тела один, поэтому
молчание реплики до тела прежнее. Место держится до ответа, включая
запись и компенсацию.
Ожидание места, тело и проверка идут до строки `pending`, поэтому
граница живой загрузки уборщика прежняя. Порядок записи: строка
`pending` с ключами — commit, PUT в staging, `queued` и задание —
@@ -120,19 +123,32 @@ class AttachmentService:
chat_id=chat_id,
user_id=owner_id,
)
if media_type not in _ACCEPTED_MEDIA_TYPES:
log.info("Rejected attachment", reason="type")
raise exceptions.UnsupportedMediaType
if (
content_length is not None
and content_length > ATTACHMENT_MAX_BYTES
):
log.info(
"Rejected attachment",
reason="declared_size",
declared_size=content_length,
)
raise exceptions.PayloadTooLarge
if media_type not in _ACCEPTED_MEDIA_TYPES:
log.info("Rejected attachment", reason="type")
raise exceptions.UnsupportedMediaType
if (
content_length is not None
and content_length > ATTACHMENT_MAX_BYTES
):
log.info(
"Rejected attachment",
reason="declared_size",
declared_size=content_length,
)
raise exceptions.PayloadTooLarge
backlog_limit = settings.uploads.max_unfinished_jobs
if backlog_limit > 0:
unfinished = await self.uow.jobs.count_unfinished(
limit=backlog_limit,
)
if unfinished >= backlog_limit:
log.info(
"Rejected attachment",
reason="backlog",
unfinished=unfinished,
limit=backlog_limit,
)
raise exceptions.UploadBacklogFull
waiting_since = time.monotonic()
try:
async with self.slots.slot() as waited_ms:
+1
View File
@@ -61,6 +61,7 @@ async def lifespan(_: FastAPI) -> AsyncIterator[None]:
uploads_max_waiting=settings.uploads.max_waiting,
uploads_wait_timeout_seconds=settings.uploads.wait_timeout_seconds,
uploads_body_timeout_seconds=settings.uploads.body_timeout_seconds,
uploads_max_unfinished_jobs=settings.uploads.max_unfinished_jobs,
)
try:
yield
+5
View File
@@ -116,6 +116,11 @@ RECONCILE_PACE_STEP_SECONDS = 0.2
# через LB уходит на следующую реплику (design change `upload-memory`,
# решение 2)
UPLOAD_RETRY_AFTER_SECONDS = 1
# секунды в Retry-After ответа 429, когда достигнут предел незавершённых
# заданий: за 5 с worker завершает 4–15 заданий, повтор через секунду почти
# всегда получил бы тот же 429, а простоя нет: при заполненном пределе работы
# на десятки секунд (design change `track1-queue-overload`, решение 2)
UPLOAD_BACKLOG_RETRY_AFTER_SECONDS = 5
# пагинация
PAGE_LIMIT_MIN = 1
+16
View File
@@ -26,6 +26,10 @@ FAULT_UPLOADS_BASE_URL = os.environ.get("FAULT_UPLOADS_BASE_URL", "").rstrip(
)
# API стенда отказов с коротким сроком вызова S3 (change fix-upload-put-flake)
FAULT_S3_BASE_URL = os.environ.get("FAULT_S3_BASE_URL", "").rstrip("/")
# «узкий по заданиям» API стенда отказов (change track1-queue-overload)
FAULT_BACKLOG_BASE_URL = os.environ.get("FAULT_BACKLOG_BASE_URL", "").rstrip(
"/",
)
FAULT_HOOK_TIMEOUT_S = 120
# срок клиента «узкого» API: больше ожидания места, срока тела и шагов
UPLOADS_CLIENT_TIMEOUT_S = 30
@@ -69,6 +73,7 @@ def pytest_collection_finish(session: pytest.Session) -> None:
and FAULT_TIGHT_BASE_URL
and FAULT_UPLOADS_BASE_URL
and FAULT_S3_BASE_URL
and FAULT_BACKLOG_BASE_URL
):
pytest.exit(
"fault checks need the failure stand and its hook: "
@@ -199,3 +204,14 @@ def s3_api() -> Iterator[Api]:
"""API стенда отказов со сроком вызова S3 1 с (`FAULT_S3_ENV`)."""
with Api(FAULT_S3_BASE_URL, timeout=S3_CLIENT_TIMEOUT_S) as client:
yield client
@pytest.fixture(scope="session")
def backlog_api() -> Iterator[Api]:
"""API стенда отказов с малым пределом незавершённых заданий
(`FAULT_BACKLOG_ENV`)."""
with Api(
FAULT_BACKLOG_BASE_URL,
timeout=UPLOADS_CLIENT_TIMEOUT_S,
) as client:
yield client
+11
View File
@@ -25,6 +25,8 @@
соединения API: их пулы переподключаются
и получают «too many clients» (53300)
clear-connections освободить слоты и дождаться подключения
unfinished-jobs число заданий queued и processing
backlog-api-log журнал «узкого по заданиям» API
db-sessions pg_stat_database.sessions базы стенда:
сколько сессий PostgreSQL приняла за всё
время (учитывает и сессию самого вызова)
@@ -555,6 +557,11 @@ SET_STAGING_KEY_SQL = """\
UPDATE attachments SET staging_key = :'mode'
WHERE id = :'title'::uuid RETURNING id;
"""
# незавершённые задания: то, что считает предел заданий (change
# track1-queue-overload), без обрыва счёта
UNFINISHED_JOBS_SQL = """\
SELECT count(*) FROM attachment_jobs WHERE state IN ('queued', 'processing');
"""
SET_NEXT_ATTEMPT_SQL = """\
UPDATE attachment_jobs
SET next_attempt_at = clock_timestamp() + make_interval(secs => :'mode'::float8)
@@ -1853,6 +1860,10 @@ def run(project: str, action: str, args: list[str]) -> str:
return psql(project, DB_SESSIONS_SQL)
if action == "attachment-ids" and not args:
return psql(project, ATTACHMENT_IDS_SQL)
if action == "unfinished-jobs" and not args:
return psql(project, UNFINISHED_JOBS_SQL)
if action == "backlog-api-log" and not args:
return docker("logs", f"{project}-api-backlog")
if action == "last-pending" and not args:
return psql(project, LAST_PENDING_SQL)
if action == "object-ids" and not args:
+41 -5
View File
@@ -104,6 +104,17 @@ UPLOADS_ENV = {
S3_ENV = {
"S3__TIMEOUT_SECONDS": "1",
}
# проверки копят задания при остановленном worker и под нагрузкой: у четырёх
# API выше предел заданий выключен, иначе он отклонял бы загрузки чужих проверок
# (change track1-queue-overload, design, решение 13)
NO_BACKLOG_ENV = {
"UPLOADS__MAX_UNFINISHED_JOBS": "0",
}
# «узкий по заданиям» API: малый предел, те же пары тест получает в
# `FAULT_BACKLOG_ENV` и сверяет стенд
BACKLOG_ENV = {
"UPLOADS__MAX_UNFINISHED_JOBS": "3",
}
def say(message: str) -> None:
@@ -370,6 +381,7 @@ def main() -> int:
tight_name = f"{project}-api-tight"
uploads_name = f"{project}-api-uploads"
s3_name = f"{project}-api-s3"
backlog_name = f"{project}-api-backlog"
# уборщик с плановой сверкой — его запускает hook run-cleaner (design
# change track2-reconciler, решение 11); убирается вместе с API
scheduled_name = f"{project}-cleaner-scheduled"
@@ -380,6 +392,7 @@ def main() -> int:
tight_name,
uploads_name,
s3_name,
backlog_name,
scheduled_name,
f"{project}-worker-extra",
f"{project}-worker-second-extra",
@@ -447,18 +460,39 @@ def main() -> int:
)
dc(project, "up", "-d", "--no-deps", "relay")
say("start api containers")
base_url = start_api(project, default_name, free_port(), LIMITS_ENV)
tight_url = start_api(project, tight_name, free_port(), TIGHT_ENV)
base_url = start_api(
project,
default_name,
free_port(),
LIMITS_ENV | NO_BACKLOG_ENV,
)
tight_url = start_api(
project,
tight_name,
free_port(),
TIGHT_ENV | NO_BACKLOG_ENV,
)
uploads_url = start_api(
project,
uploads_name,
free_port(),
UPLOADS_ENV,
UPLOADS_ENV | NO_BACKLOG_ENV,
)
s3_url = start_api(
project,
s3_name,
free_port(),
S3_ENV | NO_BACKLOG_ENV,
)
backlog_url = start_api(
project,
backlog_name,
free_port(),
BACKLOG_ENV,
)
s3_url = start_api(project, s3_name, free_port(), S3_ENV)
say(
f"ready: api={base_url} tight={tight_url} uploads={uploads_url} "
f"s3={s3_url}",
f"s3={s3_url} backlog={backlog_url}",
)
env = (
os.environ
@@ -467,11 +501,13 @@ def main() -> int:
"FAULT_TIGHT_BASE_URL": tight_url,
"FAULT_UPLOADS_BASE_URL": uploads_url,
"FAULT_S3_BASE_URL": s3_url,
"FAULT_BACKLOG_BASE_URL": backlog_url,
"FAULT_HOOK": str(FAULT_HOOK),
"FAULT_PROJECT": project,
"FAULT_LIMITS_ENV": env_pairs(LIMITS_ENV),
"FAULT_UPLOADS_ENV": env_pairs(UPLOADS_ENV),
"FAULT_S3_ENV": env_pairs(S3_ENV),
"FAULT_BACKLOG_ENV": env_pairs(BACKLOG_ENV),
}
| storage_names(project)
| timings
+26
View File
@@ -31,6 +31,8 @@ CAPABILITIES = (
# с лабы 5 (design change async-attachments, решение 15)
"attachment-processing",
"message-broker",
# с change track1-queue-overload
"queue-overload",
)
SCENARIO_RE = re.compile(r"^#### Scenario: (.+?)\s*$", re.MULTILINE)
@@ -188,6 +190,30 @@ EXCLUDED: dict[Scenario, Exclusion] = {
"обработки и записи аудита replay в откатываемой транзакции — "
"evidence/attachments/storage.md",
),
**{
("queue-overload", scenario): Exclusion(
reason=(
"нужны открытая нагрузка выше потолка worker, счётчики очереди "
"и контрольный поток, а для рестартов — действие над "
"контейнером посреди неё: это замер, а не проверка по HTTP"
),
check=(
f"make bench_queue: {where} — "
"evidence/queue/baseline/summary.md"
),
)
for scenario, where in (
("Работа копится там, где положено", "шкала очереди ячеек"),
("Приём упирается в места загрузки", "блок accept, H9"),
("Сначала места, затем предел", "блок accept, H9"),
("Контрольный поток под перегрузкой", "контрольный поток, H7"),
("Бэклог уходит за измеренное время", "восстановление, H6"),
("Никого не теряем", "обход метаданных, H6"),
("Время до готовности вернулось", "окна before и after, H6"),
("Worker убит под перегрузкой", "блок kill-worker, H8"),
("Брокер перезапущен под перегрузкой", "блок restart-broker, H8"),
)
},
}
# ссылка исключения на доказательство в репозитории лабы
EVIDENCE_RE = re.compile(r"evidence/[\w./-]+\.md")
+316
View File
@@ -6155,3 +6155,319 @@ def test_defense_faults(
crash_relay_after_confirm(api, stand, alice, chat)
replay_returns_work(api, stand, alice, chat)
replay_ready_refused(api, stand, alice, chat)
# Предел незавершённых заданий (design change `track1-queue-overload`, решение
# 13). Работает пятый API стенда: у прочих предел выключен, и они копят задания,
# пока worker стоит у чужих проверок.
BACKLOG_ENV = dict(
item.split("=", 1)
for item in os.environ.get("FAULT_BACKLOG_ENV", "").split()
)
BACKLOG_LIMIT = int(BACKLOG_ENV.get("UPLOADS__MAX_UNFINISHED_JOBS", "3"))
EXPECTED_BACKLOG_ENV = {"UPLOADS__MAX_UNFINISHED_JOBS": "3"}
BACKLOG_RETRY_AFTER_S = "5"
# обе остальные проверки загрузки на пределе — без тела и без места: быстрее
BACKLOG_REJECT_MAX_S = 1
# прежние проверки могли оставить задание на следующую попытку или аренду
UNFINISHED_WAIT_S = 120
# загрузки в полёте реплики: настройки по умолчанию `[uploads]` пятого API
BACKLOG_IN_FLIGHT = 4 + 16
BACKLOG_CLIENTS = 40
def assert_backlog_stand() -> None:
"""Без малого предела пятого API тесты предела ничего не доказывают."""
assert BACKLOG_ENV == EXPECTED_BACKLOG_ENV, (
f"backlog stand started with {BACKLOG_ENV}, "
f"expected {EXPECTED_BACKLOG_ENV}"
)
def unfinished_jobs(stand: Stand) -> int:
return int(stand("unfinished-jobs"))
def wait_no_unfinished(
stand: Stand,
*,
timeout: float = UNFINISHED_WAIT_S,
) -> None:
"""Незавершённых заданий нет: worker и relay работают."""
deadline = time.monotonic() + timeout
while True:
count = unfinished_jobs(stand)
if count == 0:
return
assert time.monotonic() < deadline, f"{count} unfinished jobs left"
time.sleep(0.5)
def assert_backlog_rejected(resp: httpx.Response, elapsed: float) -> None:
assert_error(resp, 429)
assert resp.headers["Retry-After"] == BACKLOG_RETRY_AFTER_S
assert elapsed < BACKLOG_REJECT_MAX_S, f"429 after {elapsed:.2f}s"
def backlog_records(stand: Stand) -> list[dict[str, Any]]:
return [
json.loads(line)
for line in stand("backlog-api-log").splitlines()
if line.startswith("{")
]
@pytest.mark.spec("queue-overload", "Предел достигнут")
@pytest.mark.spec("queue-overload", "Порядок проверок у предела")
@pytest.mark.spec("queue-overload", "Остальной API у предела")
@pytest.mark.spec("queue-overload", "Загрузки снова принимаются")
def test_backlog_limit(
backlog_api: Api,
stand: Stand,
alice: Actor,
eve: Actor,
chat: dict[str, Any],
) -> None:
assert_backlog_stand()
data = images.sample_png()
finished = backlog_api.upload_ready(alice, chat["id"], data)
wait_no_unfinished(stand)
# 30 MiB, которые начинаются как PNG: Content-Length 31 457 280
big = images.PNG_SIGNATURE + bytes(
3 * images.MAX_BYTES - len(images.PNG_SIGNATURE),
)
with worker_stopped(stand):
accepted = [
backlog_api.upload(alice, chat["id"], data)
for _ in range(BACKLOG_LIMIT)
]
assert unfinished_jobs(stand) == BACKLOG_LIMIT
rows, objects = objects_and_rows(stand)
resp, elapsed = timed(
lambda: upload_raw(backlog_api, alice, chat, data),
)
assert_backlog_rejected(resp, elapsed)
assert resp.headers["X-Request-Id"]
assert resp.headers["X-Instance-Id"]
after_rows, after_objects = objects_and_rows(stand)
assert not new_ids(rows, after_rows)
assert not after_objects - objects
assert unfinished_jobs(stand) == BACKLOG_LIMIT
# порядок проверок: сначала дешёвые, и они раньше предела
assert_error(upload_raw(backlog_api, eve, chat, data), 404)
too_big = upload_raw(backlog_api, alice, chat, big)
assert_error(too_big, 413)
assert too_big.request.headers["Content-Length"] == "31457280"
assert_error(
upload_raw(
backlog_api,
alice,
chat,
data,
content_type="text/plain",
),
415,
)
# остальной API у предела
backlog_api.send_message(alice, chat["id"], "text at the limit")
assert_ok(
backlog_api.messages_page(alice, chat["id"]),
200,
"MessagePage",
)
assert (
backlog_api.attachment_meta(alice, finished["id"]).status_code
== 200
)
assert_content(
backlog_api.attachment_content(alice, finished["id"]),
data,
"image/png",
)
backlog_api.send_message(
alice,
chat["id"],
"",
attachment_ids=[accepted[0]["id"]],
)
ready = backlog_api.request("GET", "/health/ready")
assert ready.status_code == 200, describe(ready)
wait_no_unfinished(stand)
more = backlog_api.upload(alice, chat["id"], data)
for attachment in (*accepted, more):
backlog_api.wait_attachment(
alice,
attachment["id"],
timeout=JOB_WAIT_S,
)
records = backlog_records(stand)
started = next(r for r in records if r.get("event") == "Started API")
assert started["uploads_max_unfinished_jobs"] == BACKLOG_LIMIT
rejected = [
record
for record in records
if record.get("event") == "Rejected attachment"
and record.get("reason") == "backlog"
]
assert rejected, "no backlog rejection in the replica log"
assert rejected[-1]["limit"] == BACKLOG_LIMIT
assert rejected[-1]["unfinished"] >= BACKLOG_LIMIT
@pytest.mark.spec("queue-overload", "Завершённые задания не считаются")
def test_backlog_ignores_finished(
backlog_api: Api,
stand: Stand,
alice: Actor,
chat: dict[str, Any],
) -> None:
assert_backlog_stand()
wait_no_unfinished(stand)
data = images.sample_png()
undecodable = images.jpeg_precision_12()
for _ in range(BACKLOG_LIMIT):
backlog_api.upload_ready(alice, chat["id"], data)
for _ in range(BACKLOG_LIMIT):
failed = backlog_api.upload(
alice,
chat["id"],
undecodable,
content_type="image/jpeg",
)
backlog_api.wait_attachment(
alice,
failed["id"],
status="failed",
timeout=JOB_WAIT_S,
)
wait_no_unfinished(stand)
accepted = backlog_api.upload(alice, chat["id"], data)
backlog_api.wait_attachment(alice, accepted["id"], timeout=JOB_WAIT_S)
@pytest.mark.spec("queue-overload", "Ожидание следующей попытки считается")
def test_backlog_counts_waiting_retry(
backlog_api: Api,
stand: Stand,
alice: Actor,
chat: dict[str, Any],
) -> None:
assert_backlog_stand()
wait_no_unfinished(stand)
data = images.sample_png()
with worker_stopped(stand), relay_stopped(stand):
accepted = [
backlog_api.upload(alice, chat["id"], data)
for _ in range(BACKLOG_LIMIT)
]
# срок следующей попытки далеко: задание ждёт, а не работает
stand("set-next-attempt", accepted[0]["id"], "600")
job = job_row(stand, accepted[0]["id"])
assert job is not None and job["state"] == "queued", job
assert job["next_attempt_at"] is not None, job
resp, elapsed = timed(
lambda: upload_raw(backlog_api, alice, chat, data),
)
assert_backlog_rejected(resp, elapsed)
stand("set-next-attempt", accepted[0]["id"], "0")
for attachment in accepted:
backlog_api.wait_attachment(
alice,
attachment["id"],
timeout=JOB_WAIT_S,
)
@pytest.mark.spec("queue-overload", "Предел при остановленных брокере и relay")
def test_backlog_without_broker(
backlog_api: Api,
stand: Stand,
alice: Actor,
chat: dict[str, Any],
) -> None:
assert_backlog_stand()
wait_no_unfinished(stand)
data = images.sample_png()
accepted = []
with (
worker_stopped(stand),
relay_stopped(stand),
outage(stand, "stop", "rabbitmq"),
):
for _ in range(BACKLOG_LIMIT):
resp, elapsed = timed(
lambda: upload_raw(backlog_api, alice, chat, data),
)
accepted.append(assert_accepted(resp))
assert elapsed < BACKLOG_REJECT_MAX_S, f"202 after {elapsed:.2f}s"
resp, elapsed = timed(
lambda: upload_raw(backlog_api, alice, chat, data),
)
assert_backlog_rejected(resp, elapsed)
for attachment in accepted:
backlog_api.wait_attachment(
alice,
attachment["id"],
timeout=JOB_WAIT_S,
)
@pytest.mark.spec("queue-overload", "Превышение ограничено")
def test_backlog_overshoot_bounded(
backlog_api: Api,
stand: Stand,
alice: Actor,
chat: dict[str, Any],
) -> None:
assert_backlog_stand()
wait_no_unfinished(stand)
base_url = str(backlog_api.client.base_url)
data = images.sample_png()
barrier = threading.Barrier(BACKLOG_CLIENTS)
def upload_at_once(_: int) -> httpx.Response:
with Api(base_url, timeout=THREAD_CLIENT_TIMEOUT_S) as client:
barrier.wait(timeout=30)
return upload_raw(client, alice, chat, data)
with worker_stopped(stand), ThreadPoolExecutor(BACKLOG_CLIENTS) as pool:
answers = list(pool.map(upload_at_once, range(BACKLOG_CLIENTS)))
accepted = [resp.json() for resp in answers if resp.status_code == 202]
statuses = sorted({resp.status_code for resp in answers})
assert set(statuses) <= {202, 429}, statuses
assert (
BACKLOG_LIMIT <= len(accepted) <= BACKLOG_LIMIT + BACKLOG_IN_FLIGHT
), f"accepted {len(accepted)}, statuses {statuses}"
for resp in answers:
if resp.status_code == 429:
assert_error(resp, 429)
for attachment in accepted:
backlog_api.wait_attachment(
alice,
attachment["id"],
timeout=JOB_WAIT_S,
)
@pytest.mark.spec("queue-overload", "Предел выключен")
def test_backlog_off(
api: Api,
stand: Stand,
alice: Actor,
chat: dict[str, Any],
) -> None:
assert_backlog_stand()
wait_no_unfinished(stand)
data = images.sample_png()
with worker_stopped(stand):
accepted = [
api.upload(alice, chat["id"], data)
for _ in range(BACKLOG_LIMIT + 2)
]
assert unfinished_jobs(stand) == BACKLOG_LIMIT + 2
for attachment in accepted:
api.wait_attachment(alice, attachment["id"], timeout=JOB_WAIT_S)