diff --git a/.claude/rules/api-contract.md b/.claude/rules/api-contract.md index 1a33dec2..fbab2273 100644 --- a/.claude/rules/api-contract.md +++ b/.claude/rules/api-contract.md @@ -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) на процесс, очередь diff --git a/.claude/rules/bench.md b/.claude/rules/bench.md index 0aea6b5b..b23bc7a8 100644 --- a/.claude/rules/bench.md +++ b/.claude/rules/bench.md @@ -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//` | | `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 diff --git a/.claude/rules/logging.md b/.claude/rules/logging.md index 1d09f590..33db48f3 100644 --- a/.claude/rules/logging.md +++ b/.claude/rules/logging.md @@ -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» с diff --git a/.claude/rules/repo-layer.md b/.claude/rules/repo-layer.md index 99c0937f..47dd2316 100644 --- a/.claude/rules/repo-layer.md +++ b/.claude/rules/repo-layer.md @@ -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`, diff --git a/.claude/rules/service-layer.md b/.claude/rules/service-layer.md index 271d3f1c..63e7e687 100644 --- a/.claude/rules/service-layer.md +++ b/.claude/rules/service-layer.md @@ -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] diff --git a/.claude/rules/settings.md b/.claude/rules/settings.md index 2bf6dc96..182445a0 100644 --- a/.claude/rules/settings.md +++ b/.claude/rules/settings.md @@ -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; при diff --git a/.claude/rules/student-tests.md b/.claude/rules/student-tests.md index eb5aca76..4b64084f 100644 --- a/.claude/rules/student-tests.md +++ b/.claude/rules/student-tests.md @@ -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`), diff --git a/.claude/rules/worker.md b/.claude/rules/worker.md index 6f966d06..1d88b523 100644 --- a/.claude/rules/worker.md +++ b/.claude/rules/worker.md @@ -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, иначе diff --git a/.claude/skills/run-mtusi-messenger/SKILL.md b/.claude/skills/run-mtusi-messenger/SKILL.md index bde2c6e0..bbff7a83 100644 --- a/.claude/skills/run-mtusi-messenger/SKILL.md +++ b/.claude/skills/run-mtusi-messenger/SKILL.md @@ -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 мин diff --git a/.gitignore b/.gitignore index ed0b25b1..581bcf4f 100644 --- a/.gitignore +++ b/.gitignore @@ -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 на пробных метках diff --git a/AGENTS.md b/AGENTS.md index 523e6844..2fe9dd4f 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -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_`: настоящая единица работы, тот же контракт repo на SQL, соединение на шаг и общий срок JSON-запроса в процессе (S3 и кэш — фейки), замороженный сервер — TCP-прокси; база удаляется при любом исходе, имя не по шаблону — код 2 | | `make test_isolated [KEEP_TEST_DB=1]` | образ на временной базе `test_` с Valkey и S3 стенда (ключи кэша и объектов разделены именем базы): сборка, миграции, отдельный контейнер API на `TEST_APP_PORT`, `make test` + `make student_test EXPECT_REPLICAS=1` (тесты реплик пропускаются с причиной), уборка при любом исходе — база и объекты под префиксом `test_/` (`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//` | | `make bench_ab BEFORE=... AFTER=... REAPPLY= [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/.py # SqlAlchemyRepository: одна атомарная операция на метод; 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 на запрос старых и новых реплик) diff --git a/Makefile b/Makefile index 6fccb3f1..90c2b192 100644 --- a/Makefile +++ b/Makefile @@ -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 diff --git a/QUESTIONS.md b/QUESTIONS.md index d5a87e5e..2d3a4031 100644 --- a/QUESTIONS.md +++ b/QUESTIONS.md @@ -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). ### Вопросы diff --git a/REPORT.md b/REPORT.md index 12e563df..3512c6bf 100644 --- a/REPORT.md +++ b/REPORT.md @@ -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 + доля ожидания, (лимит − база) / пик процесса)`. + ### Отказы | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | diff --git a/bench/k6/queue.js b/bench/k6/queue.js new file mode 100644 index 00000000..bad40182 --- /dev/null +++ b/bench/k6/queue.js @@ -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,<окно>,<отправка мс>,<длительность мс>,<статус>,,, +// » — в файл консоли (--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); +} diff --git a/bench/k6/queue_sweep.js b/bench/k6/queue_sweep.js new file mode 100644 index 00000000..a8603853 --- /dev/null +++ b/bench/k6/queue_sweep.js @@ -0,0 +1,81 @@ +// Обход принятых вложений профиля очереди (design change track1-queue-overload, +// решение 9): истина о готовности — метаданные GET /attachments/{id}, опрос в +// замере не нужен: updated_at у ready не меняется после фиксации. Строка на +// вложение «qs,,,,,,»; у +// выборки (первые SAMPLE ids, порядок задал оркестратор от зерна) — оригинал и +// варианты с SHA-256 из метаданных: «qv,,<имя>,<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); +} diff --git a/bench/make_images.py b/bench/make_images.py new file mode 100644 index 00000000..8f73c15f --- /dev/null +++ b/bench/make_images.py @@ -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()) diff --git a/bench/overload.py b/bench/overload.py new file mode 100644 index 00000000..a62827f9 --- /dev/null +++ b/bench/overload.py @@ -0,0 +1,2173 @@ +"""Профиль очереди без docker (design change `track1-queue-overload`, решения +5–8, 11, 12): план кругами, разбор строк k6, сэмплера и журналов, строка ячейки и +посекундная шкала, пометки, вердикты H1–H9, правило рекомендации, сводка и +графики. Только stdlib; `--selftest`. Имя не `queue.py`: каталог скрипта первый в +`sys.path`, и `queue` затенил бы модуль stdlib. +""" + +from __future__ import annotations + +import csv +import json +import random +import sys +from collections.abc import Iterable, Mapping +from dataclasses import dataclass, field +from pathlib import Path +from typing import Any + +import plots +import reconcile + +WINDOWS = ("before", "over", "after") +CONTROL_WINDOWS = ("before", "over", "recovery", "after") +CONTROL_KINDS = {"w": "write", "r": "read", "d": "download"} +CONTROL_STATS = ("n", "errors", "s5xx", "p50", "p95", "p99") +ROLES = ( + "worker", + "s3", + "postgres", + "api", + "relay", + "rabbitmq", + "cleaner", + "haproxy", +) +# пометки, при которых метка не зелёная: система потеряла работу (решение 11) +FATAL_FLAGS = ("lost", "stuck", "duplicate", "sha_mismatch") +DEFAULT_SETTING = (2, 2) +MIB = 2**20 +CONFIRMED = "подтверждено" +REFUTED = "нет" +NO_DATA = "нет данных" +BACKLOG_RETRY_AFTER = "5" +# запас превышения предела: загрузки в полёте двух реплик (решение 3) +IN_FLIGHT = 40 +LEASE_S = 70 +# окно CPU S3 блока accept: до срабатывания предела (гипотеза H9) +ACCEPT_S3_WINDOW_S = 30 + +CELL_FIELDS = [ + "cell", + "config", + "block", + "class", + "concurrency", + "prefetch", + "repeat", + "order", + "rate_low", + "rate_high", + "over_s", + "limit", + "action", + "accepted", + "s202", + "s429", + "s5xx", + "s_other", + "s_conn", + "dropped", + "accepted_before", + "accepted_over", + "accepted_after", + "retry_after", + "busy_429", + "backlog_429", + "first_busy_s", + "first_backlog_s", + "upload_before_p50_ms", + "upload_over_p50_ms", + "upload_over_p95_ms", + "ready", + "failed", + "lost", + "stuck", + "duplicate", + "sha_checked", + "sha_bad", + "ready_s_over", + "ready_s_recovery", + "over_end", + "zero_at", + "action_at", + "recovery_s", + "peak_unfinished", + "peak_outbox", + "peak_waiting", + "peak_published", + "peak_processing", + "peak_broker_ready", + "peak_broker_unacked", + "peak_prefetched", + "peak_oldest_s", + "staging_ready_end", + "queue_left", + "ready_before_p50_s", + "ready_before_p95_s", + "ready_before_p99_s", + "ready_over_p50_s", + "ready_over_p95_s", + "ready_over_p99_s", + "ready_after_p50_s", + "ready_after_p95_s", + "ready_after_p99_s", + "ready_before_list", + "ready_after_list", + "queue_wait_p50_ms", + "queue_wait_p95_ms", + "duration_p50_ms", + "render_p50_ms", + "worker_hwm_mib", + "render_peak_p50_mib", + "render_peak_max_mib", + "memory_peak_mib", + "anon_max_mib", + "oom_kill", + "worker_restarts", + *[f"cpu_{role}_over" for role in ROLES], + *[f"cpu_{role}_recovery" for role in ROLES], + *[f"throttle_{role}_over" for role in ("worker", "s3")], + "cpu_s3_accept", + "cpu_worker_per_job_s", + "broker_memory_mib", + "broker_refused", + "attempts_over_one", + "skipped", + "relay_published", + "relay_republished", + "relay_recovered", + "relay_backlog_full", + "failed_by", + "second_jobs", + "second_share", + *[ + f"ctrl_{kind}_{window}_{stat}" + for kind in CONTROL_KINDS.values() + for window in CONTROL_WINDOWS + for stat in CONTROL_STATS + ], + "swapouts", + "lb_down", + "flags", +] +TIMELINE_FIELDS = [ + "cell", + "t", + "window", + "outbox", + "waiting", + "published", + "processing", + "unfinished", + "broker_ready", + "broker_unacked", + "prefetched", + "oldest_s", + "staging_ready", + "accepted", + "ready", +] + + +# ------------------------------------------------------------------ план + + +def config_key( + block: str, + klass: str, + concurrency: int, + prefetch: int, +) -> str: + setting = f"{klass}-c{concurrency}p{prefetch}" + return setting if block == "matrix" else f"{block}-{setting}" + + +def plan_cells( + configs: Iterable[Mapping[str, Any]], + repeats: int, + seed: int, +) -> list[dict[str, Any]]: + """Круги: на круге — перестановка конфигураций от зерна; круг не начинается + с той, на которой кончился прошлый (как `scaling.plan_cells`).""" + items = list(configs) + plan: list[dict[str, Any]] = [] + previous = None + for round_no in range(1, repeats + 1): + order = list(range(len(items))) + random.Random(seed + round_no).shuffle(order) + if len(order) > 1 and order[0] == previous: + order[0], order[1] = order[1], order[0] + for index in order: + item = dict(items[index]) + key = config_key( + item["block"], + item["class"], + item["concurrency"], + item["prefetch"], + ) + plan.append( + { + **item, + "cell": f"{key}-r{round_no}", + "config": key, + "repeat": round_no, + "order": len(plan) + 1, + }, + ) + previous = order[-1] if order else None + return plan + + +# --------------------------------------------------------- разбор источников + + +@dataclass(frozen=True) +class Upload: + window: str + start_ms: int + duration_ms: int + status: int + retry_after: str + instance: str + attachment_id: str + + @property + def answered(self) -> float: + return (self.start_ms + self.duration_ms) / 1000 + + +@dataclass(frozen=True) +class JobTick: + t: float + outbox: int + waiting: int + published: int + processing: int + oldest_s: float + staging_ready: int + + @property + def unfinished(self) -> int: + return self.outbox + self.waiting + self.published + self.processing + + +@dataclass(frozen=True) +class Meta: + http: int + status: str + error_code: str + variants: int + updated_at: float | None + + +@dataclass +class Sources: + """Всё снятое за ячейку; сюда же — готовые разборы журналов.""" + + uploads: list[Upload] + t0: float + metas: dict[str, Meta] + sha_checks: list[bool] + jobs: list[JobTick] + mq: list[tuple[float, int, int]] + mq_missing: int + cg: dict[str, list[list[tuple[int, ...]]]] + mp: dict[str, list[list[tuple[int, ...]]]] + control: list[Any] + worker_records: list[dict[str, Any]] + second_records: list[dict[str, Any]] + relay_records: list[dict[str, Any]] + api_records: list[dict[str, Any]] + sql: dict[str, Any] + hwm_kib: int | None = None + restarts: int = 0 + dropped: int = 0 + action_at: float | None = None + swapouts: int | None = None + lb_down: bool = False + storage_down: bool = False + extra: dict[str, Any] = field(default_factory=dict) + + +def parse_uploads(text: str) -> tuple[float | None, list[Upload]]: + """Строки `q-t0,<мс>` и `q,<окно>,<мс>,<мс>,<статус>,,<реплика>,`.""" + t0 = None + out = [] + for raw in text.splitlines(): + line = raw.strip() + if line.startswith("q-t0,"): + t0 = int(line.split(",")[1]) / 1000 + elif line.startswith("q,"): + parts = line.split(",") + if len(parts) == 8: + out.append( + Upload( + parts[1], + int(parts[2]), + int(parts[3]), + int(parts[4]), + parts[5], + parts[6], + parts[7], + ), + ) + return t0, out + + +def parse_sweep(text: str) -> tuple[dict[str, Meta], list[bool]]: + metas: dict[str, Meta] = {} + checks: list[bool] = [] + for raw in text.splitlines(): + parts = raw.strip().split(",") + if parts[0] == "qs" and len(parts) == 7: + updated = ( + None if parts[6] == "-" else reconcile.timestamp(parts[6]) + ) + metas[parts[1]] = Meta( + int(parts[2]), + parts[3], + parts[4], + int(parts[5]), + updated, + ) + elif parts[0] == "qv" and len(parts) == 4: + checks.append(parts[3] == "1") + return metas, checks + + +def parse_jobs(text: str) -> list[JobTick]: + out = [] + for line in text.splitlines(): + parts = line.strip().split("|") + if len(parts) == 8 and parts[0] == "jobs": + out.append( + JobTick( + int(parts[1]) / 1000, + int(parts[2]), + int(parts[3]), + int(parts[4]), + int(parts[5]), + float(parts[6]), + int(parts[7]), + ), + ) + return out + + +def parse_mq(text: str) -> tuple[list[tuple[float, int, int]], int]: + """Строки `mq`: значения и число `missing` (брокер не ответил).""" + out = [] + missing = 0 + for line in text.splitlines(): + parts = line.split(" ") + if parts[0] != "mq": + continue + if len(parts) == 3 and parts[2] == "missing": + missing += 1 + elif len(parts) == 4: + out.append( + ( + int(parts[1]) / 1e9, + int(float(parts[2])), + int(float(parts[3])), + ), + ) + return out, missing + + +def parse_mp(text: str) -> dict[str, list[tuple[int, ...]]]: + """Строки `mp <нс> ` по контейнерам.""" + out: dict[str, list[tuple[int, ...]]] = {} + for line in text.splitlines(): + parts = line.split(" ") + if parts[0] == "mp" and len(parts) == 6: + out.setdefault(parts[2], []).append( + (int(parts[1]), *(int(v) for v in parts[3:6])), + ) + return out + + +def split_lives( + points: list[tuple[int, ...]], + key: int = 1, +) -> list[list[tuple[int, ...]]]: + """Жизни контейнера: перезапуск сбрасывает cgroup того же контейнера, и + счётчик `points[i][key]` падает (решение 10).""" + lives: list[list[tuple[int, ...]]] = [] + for point in points: + if lives and point[key] >= lives[-1][-1][key]: + lives[-1].append(point) + else: + lives.append([point]) + return lives + + +def lives_delta( + lives: Iterable[list[tuple[int, ...]]], + w0: float, + w1: float, + key: int = 1, +) -> float | None: + """Разность счётчика за окно [w0, w1] (секунды) — сумма разностей внутри + жизней, на краях окна — линейно между соседними отсчётами: тик сэмплера не + совпадает с краем, и разность только по внутренним отсчётам занижала бы + короткое окно на ~10 %. Окно не задевает ни одну жизнь — `None`.""" + + def value_at(life: list[tuple[int, ...]], ns: float) -> float: + for prev, cur in zip(life, life[1:], strict=False): + if prev[0] <= ns <= cur[0]: + share = (ns - prev[0]) / ((cur[0] - prev[0]) or 1) + return prev[key] + (cur[key] - prev[key]) * share + return float(life[-1][key]) + + total = 0.0 + seen = False + for life in lives: + if len(life) < 2: + continue + a, b = max(w0 * 1e9, life[0][0]), min(w1 * 1e9, life[-1][0]) + if b > a: + total += value_at(life, b) - value_at(life, a) + seen = True + return total if seen else None + + +def role_cores( + lives_by_container: Iterable[list[list[tuple[int, ...]]]], + w0: float, + w1: float, +) -> float | None: + """Ядер роли за окно: сумма по контейнерам, `usage_usec` — столбец 1.""" + if w1 <= w0: + return None + total = None + for lives in lives_by_container: + delta = lives_delta(lives, w0, w1) + if delta is not None: + total = (total or 0.0) + delta + return None if total is None else round(total / 1e6 / (w1 - w0), 4) + + +def throttle_share( + lives: Iterable[list[tuple[int, ...]]], + w0: float, + w1: float, +) -> float | None: + """Доля периодов с троттлингом: столбцы 2 (`nr_periods`), 3 (`nr_throttled`).""" + lives = list(lives) + periods = lives_delta(lives, w0, w1, key=2) + throttled = lives_delta(lives, w0, w1, key=3) + if not periods or throttled is None: + return None + return round(throttled / periods, 4) + + +def memory_by_lives( + lives: Iterable[list[tuple[int, ...]]], +) -> tuple[float | None, float | None, int]: + """`memory.peak` и `anon` — наибольшее по жизням, `oom_kill` — сумма: у + каждой жизни считается наибольшее значение.""" + peak = anon = None + kills = 0 + for life in lives: + peak = max([p[1] for p in life] + ([peak] if peak is not None else [])) + anon = max([p[2] for p in life] + ([anon] if anon is not None else [])) + kills += max(p[3] for p in life) + return ( + None if peak is None else round(peak / MIB, 1), + None if anon is None else round(anon / MIB, 1), + kills, + ) + + +def events( + records: Iterable[Mapping[str, Any]], + name: str, +) -> list[Mapping[str, Any]]: + return [item for item in records if item.get("event") == name] + + +def rejected_by_reason( + records: Iterable[Mapping[str, Any]], + reason: str, +) -> list[float]: + """Моменты отказов «Rejected attachment» с этой причиной, по времени.""" + return sorted( + reconcile.timestamp(item["timestamp"]) + for item in events(records, "Rejected attachment") + if item.get("reason") == reason and item.get("timestamp") + ) + + +def rounded(value: float | None, digits: int = 2) -> float | None: + return None if value is None else round(value, digits) + + +def percentile(values: list[float], q: float, digits: int = 2) -> float | None: + return rounded(reconcile.percentile(values, q), digits) + + +# ---------------------------------------------------------------- ячейка + + +def control_columns( + requests: list[Any], + bounds: Mapping[str, tuple[float, float]], +) -> dict[str, Any]: + out: dict[str, Any] = {} + for kind, name in CONTROL_KINDS.items(): + for window, (w0, w1) in bounds.items(): + stats = reconcile.window_stats(requests, kind, w0, w1) + prefix = f"ctrl_{name}_{window}" + out[f"{prefix}_n"] = stats["responses"] + out[f"{prefix}_errors"] = stats["errors"] + out[f"{prefix}_s5xx"] = stats["s5xx"] + out[f"{prefix}_p50"] = rounded(stats["p50_ms"], 1) + out[f"{prefix}_p95"] = rounded(stats["p95_ms"], 1) + out[f"{prefix}_p99"] = rounded(stats["p99_ms"], 1) + return out + + +def cell_row(cell: Mapping[str, Any], src: Sources) -> dict[str, Any]: + """Строка `cells.csv`. Окна — от начала `q-t0`: `before`, `over`, затем + `recovery` до нуля незавершённых.""" + before_s = cell["before_s"] + over_s = cell["over_s"] + over_start = src.t0 + before_s + over_end = over_start + over_s + answers = src.uploads + in_over = [u for u in answers if u.window == "over"] + # последняя загрузка окна: её ответ — конец приёма + load_end = max((u.answered for u in in_over), default=over_end) + zero_at = next( + (t.t for t in src.jobs if t.t >= load_end and t.unfinished == 0), + None, + ) + recovery_end = zero_at if zero_at is not None else load_end + accepted = [u for u in answers if u.status == 202] + statuses = [u.status for u in answers] + metas = src.metas + ready = [m for m in metas.values() if m.status == "ready"] + failed = [m for m in metas.values() if m.status == "failed"] + lost = sum( + 1 + for u in accepted + if u.attachment_id not in metas or metas[u.attachment_id].http != 200 + ) + stuck = sum( + 1 + for u in accepted + if u.attachment_id in metas + and metas[u.attachment_id].http == 200 + and metas[u.attachment_id].status not in ("ready", "failed") + ) + ready_at = [m.updated_at for m in ready if m.updated_at is not None] + + def per_second(w0: float, w1: float) -> float | None: + if w1 <= w0: + return None + return round(sum(1 for t in ready_at if w0 <= t < w1) / (w1 - w0), 3) + + waits: dict[str, list[float]] = {window: [] for window in WINDOWS} + for upload in accepted: + meta = metas.get(upload.attachment_id) + if meta and meta.status == "ready" and meta.updated_at is not None: + waits[upload.window].append(meta.updated_at - upload.answered) + + jobs_over = [t for t in src.jobs if src.t0 <= t.t <= recovery_end] + peak = { + name: max((getattr(t, name) for t in jobs_over), default=None) + for name in ( + "unfinished", + "outbox", + "waiting", + "published", + "processing", + "oldest_s", + ) + } + mq_inside = [m for m in src.mq if src.t0 <= m[0] <= recovery_end] + # неподтверждённые против взятых: ближайший по времени тик заданий + prefetched = 0 + for moment, _, unacked in mq_inside: + nearest = min(src.jobs, key=lambda t: abs(t.t - moment), default=None) + if nearest is not None: + prefetched = max(prefetched, unacked - nearest.processing) + + worker_ready = events(src.worker_records, "Attachment became ready") + second_ready = events(src.second_records, "Attachment became ready") + both_ready = [*worker_ready, *second_ready] + started_jobs = events( + [*src.worker_records, *src.second_records], + "Started job attempt", + ) + queue_waits = [ + float(item["queue_wait_ms"]) + for item in started_jobs + if item.get("queue_wait_ms") is not None + ] + durations = [float(i["duration_ms"]) for i in both_ready] + renders = [float(i["render_ms"]) for i in both_ready if i.get("render_ms")] + render_peaks = [ + float(i["render_peak_kib"]) / 1024 + for i in both_ready + if i.get("render_peak_kib") + ] + skipped: dict[str, int] = {} + for item in events(src.worker_records, "Skipped job message"): + reason = str(item.get("reason")) + skipped[reason] = skipped.get(reason, 0) + 1 + relay_passes = events(src.relay_records, "Relay pass") + busy = rejected_by_reason(src.api_records, "busy") + backlog = rejected_by_reason(src.api_records, "backlog") + retry_values = sorted( + {u.retry_after for u in answers if u.status == 429}, + ) + + worker_lives = src.cg.get("worker", []) + # только основной контейнер worker: лимит памяти у второго свой + peak_mem, anon_mem, kills = memory_by_lives(src.mp.get("worker", [])) + # процесс 1, завершённый ядром, уносит cgroup раньше следующего тика: его + # счётчик не прочитать, а политика перезапускает только аварийный выход + kills += src.restarts + per_job = None + delta = lives_delta( + [life for lives in worker_lives for life in lives], + src.t0, + recovery_end, + ) + if delta is not None and ready_at: + per_job = round(delta / 1e6 / len(ready_at), 3) + + row: dict[str, Any] = { + key: cell.get(key) + for key in ( + "cell", + "config", + "block", + "class", + "concurrency", + "prefetch", + "repeat", + "order", + "rate_low", + "rate_high", + "over_s", + "limit", + "action", + ) + } + row.update( + { + "accepted": len(accepted), + "s202": statuses.count(202), + "s429": statuses.count(429), + "s5xx": sum(1 for s in statuses if 500 <= s < 600), + "s_other": sum( + 1 + for s in statuses + if s not in (0, 202, 429) and not 500 <= s < 600 + ), + "s_conn": statuses.count(0), + "dropped": src.dropped, + "accepted_before": sum( + 1 for u in accepted if u.window == "before" + ), + "accepted_over": sum(1 for u in accepted if u.window == "over"), + "accepted_after": sum(1 for u in accepted if u.window == "after"), + "retry_after": " ".join(retry_values), + "busy_429": len(busy), + "backlog_429": len(backlog), + "first_busy_s": rounded(busy[0] - over_start) if busy else None, + "first_backlog_s": ( + rounded(backlog[0] - over_start) if backlog else None + ), + "upload_before_p50_ms": percentile( + [u.duration_ms for u in accepted if u.window == "before"], + 50, + 1, + ), + "upload_over_p50_ms": percentile( + [u.duration_ms for u in accepted if u.window == "over"], + 50, + 1, + ), + "upload_over_p95_ms": percentile( + [u.duration_ms for u in accepted if u.window == "over"], + 95, + 1, + ), + "ready": len(ready), + "failed": len(failed), + "lost": lost, + "stuck": stuck, + "duplicate": src.sql.get("extra_jobs", 0) + + src.sql.get("bad_variants", 0), + "sha_checked": len(src.sha_checks), + "sha_bad": src.sha_checks.count(False), + "ready_s_over": per_second(over_start, over_end), + "ready_s_recovery": per_second(over_end, recovery_end), + "over_end": round(over_end, 3), + "zero_at": rounded(zero_at, 3), + "action_at": rounded(src.action_at, 3), + "recovery_s": ( + rounded(zero_at - load_end) if zero_at is not None else None + ), + "peak_unfinished": peak["unfinished"], + "peak_outbox": peak["outbox"], + "peak_waiting": peak["waiting"], + "peak_published": peak["published"], + "peak_processing": peak["processing"], + "peak_broker_ready": max((m[1] for m in mq_inside), default=None), + "peak_broker_unacked": max( + (m[2] for m in mq_inside), + default=None, + ), + "peak_prefetched": prefetched, + "peak_oldest_s": peak["oldest_s"], + "staging_ready_end": ( + src.jobs[-1].staging_ready if src.jobs else None + ), + "queue_left": sum(src.mq[-1][1:]) if src.mq else None, + "ready_before_list": " ".join(f"{v:.2f}" for v in waits["before"]), + "ready_after_list": " ".join(f"{v:.2f}" for v in waits["after"]), + "queue_wait_p50_ms": percentile(queue_waits, 50, 0), + "queue_wait_p95_ms": percentile(queue_waits, 95, 0), + "duration_p50_ms": percentile(durations, 50, 0), + "render_p50_ms": percentile(renders, 50, 0), + "worker_hwm_mib": ( + round(src.hwm_kib / 1024, 1) if src.hwm_kib else None + ), + "render_peak_p50_mib": percentile(render_peaks, 50, 1), + "render_peak_max_mib": rounded( + max(render_peaks, default=None), + 1, + ), + "memory_peak_mib": peak_mem, + "anon_max_mib": anon_mem, + "oom_kill": kills, + "worker_restarts": src.restarts, + "cpu_s3_accept": role_cores( + src.cg.get("s3", []), + over_start, + min(over_end, over_start + ACCEPT_S3_WINDOW_S), + ), + "cpu_worker_per_job_s": per_job, + "broker_memory_mib": src.extra.get("broker_memory_mib"), + "broker_refused": src.extra.get("broker_refused", 0), + "attempts_over_one": src.sql.get("attempts_over_one"), + "skipped": json.dumps(skipped, sort_keys=True), + "relay_published": sum( + i.get("published", 0) for i in relay_passes + ), + "relay_republished": sum( + i.get("republished", 0) for i in relay_passes + ), + "relay_recovered": sum( + i.get("recovered", 0) for i in relay_passes + ), + "relay_backlog_full": len( + events(src.relay_records, "Relay backlog is full"), + ), + "failed_by": json.dumps(src.sql.get("failed", {}), sort_keys=True), + "second_jobs": len(second_ready) if src.second_records else None, + "swapouts": src.swapouts, + "lb_down": int(src.lb_down), + }, + ) + for window in WINDOWS: + for q in (50, 95, 99): + row[f"ready_{window}_p{q}_s"] = percentile(waits[window], q) + for role in ROLES: + lives = src.cg.get(role, []) + row[f"cpu_{role}_over"] = role_cores(lives, over_start, over_end) + row[f"cpu_{role}_recovery"] = role_cores(lives, over_end, recovery_end) + for role in ("worker", "s3"): + row[f"throttle_{role}_over"] = throttle_share( + [life for lives in src.cg.get(role, []) for life in lives], + over_start, + over_end, + ) + action_at = src.extra.get("second_started_at") + if action_at is not None and src.second_records: + # только разбор накопленного: окно after делится поровну при любом + # prefetch и смазывало бы опыт (design, «Уточнения apply», п. 2) + def in_backlog(item: Mapping[str, Any]) -> bool: + moment = reconcile.timestamp(item["timestamp"]) + return action_at <= moment <= recovery_end + + after = sum(1 for item in both_ready if in_backlog(item)) + taken = sum(1 for item in second_ready if in_backlog(item)) + row["second_jobs"] = taken + row["second_share"] = round(taken / after, 3) if after else None + after_start = src.extra.get("after_start") + after_end = src.extra.get("after_end") + bounds = { + "before": (src.t0, over_start), + "over": (over_start, over_end), + "recovery": (over_end, recovery_end), + "after": (after_start or recovery_end, after_end or recovery_end), + } + row.update(control_columns(src.control, bounds)) + row["flags"] = " ".join( + cell_flags(row, zero_at is None, src.storage_down), + ) + return row + + +def cell_flags( + row: Mapping[str, Any], + not_recovered: bool, + storage_down: bool, +) -> list[str]: + """Пометки решения 11.""" + flags = [] + if num(row.get("oom_kill")): + flags.append("oom") + if num(row.get("worker_restarts")): + flags.append("worker_restart") + if num(row.get("lost")): + flags.append("lost") + if num(row.get("stuck")): + flags.append("stuck") + if num(row.get("duplicate")): + flags.append("duplicate") + if num(row.get("sha_bad")): + flags.append("sha_mismatch") + if not_recovered: + flags.append("not_recovered") + if num(row.get("failed")): + flags.append("failed") + if num(row.get("dropped")): + flags.append("dropped") + if num(row.get("lb_down")): + flags.append("lb_down") + if num(row.get("swapouts")): + flags.append("host_swap") + if storage_down: + flags.append("storage_down") + return flags + + +def timeline_rows( + cell: Mapping[str, Any], + src: Sources, +) -> list[dict[str, Any]]: + """Посекундная шкала от `q-t0`: окно, очередь в трёх местах, принято и + готово за секунду.""" + over_start = src.t0 + cell["before_s"] + over_end = over_start + cell["over_s"] + after_start = src.extra.get("after_start") + accepted: dict[int, int] = {} + for upload in src.uploads: + if upload.status == 202: + second = int(upload.answered - src.t0) + accepted[second] = accepted.get(second, 0) + 1 + ready: dict[int, int] = {} + for meta in src.metas.values(): + if meta.status == "ready" and meta.updated_at is not None: + second = int(meta.updated_at - src.t0) + ready[second] = ready.get(second, 0) + 1 + mq = {int(m[0] - src.t0): m for m in src.mq} + rows = [] + for tick in src.jobs: + if tick.t < src.t0: + continue + second = int(tick.t - src.t0) + if tick.t < over_start: + window = "before" + elif tick.t < over_end: + window = "over" + elif after_start is None or tick.t < after_start: + window = "recovery" + else: + window = "after" + broker = mq.get(second) + rows.append( + { + "cell": cell["cell"], + "t": second, + "window": window, + "outbox": tick.outbox, + "waiting": tick.waiting, + "published": tick.published, + "processing": tick.processing, + "unfinished": tick.unfinished, + "broker_ready": broker[1] if broker else None, + "broker_unacked": broker[2] if broker else None, + "prefetched": ( + max(0, broker[2] - tick.processing) if broker else None + ), + "oldest_s": tick.oldest_s, + "staging_ready": tick.staging_ready, + "accepted": accepted.get(second, 0), + "ready": ready.get(second, 0), + }, + ) + return rows + + +# --------------------------------------------------------------- вердикты + + +def read_csv(path: Path) -> list[dict[str, Any]]: + if not path.exists(): + return [] + with path.open(encoding="utf-8", newline="") as file: + return list(csv.DictReader(file)) + + +def num(value: Any) -> float | None: + return reconcile.num(value) + + +def med(rows: Iterable[Mapping[str, Any]], key: str) -> float | None: + return reconcile.med(row.get(key) for row in rows) + + +def select( + rows: Iterable[Mapping[str, Any]], + *, + block: str = "matrix", + klass: str | None = None, + setting: tuple[int, int] | None = None, +) -> list[Mapping[str, Any]]: + found = [] + for row in rows: + if row.get("block") != block: + continue + if klass is not None and row.get("class") != klass: + continue + if setting is not None and ( + num(row.get("concurrency")) != setting[0] + or num(row.get("prefetch")) != setting[1] + ): + continue + found.append(row) + return found + + +def flagged(row: Mapping[str, Any], flag: str) -> bool: + return flag in (row.get("flags") or "").split() + + +def classes_of(rows: Iterable[Mapping[str, Any]]) -> list[str]: + return sorted({r["class"] for r in rows if r.get("block") == "matrix"}) + + +def ratio(a: float | None, b: float | None) -> float | None: + return None if a is None or not b else a / b + + +class Check: + """Условия гипотезы: `нет данных`, если нечем проверить условие; `нет` — если + условие нарушено, и причина названа.""" + + def __init__(self) -> None: + self.failed: list[str] = [] + self.missing: list[str] = [] + self.passed = 0 + + def within( + self, + name: str, + value: float | None, + low: float | None, + high: float | None, + ) -> None: + if value is None: + self.missing.append(name) + elif (low is not None and value < low) or ( + high is not None and value > high + ): + self.failed.append(f"{name} = {value:.3g}") + else: + self.passed += 1 + + def true(self, name: str, value: bool | None) -> None: + if value is None: + self.missing.append(name) + elif not value: + self.failed.append(name) + else: + self.passed += 1 + + def verdict(self) -> tuple[str, str]: + if self.failed: + return REFUTED, "; ".join(self.failed[:6]) + if self.missing: + return NO_DATA, "нет: " + ", ".join(self.missing[:6]) + if not self.passed: + return NO_DATA, "нет ячеек" + return CONFIRMED, f"условий: {self.passed}" + + +def h1(rows: list[Mapping[str, Any]]) -> Check: + check = Check() + for klass in classes_of(rows): + base = select(rows, klass=klass, setting=(2, 2)) + wide = select(rows, klass=klass, setting=(4, 4)) + check.within( + f"{klass}: (4,4)/(2,2) throughput", + ratio( + med(wide, "ready_s_recovery"), + med(base, "ready_s_recovery"), + ), + None, + 1.05, + ) + for row in select(rows): + if (num(row.get("concurrency")) or 0) >= 2: + check.within( + f"{row['cell']}: CPU worker", + num(row.get("cpu_worker_over")), + 0.85, + None, + ) + for klass in ("m", "lp"): + base = select(rows, klass=klass, setting=(2, 2)) + small = select(rows, klass=klass, setting=(1, 1)) + check.within( + f"{klass}: (1,1)/(2,2) throughput", + ratio( + med(small, "ready_s_recovery"), + med(base, "ready_s_recovery"), + ), + None, + 1.0, + ) + return check + + +def h2(rows: list[Mapping[str, Any]]) -> Check: + check = Check() + limit = 1024.0 + for klass in classes_of(rows): + base = select(rows, klass=klass, setting=(2, 2)) + wide = select(rows, klass=klass, setting=(4, 4)) + check.within( + f"{klass}: duration (4,4)/(2,2)", + ratio(med(wide, "duration_p50_ms"), med(base, "duration_p50_ms")), + 1.5, + None, + ) + for row in base: + check.within( + f"{row['cell']}: memory.peak", + num(row.get("memory_peak_mib")), + None, + limit - 0.001, + ) + check.true(f"{row['cell']}: без oom", not flagged(row, "oom")) + wide_lp = select(rows, klass="lp", setting=(4, 4)) + for row in wide_lp: + check.within( + f"{row['cell']}: memory.peak", + num(row.get("memory_peak_mib")), + 0.95 * limit, + None, + ) + check.true( + "lp (4,4): oom хотя бы в одном повторе", + any(flagged(r, "oom") for r in wide_lp) if wide_lp else None, + ) + wide_lj = select(rows, klass="lj", setting=(4, 4)) + for row in wide_lj: + check.true(f"{row['cell']}: без oom", not flagged(row, "oom")) + check.within( + f"{row['cell']}: memory.peak", + num(row.get("memory_peak_mib")), + None, + 500, + ) + if not wide_lj: + check.missing.append("lj (4,4)") + return check + + +def h3(rows: list[Mapping[str, Any]]) -> Check: + check = Check() + for klass in ("s", "lp"): + base = select(rows, klass=klass, setting=(2, 2)) + big = select(rows, klass=klass, setting=(2, 256)) + check.within( + f"{klass}: throughput (2,256)/(2,2)", + ratio(med(big, "ready_s_recovery"), med(base, "ready_s_recovery")), + 0.85, + 1.15, + ) + check.within( + f"{klass}: p95 (2,256)/(2,2)", + ratio(med(big, "ready_over_p95_s"), med(base, "ready_over_p95_s")), + 0.8, + 1.25, + ) + for row in big: + check.within( + f"{row['cell']}: broker_ready / пик", + ratio( + num(row.get("peak_broker_ready")), + num(row.get("peak_unfinished")), + ), + None, + 0.10, + ) + for row in base: + check.within( + f"{row['cell']}: broker_ready / пик", + ratio( + num(row.get("peak_broker_ready")), + num(row.get("peak_unfinished")), + ), + 0.70, + None, + ) + p2 = select(rows, block="w2-p2") + p256 = select(rows, block="w2-p256") + check.within( + "доля второго при prefetch 2", + med(p2, "second_share"), + 0.30, + None, + ) + check.within( + "доля второго при prefetch 256", + med(p256, "second_share"), + None, + 0.05, + ) + check.within( + "восстановление p256 / p2", + ratio(med(p256, "recovery_s"), med(p2, "recovery_s")), + 1.4, + None, + ) + return check + + +def expected_wait(row: Mapping[str, Any]) -> float | None: + return ratio(num(row.get("peak_unfinished")), num(row.get("ready_s_over"))) + + +def h4(rows: list[Mapping[str, Any]]) -> Check: + check = Check() + for row in select(rows): + if flagged(row, "oom"): + continue + check.within( + f"{row['cell']}: p95 / (пик / throughput)", + ratio(num(row.get("ready_over_p95_s")), expected_wait(row)), + 0.8, + 1.25, + ) + return check + + +def h5(rows: list[Mapping[str, Any]], limit: int) -> Check: + check = Check() + on = select(rows, block="gate-on") + off = select(rows, block="gate-off") + if not on or not off: + check.missing.append("блоки gate-on и gate-off") + return check + for row in on: + check.within( + f"{row['cell']}: пик", + num(row.get("peak_unfinished")), + None, + limit + IN_FLIGHT, + ) + check.true(f"{row['cell']}: 429 есть", (num(row.get("s429")) or 0) > 0) + check.true( + f"{row['cell']}: Retry-After 5", + row.get("retry_after") == BACKLOG_RETRY_AFTER, + ) + check.true(f"{row['cell']}: 5xx нет", not num(row.get("s5xx"))) + check.true( + f"{row['cell']}: 429 = записи backlog", + num(row.get("s429")) == num(row.get("backlog_429")), + ) + check.within( + f"{row['cell']}: p95 / (предел / throughput)", + ratio( + num(row.get("ready_over_p95_s")), + ratio(float(limit), num(row.get("ready_s_over"))), + ), + 0.8, + 1.25, + ) + for row in off: + check.within( + f"{row['cell']}: пик без предела", + num(row.get("peak_unfinished")), + 1.5 * limit, + None, + ) + check.within( + "p95 on / off", + ratio(med(on, "ready_over_p95_s"), med(off, "ready_over_p95_s")), + None, + 0.75, + ) + check.within( + "восстановление on / off", + ratio(med(on, "recovery_s"), med(off, "recovery_s")), + None, + 0.75, + ) + a = med(on, "upload_before_p50_ms") + b = med(off, "upload_before_p50_ms") + check.within( + "загрузка before p50 on − off, мс", + None if a is None or b is None else a - b, + None, + 3, + ) + return check + + +def pooled(rows: Iterable[Mapping[str, Any]], key: str) -> list[float]: + values: list[float] = [] + for row in rows: + values += [float(v) for v in (row.get(key) or "").split()] + return values + + +def h6(rows: list[Mapping[str, Any]]) -> Check: + check = Check() + for row in rows: + for flag in FATAL_FLAGS: + check.true(f"{row['cell']}: нет {flag}", not flagged(row, flag)) + if num(row.get("failed")): + only_exhausted = all( + key.startswith("retry_exhausted") + for key in json.loads(row.get("failed_by") or "{}") + ) + check.true( + f"{row['cell']}: failed только при oom и retry_exhausted", + flagged(row, "oom") and only_exhausted, + ) + if flagged(row, "oom") or row.get("block") not in ( + "matrix", + "gate-on", + "gate-off", + ): + continue + bound = expected_wait(row) + check.within( + f"{row['cell']}: восстановление / (пик / throughput)", + ratio(num(row.get("recovery_s")), bound), + None, + 1.3, + ) + by_config: dict[str, list[Mapping[str, Any]]] = {} + for row in rows: + by_config.setdefault(row["config"], []).append(row) + for config, items in by_config.items(): + before = reconcile.percentile(pooled(items, "ready_before_list"), 95) + after = reconcile.percentile(pooled(items, "ready_after_list"), 95) + check.within( + f"{config}: p95 after / before", + ratio(after, before), + None, + 1.5, + ) + return check + + +def h7(rows: list[Mapping[str, Any]]) -> Check: + check = Check() + for row in rows: + if row.get("block") == "accept": + continue + for window in CONTROL_WINDOWS: + for kind, limit in ( + ("write", 200), + ("read", 200), + ("download", 500), + ): + value = num(row.get(f"ctrl_{kind}_{window}_p95")) + if value is not None: + check.within( + f"{row['cell']}: {kind} {window} p95", + value, + None, + limit, + ) + check.true( + f"{row['cell']}: {kind} {window} 5xx нет", + not num(row.get(f"ctrl_{kind}_{window}_s5xx")), + ) + check.true( + f"{row['cell']}: все реплики в LB", + not num(row.get("lb_down")), + ) + return check + + +def h8(rows: list[Mapping[str, Any]]) -> Check: + check = Check() + kills = select(rows, block="kill-worker") + restarts = select(rows, block="restart-broker") + if not kills: + check.missing.append("блок kill-worker") + if not restarts: + check.missing.append("блок restart-broker") + for row in kills: + check.true( + f"{row['cell']}: всё ready", + num(row.get("ready")) == num(row.get("accepted")), + ) + check.within( + f"{row['cell']}: заданий с повтором", + num(row.get("attempts_over_one")), + None, + 2, + ) + end = num(row.get("over_end")) + action = num(row.get("action_at")) + wait = expected_wait(row) + zero = num(row.get("zero_at")) + if None in (end, action, wait, zero): + check.missing.append(f"{row['cell']}: моменты") + continue + check.within( + f"{row['cell']}: разбор до границы, с", + zero - max(end + 1.3 * wait, action + LEASE_S + 15), + None, + 0, + ) + for row in restarts: + check.true( + f"{row['cell']}: всё ready", + num(row.get("ready")) == num(row.get("accepted")), + ) + check.within( + f"{row['cell']}: заданий с повтором", + num(row.get("attempts_over_one")), + None, + 0, + ) + check.true(f"{row['cell']}: 5xx нет", not num(row.get("s5xx"))) + wait = expected_wait(row) + recovery = num(row.get("recovery_s")) + check.within( + f"{row['cell']}: восстановление, с", + None + if wait is None or recovery is None + else recovery - (1.3 * wait + 15), + None, + 0, + ) + return check + + +def h9(rows: list[Mapping[str, Any]], limit: int) -> Check: + check = Check() + cells = select(rows, block="accept") + if not cells: + check.missing.append("блок accept") + for row in cells: + busy = num(row.get("first_busy_s")) + backlog = num(row.get("first_backlog_s")) + check.true( + f"{row['cell']}: первый busy раньше backlog", + None if busy is None or backlog is None else busy < backlog, + ) + check.true(f"{row['cell']}: 5xx нет", not num(row.get("s5xx"))) + check.within( + f"{row['cell']}: CPU S3 первые 30 с", + num(row.get("cpu_s3_accept")), + 0.85, + None, + ) + check.within( + f"{row['cell']}: принято/с", + ratio(num(row.get("accepted_over")), num(row.get("over_s"))), + 6, + None, + ) + check.within( + f"{row['cell']}: пик", + num(row.get("peak_unfinished")), + None, + limit + IN_FLIGHT, + ) + check.within( + f"{row['cell']}: готовых/с в окне", + num(row.get("ready_s_over")), + None, + 1.5, + ) + check.within( + f"{row['cell']}: готовых/с при восстановлении", + num(row.get("ready_s_recovery")), + 2.4, + None, + ) + for window in CONTROL_WINDOWS: + for kind, bound in ( + ("write", 200), + ("read", 200), + ("download", 1000), + ): + value = num(row.get(f"ctrl_{kind}_{window}_p95")) + if value is not None: + check.within( + f"{row['cell']}: {kind} {window} p95", + value, + None, + bound, + ) + check.true( + f"{row['cell']}: {kind} {window} 5xx нет", + not num(row.get(f"ctrl_{kind}_{window}_s5xx")), + ) + return check + + +def verdicts( + rows: list[Mapping[str, Any]], + limit: int, +) -> dict[str, tuple[str, str]]: + return { + "H1": h1(rows).verdict(), + "H2": h2(rows).verdict(), + "H3": h3(rows).verdict(), + "H4": h4(rows).verdict(), + "H5": h5(rows, limit).verdict(), + "H6": h6(rows).verdict(), + "H7": h7(rows).verdict(), + "H8": h8(rows).verdict(), + "H9": h9(rows, limit).verdict(), + } + + +def settings_of(rows: Iterable[Mapping[str, Any]]) -> list[tuple[int, int]]: + return sorted( + { + (int(num(r["concurrency"])), int(num(r["prefetch"]))) + for r in rows + if r.get("block") == "matrix" + }, + ) + + +def recommend(rows: list[Mapping[str, Any]]) -> dict[str, Any]: + """Правило решения 12: кандидат — без `oom` и `failed` на всех классах, с + throughput не ниже 90 % лучшей на каждом классе; из кандидатов — наименьшая + конкуренция; `prefetch` равен конкуренции.""" + settings = settings_of(rows) + candidates = [] + reasons: dict[str, str] = {} + for setting in settings: + problem = None + for klass in classes_of(rows): + cells = select(rows, klass=klass, setting=setting) + if not cells: + continue + if any(flagged(r, "oom") or flagged(r, "failed") for r in cells): + problem = f"{klass}: oom или failed" + break + best = max( + ( + value + for other in settings + if ( + value := med( + select(rows, klass=klass, setting=other), + "ready_s_recovery", + ) + ) + is not None + ), + default=None, + ) + own = med(cells, "ready_s_recovery") + if best is None or own is None or own < 0.9 * best: + problem = f"{klass}: throughput ниже 90 % лучшей" + break + if problem: + reasons[f"{setting[0]},{setting[1]}"] = problem + else: + candidates.append(setting) + if not candidates: + return {"setting": None, "candidates": [], "rejected": reasons} + concurrency = min(setting[0] for setting in candidates) + return { + "setting": (concurrency, concurrency), + "candidates": candidates, + "rejected": reasons, + } + + +# ----------------------------------------------------------------- сводка + + +def fmt(value: Any, digits: int = 1) -> str: + number = num(value) + return "—" if number is None else f"{number:.{digits}f}" + + +def spread( + rows: Iterable[Mapping[str, Any]], + key: str, + digits: int = 1, +) -> str: + return reconcile.spread((row.get(key) for row in rows), digits) + + +def config_table(rows: list[Mapping[str, Any]]) -> list[str]: + head = ( + "| Конфигурация | Ячеек | Принято | 429 | Готовых/с: окно | восстановление | " + "Пик незаверш. | Пик брокера | До `ready` over p50 / p95 / p99, с | " + "Восст., с | `memory.peak`, МиБ | VmHWM, МиБ | Процесс p50 / макс., МиБ | " + "CPU worker, S3 | Троттлинг worker | OOM | Перезапуски | Пометки |" + ) + lines = [head, "|" + "---|" * 18] + by_config: dict[str, list[Mapping[str, Any]]] = {} + for row in rows: + by_config.setdefault(row["config"], []).append(row) + for config in sorted(by_config): + items = by_config[config] + flags = sorted( + {f for r in items for f in (r.get("flags") or "").split()}, + ) + lines.append( + f"| `{config}` | {len(items)} | {spread(items, 'accepted', 0)} | " + f"{spread(items, 's429', 0)} | {spread(items, 'ready_s_over', 2)} | " + f"{spread(items, 'ready_s_recovery', 2)} | " + f"{spread(items, 'peak_unfinished', 0)} | " + f"{spread(items, 'peak_broker_ready', 0)} | " + f"{fmt(med(items, 'ready_over_p50_s'))} / " + f"{fmt(med(items, 'ready_over_p95_s'))} / " + f"{fmt(med(items, 'ready_over_p99_s'))} | " + f"{spread(items, 'recovery_s', 1)} | " + f"{spread(items, 'memory_peak_mib', 0)} | " + f"{fmt(med(items, 'worker_hwm_mib'), 0)} | " + f"{fmt(med(items, 'render_peak_p50_mib'), 0)} / " + f"{fmt(med(items, 'render_peak_max_mib'), 0)} | " + f"{fmt(med(items, 'cpu_worker_over'), 2)}, " + f"{fmt(med(items, 'cpu_s3_over'), 2)} | " + f"{fmt(med(items, 'throttle_worker_over'), 2)} | " + f"{sum(int(num(r.get('oom_kill')) or 0) for r in items)} | " + f"{sum(int(num(r.get('worker_restarts')) or 0) for r in items)} | " + f"{' '.join(flags) or '—'} |", + ) + return lines + + +def control_table(rows: list[Mapping[str, Any]]) -> list[str]: + lines = [ + "| Конфигурация | Окно | Запись p50 / p95 / p99, мс | Чтение p50 / p95 / p99, " + "мс | Скачивание p50 / p95 / p99, мс | Ответов | 5xx |", + "|" + "---|" * 7, + ] + by_config: dict[str, list[Mapping[str, Any]]] = {} + for row in rows: + by_config.setdefault(row["config"], []).append(row) + for config in sorted(by_config): + items = by_config[config] + for window in CONTROL_WINDOWS: + parts = [] + total = errors = 0.0 + for kind in CONTROL_KINDS.values(): + prefix = f"ctrl_{kind}_{window}" + parts.append( + " / ".join( + fmt(med(items, f"{prefix}_{stat}")) + for stat in ("p50", "p95", "p99") + ), + ) + total += sum(num(r.get(f"{prefix}_n")) or 0 for r in items) + errors += sum(num(r.get(f"{prefix}_s5xx")) or 0 for r in items) + lines.append( + f"| `{config}` | {window} | {parts[0]} | {parts[1]} | {parts[2]} " + f"| {int(total)} | {int(errors)} |", + ) + return lines + + +def block_table(rows: list[Mapping[str, Any]]) -> list[str]: + lines = [ + "| Ячейка | Принято | 429 busy / backlog | Первый busy / backlog, с | Пик | " + "Готовых/с окно / восст. | Восст., с | Повторов | Второй worker: задания, доля " + "| Пометки |", + "|" + "---|" * 10, + ] + for row in sorted(rows, key=lambda r: r["cell"]): + if row.get("block") == "matrix": + continue + lines.append( + f"| `{row['cell']}` | {fmt(row.get('accepted'), 0)} | " + f"{fmt(row.get('busy_429'), 0)} / {fmt(row.get('backlog_429'), 0)} | " + f"{fmt(row.get('first_busy_s'))} / " + f"{fmt(row.get('first_backlog_s'))} | " + f"{fmt(row.get('peak_unfinished'), 0)} | " + f"{fmt(row.get('ready_s_over'), 2)} / " + f"{fmt(row.get('ready_s_recovery'), 2)} | " + f"{fmt(row.get('recovery_s'))} | " + f"{fmt(row.get('attempts_over_one'), 0)} | " + f"{fmt(row.get('second_jobs'), 0)}, " + f"{fmt(row.get('second_share'), 2)} | " + f"{row.get('flags') or '—'} |", + ) + return lines + + +def render_summary( + meta: Mapping[str, Any], + rows: list[Mapping[str, Any]], +) -> str: + info = meta.get("queue", {}) + limit = int(info.get("default_limit") or 250) + plan_total = len(info.get("plan", [])) + lines = [ + f"# Очередь под перегрузкой: метка {meta.get('label')}", + "", + f"commit `{meta.get('git', {}).get('commit')}`, " + f"dirty {meta.get('git', {}).get('dirty')}, статус " + f"{meta.get('status')}, ячеек {len(rows)} из {plan_total}.", + "", + ] + fatal = [ + f"`{row['cell']}`: {row['flags']}" + for row in rows + if any(flagged(row, flag) for flag in FATAL_FLAGS) + ] + if fatal: + lines += ["**Потеряна работа:** " + "; ".join(fatal), ""] + lines += ["## Гипотезы", "", "| № | Вердикт | Детали |", "|---|---|---|"] + for name, (verdict, detail) in verdicts(rows, limit).items(): + lines.append(f"| {name} | {verdict} | {detail} |") + advice = recommend(rows) + setting = advice["setting"] + lines += ["", "## Рекомендация", ""] + if setting is None: + lines.append("Кандидатов нет: правило не выбрало настройку.") + else: + keep = setting == DEFAULT_SETTING + lines.append( + f"Конкуренция {setting[0]}, prefetch {setting[1]}: " + + ( + "значения по умолчанию оставить." + if keep + else "отличается от (2, 2), решение — по правилу в отчёте." + ), + ) + for key, reason in advice["rejected"].items(): + lines.append(f"- ({key}) не кандидат: {reason}") + lines += [ + "", + "## Ячейки по конфигурациям", + "", + "Значения — медиана (min–max) повторов.", + "", + *config_table(rows), + "", + "## Блоки", + "", + *block_table(rows), + "", + "## Контрольный поток", + "", + *control_table(rows), + "", + ] + return "\n".join(lines) + + +def setting_chart( + rows: list[Mapping[str, Any]], + key: str, + title: str, + unit: str, +) -> str: + """Столбики: класс → настройки, медиана повторов.""" + classes = classes_of(rows) + settings = settings_of(rows) + colors = ["#2a78d6", "#d98a00", "#3a9a5b", "#b0569c"] + width, height = 860, 420 + svg = plots.Svg(width, height, title) + left, right, top, bottom = 70, 20, 50, 60 + values = [ + med(select(rows, klass=klass, setting=setting), key) + for klass in classes + for setting in settings + ] + highest = max((v for v in values if v is not None), default=0.0) or 1.0 + y_scale = (height - top - bottom) / (highest * 1.1) + group = (width - left - right) / max(1, len(classes)) + bar = group / (len(settings) + 1) + base = height - bottom + svg.line(left, base, width - right, base, color=plots.AXIS) + svg.text(left, top - 14, unit, size=12) + for ci, klass in enumerate(classes): + x0 = left + ci * group + svg.text(x0 + group / 2 - 8, base + 22, klass, size=13) + for si, setting in enumerate(settings): + value = med(select(rows, klass=klass, setting=setting), key) + if value is None: + continue + bar_h = value * y_scale + svg.bar( + x0 + si * bar + bar / 2, + base - bar_h, + bar * 0.9, + bar_h, + colors[si % len(colors)], + f"{klass} ({setting[0]}, {setting[1]}): {value:.2f} {unit}", + top=True, + ) + for si, setting in enumerate(settings): + x = left + si * 130 + svg.bar( + x, + height - 28, + 14, + 14, + colors[si % len(colors)], + "", + top=False, + ) + svg.text(x + 20, height - 16, f"({setting[0]}, {setting[1]})", size=12) + return svg.render() + + +def gate_chart(timeline: list[Mapping[str, Any]]) -> str: + """Незавершённые посекундно: блоки предела, первый повтор.""" + width, height = 860, 420 + svg = plots.Svg(width, height, "Незавершённые задания: предел и без него") + left, right, top, bottom = 70, 20, 50, 50 + series: dict[str, list[tuple[float, float]]] = {} + for row in timeline: + cell = row.get("cell", "") + if cell.startswith(("gate-on", "gate-off")) and cell.endswith("-r1"): + t = num(row.get("t")) + value = num(row.get("unfinished")) + if t is not None and value is not None: + series.setdefault(cell, []).append((t, value)) + if not series: + svg.text(left, top + 30, "нет данных", size=13) + return svg.render() + max_t = max(p[0] for points in series.values() for p in points) or 1.0 + max_v = max(p[1] for points in series.values() for p in points) or 1.0 + colors = ["#2a78d6", "#d98a00"] + + def sx(t: float) -> float: + return left + t / max_t * (width - left - right) + + def sy(v: float) -> float: + return height - bottom - v / (max_v * 1.1) * (height - top - bottom) + + svg.line( + left, + height - bottom, + width - right, + height - bottom, + color=plots.AXIS, + ) + svg.text( + left, + top - 14, + f"до {max_v:.0f} заданий, до {max_t:.0f} с", + size=12, + ) + for index, (cell, points) in enumerate(sorted(series.items())): + svg.polyline( + [(sx(t), sy(v)) for t, v in points], + colors[index % len(colors)], + ) + svg.text(left + index * 260, height - 18, cell, size=12) + return svg.render() + + +def render_plots( + rows: list[Mapping[str, Any]], + timeline: list[Mapping[str, Any]], +) -> dict[str, str]: + return { + "throughput-by-setting.svg": setting_chart( + rows, + "ready_s_recovery", + "Throughput по настройкам и классам", + "готовых/с", + ), + "p95-by-setting.svg": setting_chart( + rows, + "ready_over_p95_s", + "p95 времени до ready, окно over", + "с", + ), + "memory-by-setting.svg": setting_chart( + rows, + "memory_peak_mib", + "memory.peak worker", + "МиБ", + ), + "backlog-gate.svg": gate_chart(timeline), + } + + +# -------------------------------------------------------------- самопроверка + + +def base_row(**values: Any) -> dict[str, Any]: + row = { + "cell": "s-c2p2-r1", + "config": "s-c2p2", + "block": "matrix", + "class": "s", + "concurrency": "2", + "prefetch": "2", + "repeat": "1", + "accepted": "100", + "ready": "100", + "failed": "0", + "s429": "0", + "s5xx": "0", + "busy_429": "0", + "backlog_429": "0", + "ready_s_over": "3", + "ready_s_recovery": "3", + "peak_unfinished": "60", + "peak_broker_ready": "50", + "ready_over_p95_s": "20", + "recovery_s": "20", + "memory_peak_mib": "200", + "duration_p50_ms": "300", + "cpu_worker_over": "0.95", + "failed_by": "{}", + "ready_before_list": "1.0 1.1", + "ready_after_list": "1.0 1.2", + "attempts_over_one": "0", + "over_end": "100", + "zero_at": "120", + "action_at": "90", + "second_share": "", + "flags": "", + "lb_down": "0", + "retry_after": "", + } + for key, value in values.items(): + row[key] = value + return row + + +def matrix_fixture() -> list[dict[str, Any]]: + rows = [] + for klass in ("s", "m", "lj", "lp"): + rows.append( + base_row( + cell=f"{klass}-c2p2-r1", + config=f"{klass}-c2p2", + **{"class": klass}, + ), + ) + wide = { + "duration_p50_ms": "600", + "memory_peak_mib": "400", + } + flags = "" + if klass == "lp": + wide["memory_peak_mib"] = "1024" + wide["oom_kill"] = "3" + flags = "oom" + rows.append( + base_row( + cell=f"{klass}-c4p4-r1", + config=f"{klass}-c4p4", + concurrency="4", + prefetch="4", + flags=flags, + **{"class": klass, **wide}, + ), + ) + for klass in ("m", "lp"): + rows.append( + base_row( + cell=f"{klass}-c1p1-r1", + config=f"{klass}-c1p1", + concurrency="1", + prefetch="1", + ready_s_recovery="2.6", + cpu_worker_over="0.7", + **{"class": klass}, + ), + ) + for klass in ("s", "lp"): + rows.append( + base_row( + cell=f"{klass}-c2p256-r1", + config=f"{klass}-c2p256", + prefetch="256", + peak_broker_ready="0", + **{"class": klass}, + ), + ) + return rows + + +def gate_fixture() -> list[dict[str, Any]]: + on = base_row( + cell="gate-on-s-c2p2-r1", + config="gate-on-s-c2p2", + block="gate-on", + peak_unfinished="255", + s429="180", + backlog_429="180", + retry_after="5", + ready_over_p95_s="85", + recovery_s="85", + upload_before_p50_ms="15", + ) + off = base_row( + cell="gate-off-s-c2p2-r1", + config="gate-off-s-c2p2", + block="gate-off", + peak_unfinished="430", + ready_over_p95_s="145", + recovery_s="145", + upload_before_p50_ms="14", + ) + return [on, off] + + +def selftest() -> None: + # план: без повтора подряд на границе кругов, все ячейки + configs = [ + {"block": "matrix", "class": k, "concurrency": 2, "prefetch": 2} + for k in ("s", "m", "lj") + ] + plan = plan_cells(configs, 3, 7) + assert len(plan) == 9 + for prev, cur in zip(plan, plan[1:], strict=False): + assert prev["config"] != cur["config"] + assert plan[0]["order"] == 1 and plan[-1]["order"] == 9 + + # разбор строк + t0, ups = parse_uploads( + "q-t0,1000000\n" + "q,before,1000000,10,202,-,a,id1\n" + "q,over,1010000,20,429,5,a,-\nбред\n", + ) + assert t0 == 1000.0 and len(ups) == 2 and ups[1].retry_after == "5" + metas, checks = parse_sweep( + "qs,id1,200,ready,-,3,2026-11-01T10:00:00.123456Z\n" + "qs,id2,404,-,-,0,-\nqv,id1,original,1\nqv,id1,crop,0\n", + ) + assert abs(metas["id1"].updated_at % 1 - 0.123456) < 1e-5 + assert metas["id2"].updated_at is None and checks == [True, False] + jobs = parse_jobs("jobs|1000000|1|2|3|4|5.5|6\nсбой\n") + assert jobs[0].unfinished == 10 and jobs[0].oldest_s == 5.5 + mq, missing = parse_mq("mq 1000000000 5 2\nmq 2000000000 missing\n") + assert mq == [(1.0, 5, 2)] and missing == 1 + + # жизни: перезапуск сбрасывает счётчики + points = [ + (10**9, 100, 10, 1), + (2 * 10**9, 200, 20, 2), + (3 * 10**9, 50, 5, 0), + (4 * 10**9, 150, 15, 1), + ] + lives = split_lives(points) + assert len(lives) == 2 + assert lives_delta(lives, 0, 5) == 200 + assert role_cores([lives], 1, 4) == round(200 / 1e6 / 3, 4) + mp = [ + (10**9, 500 * MIB, 400 * MIB, 2), + (2 * 10**9, 700 * MIB, 600 * MIB, 3), + (3 * 10**9, 100 * MIB, 90 * MIB, 0), + (4 * 10**9, 300 * MIB, 200 * MIB, 1), + ] + assert memory_by_lives(split_lives(mp, key=1)) == (700.0, 600.0, 4) + + # ячейка на границах окон: потерянное, зависшее, OOM, перезапуск + base = { + "cell": "s-c2p2-r1", + "config": "s-c2p2", + "block": "matrix", + "class": "s", + "concurrency": 2, + "prefetch": 2, + "repeat": 1, + "order": 1, + "before_s": 10, + "over_s": 20, + } + t = 1000.0 + uploads_seen = [ + Upload("before", int(t * 1000), 10, 202, "-", "a", "b1"), + Upload("over", int((t + 10) * 1000), 10, 202, "-", "a", "o1"), + Upload("over", int((t + 11) * 1000), 10, 202, "-", "a", "o2"), + Upload("over", int((t + 12) * 1000), 10, 202, "-", "a", "o3"), + Upload("over", int((t + 13) * 1000), 10, 429, "5", "a", "-"), + ] + src = Sources( + uploads=uploads_seen, + t0=t, + metas={ + "b1": Meta(200, "ready", "-", 3, t + 1), + # ровно на начале окна over: входит + "o1": Meta(200, "ready", "-", 3, t + 10), + "o2": Meta(200, "queued", "-", 0, None), + }, + sha_checks=[True], + jobs=[ + JobTick(t + 5, 0, 0, 0, 1, 0.1, 0), + JobTick(t + 20, 1, 1, 1, 2, 9.0, 1), + JobTick(t + 40, 0, 0, 0, 0, 0.0, 0), + ], + mq=[(t + 20, 3, 2), (t + 40, 0, 0)], + mq_missing=0, + cg={ + "worker": [ + split_lives( + [(int((t + i) * 1e9), i * 10**6, i, 0) for i in range(41)], + ), + ], + }, + mp={"worker": split_lives(mp)}, + control=[], + worker_records=[], + second_records=[], + relay_records=[], + api_records=[], + sql={"extra_jobs": 0, "bad_variants": 0, "attempts_over_one": 1}, + hwm_kib=2048, + restarts=1, + ) + row = cell_row(base, src) + assert row["lost"] == 1 and row["stuck"] == 1 + assert row["ready"] == 2 and row["oom_kill"] == 5 + assert "lost" in row["flags"] and "stuck" in row["flags"] + # край окна — между тиками: CPU не занижен + assert row["cpu_worker_over"] == 1.0, row["cpu_worker_over"] + assert "oom" in row["flags"] and "worker_restart" in row["flags"] + assert row["ready_s_over"] == round(1 / 20, 3) + assert row["peak_unfinished"] == 5 and row["peak_prefetched"] == 0 + assert row["recovery_s"] is not None and row["memory_peak_mib"] == 700.0 + assert row["accepted_over"] == 3 and row["s429"] == 1 + timeline = timeline_rows(base, src) + assert [r["window"] for r in timeline] == ["before", "over", "recovery"] + + # вердикты: подтверждено, нет, нет данных + rows = matrix_fixture() + gate_fixture() + w2 = [ + base_row( + cell="w2-p2-r1", + config="w2-p2", + block="w2-p2", + second_share="0.4", + recovery_s="20", + ), + base_row( + cell="w2-p256-r1", + config="w2-p256", + block="w2-p256", + prefetch="256", + second_share="0", + recovery_s="30", + ), + ] + restarts = [ + base_row( + cell="kill-r1", + config="kill", + block="kill-worker", + attempts_over_one="2", + ), + base_row(cell="brk-r1", config="brk", block="restart-broker"), + ] + accept = [ + base_row( + cell="acc-r1", + config="acc", + block="accept", + first_busy_s="10", + first_backlog_s="35", + cpu_s3_accept="0.97", + accepted_over="300", + over_s="45", + peak_unfinished="280", + ready_s_over="0.6", + ready_s_recovery="2.8", + ctrl_download_over_p95="340", + ready_over_p95_s="93", + recovery_s="100", + ), + ] + everything = rows + w2 + restarts + accept + assert h1(everything).verdict()[0] == CONFIRMED, h1(everything).verdict() + assert h2(everything).verdict()[0] == CONFIRMED, h2(everything).verdict() + assert h3(everything).verdict()[0] == CONFIRMED, h3(everything).verdict() + assert h4(rows[:1]).verdict()[0] == CONFIRMED + assert h5(everything, 250).verdict()[0] == CONFIRMED, h5( + everything, + 250, + ).verdict() + assert h6(rows[:1]).verdict()[0] == CONFIRMED, h6(rows[:1]).verdict() + assert h7(everything).verdict()[0] == CONFIRMED + assert h8(everything).verdict()[0] == CONFIRMED, h8(everything).verdict() + assert h9(everything, 250).verdict()[0] == CONFIRMED, h9( + everything, + 250, + ).verdict() + + empty: list[dict[str, Any]] = [] + for name, (verdict, _) in verdicts(empty, 250).items(): + assert verdict == NO_DATA, (name, verdict) + + def broken(**values: Any) -> list[dict[str, Any]]: + return [base_row(**{**r, **values}) for r in everything] + + assert h1(broken(cpu_worker_over="0.5")).verdict()[0] == REFUTED + assert ( + h2(broken(duration_p50_ms="300", memory_peak_mib="1100")).verdict()[0] + == REFUTED + ) + assert h3(broken(peak_broker_ready="60")).verdict()[0] == REFUTED + assert h4(broken(ready_over_p95_s="60")[:1]).verdict()[0] == REFUTED + assert h5(broken(retry_after="1"), 250).verdict()[0] == REFUTED + assert h6(broken(flags="lost")).verdict()[0] == REFUTED + assert h7(broken(ctrl_write_over_p95="500")).verdict()[0] == REFUTED + assert h7(broken(ctrl_read_over_s5xx="1")).verdict()[0] == REFUTED + assert h8(broken(attempts_over_one="5")).verdict()[0] == REFUTED + assert ( + h9(broken(first_busy_s="50", first_backlog_s="10"), 250).verdict()[0] + == REFUTED + ) + + # рекомендация: (2, 2) и другая + assert recommend(matrix_fixture())["setting"] == (2, 2) + other = [ + base_row(**{**r, "ready_s_recovery": "3"}) + if r["concurrency"] == "1" + else r + for r in matrix_fixture() + ] + assert recommend(other)["setting"] == (1, 1) + assert recommend(empty)["setting"] is None + + # сводка и графики собираются + text = render_summary( + {"label": "x", "git": {"commit": "abc", "dirty": False}, "queue": {}}, + everything, + ) + assert "H9" in text and "Рекомендация" in text + pictures = render_plots(everything, []) + assert set(pictures) == { + "throughput-by-setting.svg", + "p95-by-setting.svg", + "memory-by-setting.svg", + "backlog-gate.svg", + } + print("overload selftest ok") + + +if __name__ == "__main__": + if "--selftest" in sys.argv: + selftest() + else: + print(__doc__) diff --git a/bench/queue.compose.yml b/bench/queue.compose.yml new file mode 100644 index 00000000..7971c637 --- /dev/null +++ b/bench/queue.compose.yml @@ -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 diff --git a/bench/rabbitmq/91-bench.conf b/bench/rabbitmq/91-bench.conf new file mode 100644 index 00000000..63d62585 --- /dev/null +++ b/bench/rabbitmq/91-bench.conf @@ -0,0 +1,2 @@ +# Профиль очереди: значения метрик свежие за секунду (проба: 4,7 мс CPU на опрос) +collect_statistics_interval = 1000 diff --git a/bench/rabbitmq/enabled_plugins b/bench/rabbitmq/enabled_plugins new file mode 100644 index 00000000..71248399 --- /dev/null +++ b/bench/rabbitmq/enabled_plugins @@ -0,0 +1 @@ +[rabbitmq_prometheus]. diff --git a/bench/run.py b/bench/run.py index 762c8cbc..9edf33e4 100644 --- a/bench/run.py +++ b/bench/run.py @@ -20,6 +20,7 @@ import fcntl import json import os import platform +import random import re import secrets import shutil @@ -37,6 +38,7 @@ from pathlib import Path from typing import Any import failover +import overload import plots import reconcile import resources @@ -96,6 +98,18 @@ FILL = "mtusi-bench-fill" RECONCILE_PASS = "mtusi-bench-reconcile-" S3_METRICS_COMPOSE = "s3-metrics.compose.yml" BEFORE_CLEANER_COMPOSE = "cleaner-before.compose.yml" +# профиль очереди (design change track1-queue-overload): постоянные контейнеры +# конвейера (`container_name` в bench.compose.yml), второй worker блоков w2-*, +# генератор файлов классов, override с плагином брокера и политикой worker +BROKER = "mtusi-bench-rabbitmq" +RELAY = "mtusi-bench-relay" +WORKER = "mtusi-bench-worker" +WORKER_2 = "mtusi-bench-worker-2" +CLEANER = "mtusi-bench-cleaner" +IMAGES = "mtusi-bench-images" +QUEUE_COMPOSE = ROOT / "bench" / "queue.compose.yml" +# сколько ждать нуля незавершённых после разогрева, с +QUEUE_WARM_WAIT_S = 120 # сэмплер серий трека 1: образ PostgreSQL стенда, --cgroupns host # (решение 7 design change scaling-bench) SAMPLER = "mtusi-bench-sampler" @@ -430,6 +444,26 @@ class Profile: reconcile_h2_stages: tuple[str, ...] = () reconcile_h3_stages: tuple[str, ...] = () reconcile_s4_base: str = "" + # профиль очереди (design change track1-queue-overload, решения 5, 6, 8, 14): + # конфигурации — (блок, класс, конкуренция, prefetch, низкая λ, высокая λ, + # окно over, предел незавершённых или None, действие); окна; файлы классов от + # зерна; VU заранее; контрольный поток; разогрев; выборка SHA-256; предел по + # умолчанию для вердиктов + queue_configs: tuple[tuple[Any, ...], ...] = () + queue_before_s: int = 10 + queue_after_s: int = 10 + queue_recovery_max_s: int = 420 + queue_image_seed: int = 20261101 + queue_low_vus: int = 4 + queue_control: tuple[tuple[str, int], ...] = ( + ("download", 5), + ("write", 10), + ("read", 10), + ) + queue_control_max_vus: int = 60 + queue_warm: int = 12 + queue_sample: int = 10 + queue_default_limit: int = 250 # серии трека 1 (решения 1–6, 14 design change scaling-bench): имя # серии, конфигурации (реплик, CPU и память реплики, max_connections # PostgreSQL), чаты записи, смесь, фиксированные уровни, лестница и @@ -491,6 +525,181 @@ class Profile: def is_reconcile(self) -> bool: return bool(self.reconcile_stages) + @property + def is_queue(self) -> bool: + return bool(self.queue_configs) + + +# интенсивности загрузок по классу: низкая и высокая, в секунду (решение 5) +QUEUE_RATES = { + "s": (1.5, 8), + "m": (1.5, 6), + "lj": (1.2, 6), + "lp": (0.5, 2.5), +} +# VU заранее окна over: тело — open на VU, создание на ходу теряет итерации +QUEUE_OVER_VUS = 20 +QUEUE_ACCEPT_VUS = 80 + + +def queue_config( + block: str, + klass: str, + concurrency: int, + prefetch: int, + *, + high: float | None = None, + over_s: int = 20, + limit: int | None = None, + action: str = "", +) -> tuple[Any, ...]: + low, default_high = QUEUE_RATES[klass] + return ( + block, + klass, + concurrency, + prefetch, + low, + default_high if high is None else high, + over_s, + limit, + action, + ) + + +def queue_matrix() -> tuple[tuple[Any, ...], ...]: + """12 конфигураций решения 5: (2, 2) и (4, 4) на всех классах, (1, 1) на `m` + и `lp`, (2, 256) на `s` и `lp`.""" + configs = [] + for klass in QUEUE_RATES: + configs.append(queue_config("matrix", klass, 2, 2)) + configs.append(queue_config("matrix", klass, 4, 4)) + configs += [queue_config("matrix", k, 1, 1) for k in ("m", "lp")] + configs += [queue_config("matrix", k, 2, 256) for k in ("s", "lp")] + return tuple(configs) + + +def queue_blocks() -> tuple[tuple[Any, ...], ...]: + """Блоки решения 8: семь конфигураций.""" + return ( + queue_config("gate-on", "s", 2, 2, high=20, over_s=25), + queue_config("gate-off", "s", 2, 2, high=20, over_s=25, limit=0), + queue_config("accept", "m", 2, 2, high=15, over_s=45), + queue_config("w2-p2", "s", 2, 2, action="second-worker"), + queue_config("w2-p256", "s", 2, 256, action="second-worker"), + queue_config( + "kill-worker", + "s", + 2, + 2, + over_s=25, + action="kill-worker", + ), + queue_config( + "restart-broker", + "s", + 2, + 2, + over_s=25, + action="restart-broker", + ), + ) + + +def queue_quick_configs() -> tuple[tuple[Any, ...], ...]: + """Быстрый профиль (решение 14): предел 40 и без него, `s` (2, 2), `lp` + (4, 4), `kill-worker`, `w2-p256`, окна over 10 с.""" + return ( + queue_config("matrix", "s", 2, 2, over_s=10), + queue_config("matrix", "lp", 4, 4, over_s=10), + queue_config("gate-on", "s", 2, 2, high=20, over_s=10, limit=40), + queue_config("gate-off", "s", 2, 2, high=20, over_s=10, limit=0), + queue_config( + "kill-worker", + "s", + 2, + 2, + over_s=10, + action="kill-worker", + ), + queue_config( + "w2-p256", + "s", + 2, + 256, + over_s=10, + action="second-worker", + ), + ) + + +def queue_cell_configs(profile: Profile) -> list[dict[str, Any]]: + keys = ( + "block", + "class", + "concurrency", + "prefetch", + "rate_low", + "rate_high", + "over_s", + "limit", + "action", + ) + return [ + { + **dict(zip(keys, item, strict=True)), + "before_s": profile.queue_before_s, + "after_s": profile.queue_after_s, + } + for item in profile.queue_configs + ] + + +def queue_budget( + profile: Profile, + vm_cpus: int, + vm_memory: int, +) -> dict[str, Any]: + """Сумма лимитов профиля очереди на пике (решение 10): реплики, хранилища, + брокер, relay, два worker, уборщик, сэмплер; генератор без лимита.""" + cpu = profile.replicas * float(profile.cpus) + sum( + float(value) + for value in ( + profile.db_cpus, + profile.lb_cpus, + profile.cache_cpus, + profile.s3_cpus, + profile.broker_cpus, + profile.relay_cpus, + profile.worker_cpus, + profile.worker_cpus, + profile.cleaner_cpus, + profile.sampler_cpus, + ) + ) + mem = profile.replicas * size_bytes(profile.memory) + sum( + size_bytes(value) + for value in ( + profile.db_memory, + profile.lb_memory, + profile.cache_memory, + profile.s3_memory, + profile.broker_memory, + profile.relay_memory, + profile.worker_memory, + profile.worker_memory, + profile.cleaner_memory, + profile.sampler_memory, + ) + ) + return { + "cpus": round(cpu, 2), + "memory_gib": round(mem / 2**30, 2), + "vm_cpus": vm_cpus, + "vm_memory_gib": round(vm_memory / 2**30, 2), + "generator": "no limit", + } + PROFILES = { "full": Profile( @@ -796,6 +1005,50 @@ PROFILES = { reconcile_h3_stages=("Q", ""), reconcile_s4_base="Q", ), + # очередь под перегрузкой (трек 1 «5» лабы 5): LB, две реплики, хранилища, S3, + # брокер, relay, worker и уборщик с лимитами рабочего стенда; настройки × + # классы × 3 повтора и блоки. Design change track1-queue-overload, решения 5–8 + "queue": Profile( + name="queue", + sizes=(), + concurrency=(), + repeats=3, + read_warmup_s=0, + read_measure_s=0, + write_warmup=0, + write_measure=0, + members=1, + cpus="1", + memory="512m", + db_cpus="2", + db_memory="1g", + cache_cpus="0.5", + cache_memory="128m", + replicas=2, + queue_configs=(*queue_matrix(), *queue_blocks()), + ), + "queue_quick": Profile( + name="queue_quick", + sizes=(), + concurrency=(), + repeats=1, + read_warmup_s=0, + read_measure_s=0, + write_warmup=0, + write_measure=0, + members=1, + cpus="1", + memory="512m", + db_cpus="2", + db_memory="1g", + cache_cpus="0.5", + cache_memory="128m", + replicas=2, + queue_configs=queue_quick_configs(), + queue_before_s=5, + queue_after_s=5, + queue_default_limit=40, + ), } @@ -1259,6 +1512,17 @@ def vm_warnings(profile: Profile) -> list[str]: profile.cleaner_memory, profile.sampler_memory, ) + elif profile.is_queue: + # профиль очереди: S3, брокер, relay, два worker, уборщик и сэмплер + extra = ( + profile.s3_memory, + profile.broker_memory, + profile.relay_memory, + profile.worker_memory, + profile.worker_memory, + profile.cleaner_memory, + profile.sampler_memory, + ) limits = max(k * size_bytes(memory) for k, memory in replicas) + sum( size_bytes(value) for value in ( @@ -1544,7 +1808,7 @@ def leftovers() -> dict[str, list[str]]: "{{.Names}}", ).split() networks = sh("docker", "network", "ls", "--format", "{{.Name}}").split() - extra = [name for name in (K6, SAMPLER, FILL) if name in names] + extra = [name for name in (K6, SAMPLER, FILL, IMAGES) if name in names] return { "rm -f": containers + [n for n in extra if n not in containers], "volume rm": sh( @@ -1791,6 +2055,12 @@ class Stand: f"s3 healthy with metrics port " f"{self.profile.reconcile_metrics_port}, bootstrap done", ) + if self.profile.is_queue: + # профиль очереди меряет обработку: S3 и брокер до реплик (решение + # 10 design change track1-queue-overload) + self.start_s3() + self.start_broker() + say("s3 and broker healthy, bootstrap done") self.compose( "up", "-d", @@ -1799,6 +2069,16 @@ class Stand: APP_SERVICE, "haproxy", ) + if self.profile.is_queue: + self.compose( + "up", + "-d", + "--no-deps", + "--no-build", + "relay", + "cleaner", + "worker", + ) # генератор серий трека 1 — с лимитом без swap (решение 6 design # change scaling-bench); у прочих профилей — без лимита limits = ( @@ -2302,12 +2582,25 @@ class Stand: k6 и хранилище восстановления — первыми: подключённый к сети контейнер не из compose не дал бы compose удалить сеть. Volume - восстановления compose не знает, он удаляется отдельно. + восстановления compose не знает, он удаляется отдельно. У профиля + очереди перед `down` — `kill`: S3 иначе останавливается ~15 с, а его + volume всё равно уходит. """ # -v — анонимные volume образа (у сэмплера — /var/lib/postgresql); # именованный volume восстановления удаляется ниже отдельно subprocess.run( - ["docker", "rm", "-f", "-v", K6, SAMPLER, RESTORE_DB, FILL], + [ + "docker", + "rm", + "-f", + "-v", + K6, + SAMPLER, + RESTORE_DB, + FILL, + WORKER_2, + IMAGES, + ], capture_output=True, check=False, ) @@ -2326,6 +2619,8 @@ class Stand: capture_output=True, check=False, ) + if self.profile.is_queue: + self.compose("kill", check=False) self.compose("down", "-v", "--remove-orphans", check=False) subprocess.run( ["docker", "volume", "rm", RESTORE_VOLUME], @@ -2426,6 +2721,16 @@ class Stand: roles = {APP_SERVICE: replicas[0], **CONTAINERS, "k6": K6} if self.profile.is_uploads or self.profile.is_reconcile: roles["s3"] = S3 + if self.profile.is_queue: + roles.update( + { + "s3": S3, + "rabbitmq": BROKER, + "relay": RELAY, + "worker": WORKER, + "cleaner": CLEANER, + }, + ) limits: dict[str, Any] = {} for role, name in roles.items(): limits[role] = self.container_limits(name) @@ -2620,6 +2925,135 @@ class Stand: tail = sh("docker", "logs", "--tail", "5", SAMPLER, check=False) raise BenchError(f"sampler: {problem}\n{tail}") + def make_images(self, seed: int) -> dict[str, Any]: + """Файлы классов профиля очереди в `.work/` (решение 5): контейнер на + образе стенда без сети; ненулевой код — файл вышел за лимит контракта.""" + self.work_dir.mkdir(parents=True, exist_ok=True) + proc = subprocess.run( + [ + "docker", + "run", + "--rm", + "--name", + IMAGES, + "--network", + "none", + "-v", + f"{ROOT / 'bench'}:/bench:ro", + "-v", + f"{self.work_dir}:/work", + "--entrypoint", + "python", + APP_IMAGE, + "/bench/make_images.py", + str(seed), + "/work", + ], + capture_output=True, + text=True, + check=False, + ) + if proc.returncode != 0: + raise BenchError( + f"make_images: exit {proc.returncode}\n{proc.stderr[-2000:]}", + ) + return json.loads(proc.stdout) + + def queue_overrides(self, env: dict[str, dict[str, str]]) -> None: + """Плагин брокера и политика worker (`queue.compose.yml`), окружение + ячейки — override `VARIANT_COMPOSE`, как у профиля загрузок: сервисы и + их переменные.""" + path = self.work_dir / VARIANT_COMPOSE + lines = ["services:"] + for service, values in env.items(): + lines += [f" {service}:", " environment:"] + lines += [ + f' {key}: "{value}"' for key, value in values.items() + ] + path.write_text("\n".join(lines) + "\n", encoding="utf-8") + self.extra_files = [QUEUE_COMPOSE, path] + + def start_queue_sampler(self, queue: str) -> None: + """Сэмплер в режиме `queue`: сеть стенда (метрики брокера, статистика LB, + `psql \\watch`), `--cgroupns host`, свои лимиты; готов, когда видит все + контейнеры проекта, тик ВМ и первую строку заданий.""" + p = self.profile + image = sh("docker", "inspect", "-f", "{{.Config.Image}}", DB) + for name in ("samples.log", "jobs.log"): + (self.work_dir / name).unlink(missing_ok=True) + proc = subprocess.run( + [ + "docker", + "run", + "-d", + "--name", + SAMPLER, + "--cgroupns", + "host", + "--network", + NETWORK, + "--cpus", + p.sampler_cpus, + "--memory", + p.sampler_memory, + "--memory-swap", + p.sampler_memory, + "--env", + "POSTGRES_PASSWORD", + "-e", + f"POSTGRES_USER={self.env_value('POSTGRES_USER')}", + "-e", + f"POSTGRES_DB={self.env_value('POSTGRES_DB')}", + "-v", + f"{SAMPLER_SCRIPT}:/sampler.sh:ro", + "-v", + f"{self.work_dir}:/work", + "--entrypoint", + "bash", + image, + "/sampler.sh", + f"{p.sample_interval_s:g}", + "queue", + queue, + ], + capture_output=True, + text=True, + env={ + **os.environ, + "POSTGRES_PASSWORD": self.env["POSTGRES_PASSWORD"], + }, + check=False, + ) + if proc.returncode != 0: + raise BenchError(f"sampler did not start: {proc.stderr}") + deadline = time.monotonic() + 10 + problem = "no samples" + while time.monotonic() < deadline: + time.sleep(0.5) + samples = scaling.parse_samples(self.sampler_logs()[0]) + jobs = overload.parse_jobs(self.read_work("jobs.log")) + if samples.cg and samples.vm and jobs: + return + problem = ( + f"cgroups {len(samples.cg)}, vm {len(samples.vm)}, " + f"jobs {len(jobs)}" + ) + tail = sh("docker", "logs", "--tail", "5", SAMPLER, check=False) + raise BenchError(f"queue sampler: {problem}\n{tail}") + + def env_value(self, name: str) -> str: + """Значение подстановки compose из `bench.env` стенда (не секрет).""" + for line in ENV_FILE.read_text(encoding="utf-8").splitlines(): + if line.startswith(f"{name}="): + return line.split("=", 1)[1].strip() + raise BenchError(f"{name} is not in {ENV_FILE.name}") + + def read_work(self, name: str) -> str: + path = self.work_dir / name + if not path.exists(): + return "" + return path.read_text(encoding="utf-8", errors="replace") + def container_map(self) -> dict[str, dict[str, str]]: """id12 → имя и роль контейнера (решение 1 design change `profile-resources`): контейнеры проекта (и удалённые не @@ -3663,6 +4097,17 @@ class Results: self.runs.append(row) self.append("passes.csv", reconcile.PASS_FIELDS, row) + def add_cell( + self, + row: dict[str, Any], + timeline: list[dict[str, Any]], + ) -> None: + """Ячейка профиля очереди: шкала, затем строка `cells.csv` — она же + признак готовой ячейки при продолжении.""" + for second in timeline: + self.append("timeline.csv", overload.TIMELINE_FIELDS, second) + self.append("cells.csv", overload.CELL_FIELDS, row) + def add_windows(self, rows: list[dict[str, Any]]) -> None: """Окна фоновой нагрузки прохода — строки `windows.csv`.""" for row in rows: @@ -3720,6 +4165,19 @@ class Results: (self.dir / "summary.md").write_text(text, encoding="utf-8") plots.render_series(self.dir) return + if self.meta["profile"].get("queue_configs"): + # профиль очереди: сводка из таблиц метки, в них и строки прежних + # запусков при продолжении (решение 14 design change + # track1-queue-overload) + rows = overload.read_csv(self.dir / "cells.csv") + text = overload.render_summary(self.meta, rows) + (self.dir / "summary.md").write_text(text, encoding="utf-8") + for name, svg in overload.render_plots( + rows, + overload.read_csv(self.dir / "timeline.csv"), + ).items(): + (self.dir / name).write_text(svg, encoding="utf-8") + return if self.meta["profile"].get("reconcile_stages"): # профиль сверки: сводка и графики (решение 13 design change # track2-reconcile-cost) @@ -4045,6 +4503,9 @@ class Bench: if profile.is_reconcile: # профиль сверки — проходы: этапы и S4, по повторам self.runs_total = len(reconcile_plan(profile)) + if profile.is_queue: + # профиль очереди — ячейки: конфигурация × повтор + self.runs_total = len(profile.queue_configs) * profile.repeats # профиль сверки: длительности проходов для оценки остатка и # фикстура стенда (читаемый чат и его владелец — чат набора) self.pass_seconds: list[float] = [] @@ -4088,6 +4549,14 @@ class Bench: def eta(self) -> float: p = self.profile + if p.is_queue: + # ячейка ≈ 2 мин (решение 14), затем среднее снятых + per_cell = ( + statistics.mean(self.cell_seconds) + if self.cell_seconds + else 120 + ) + return (self.runs_total - self.runs_done) * per_cell if p.is_reconcile: # проход: старт контейнера и сам проход (среднее снятых), тихие # окна проходов под нагрузкой не считаются @@ -4181,6 +4650,9 @@ class Bench: # --------------------------------------------------------- этапы def run(self) -> None: + if self.profile.is_queue: + self.run_queue() + return if self.profile.is_reconcile: self.run_reconcile() return @@ -6012,11 +6484,17 @@ class Bench: info = self.results.meta["uploads"] self.stage = name self.progress() - env = ( - dict(p.uploads_unlimited_env) - if run["variant"] == "unlimited" - else {} - ) + # worker нет, задания копятся: предел заданий мерил бы себя, а не память + # приёма (design change track1-queue-overload, решение 13). Образ «до» + # этой настройки не знает и её игнорирует + env = { + "UPLOADS__MAX_UNFINISHED_JOBS": "0", + **( + dict(p.uploads_unlimited_env) + if run["variant"] == "unlimited" + else {} + ), + } stand.recycle_uploads(image, env) replica = stand.replicas()[0] if run["variant"] not in info["app_env"]: @@ -6126,6 +6604,581 @@ class Bench: ) self.progress(last={"run": name, "flags": row["flags"]}) + # ------------------------------------------------ профиль очереди + + def run_queue(self) -> None: + """Профиль очереди (design change `track1-queue-overload`, решения + 5–11, 14): файлы классов и план в паспорт до первой ячейки, ячейки на + свежем стенде; ячейка, потерявшая работу, — отказ всей метки в конце, но + все ячейки сняты.""" + p = self.profile + meta = self.results.meta + plan = overload.plan_cells( + queue_cell_configs(p), + p.repeats, + p.order_seed, + ) + self.runs_total = len(plan) + classes = self.stand.make_images(p.queue_image_seed) + self.say( + "queue: classes " + + ", ".join( + f"{name} {item['bytes'] / 2**20:.2f} MiB" + for name, item in classes.items() + ), + ) + info: dict[str, Any] = meta.setdefault("queue", {}) + info.update( + { + "classes": classes, + "image_seed": p.queue_image_seed, + "plan": plan, + "rates": {k: list(v) for k, v in QUEUE_RATES.items()}, + "windows": { + "before_s": p.queue_before_s, + "after_s": p.queue_after_s, + "recovery_max_s": p.queue_recovery_max_s, + }, + "control": dict(p.queue_control), + "default_limit": p.queue_default_limit, + }, + ) + info.setdefault("app_env", {}) + self.results.write_meta() + done = { + row["cell"] + for row in overload.read_csv(self.results.dir / "cells.csv") + } + fatal = [] + for row in overload.read_csv(self.results.dir / "cells.csv"): + if any(overload.flagged(row, f) for f in overload.FATAL_FLAGS): + fatal.append(row["cell"]) + self.say(f"queue: {len(plan)} cells planned, {len(done)} already done") + self.runs_done = len(done) + for cell in plan: + if cell["cell"] in done: + continue + started = time.monotonic() + self.stage = cell["cell"] + self.progress() + try: + row = self.queue_cell(cell, classes) + finally: + if not self.stand.stop(): + self.say(f"cleanup incomplete: {leftovers()}") + if any(overload.flagged(row, f) for f in overload.FATAL_FLAGS): + fatal.append(cell["cell"]) + self.runs_done += 1 + self.cell_seconds.append(time.monotonic() - started) + self.progress(last={"cell": cell["cell"], "flags": row["flags"]}) + if fatal: + raise BenchError( + "work was lost in cells: " + ", ".join(sorted(set(fatal))), + ) + + def queue_cell( + self, + cell: dict[str, Any], + classes: dict[str, Any], + ) -> dict[str, Any]: + """Ячейка: свежий стенд, пользователь и чат, разогрев, сэмплер, контрольный + поток, окна `before` и `over`, действие блока, разбор очереди, окно `after`, + обход метаданных, чтение SQL и журналов, строка `cells.csv`.""" + p = self.profile + stand = self.stand + name = cell["cell"] + self.say(f"{name} ({cell['order']}/{self.runs_total}): start") + env = { + "api": ( + {} + if cell["limit"] is None + else {"UPLOADS__MAX_UNFINISHED_JOBS": str(cell["limit"])} + ), + "worker": { + "WORKER__CONCURRENCY": str(cell["concurrency"]), + "WORKER__PREFETCH": str(cell["prefetch"]), + }, + } + stand.queue_overrides({k: v for k, v in env.items() if v}) + stand.start(lambda _: None) + info = self.results.meta["queue"] + limits = stand.limits() + known = self.results.meta.get("limits") + if known is None: + self.results.meta["limits"] = limits + self.results.meta["stand"] = stand.passport() + self.results.write_meta() + elif known != limits: + raise BenchError(f"{name}: limits differ from the first cell") + info["app_env"][cell["config"]] = { + "api": stand.app_env(stand.replicas()[0]), + "worker": stand.app_env(WORKER), + "relay": stand.app_env(RELAY), + } + stand.k6( + "prepare.js", + {"MEMBERS": p.members, "BACKGROUND": "", "WRITE_CHATS": 1}, + ) + self.queue_warm(cell, classes) + + body = classes[cell["class"]] + vus_over = ( + QUEUE_ACCEPT_VUS if cell["block"] == "accept" else QUEUE_OVER_VUS + ) + base_env = {"BODY": body["file"], "MEDIA": body["media_type"]} + queue_name = f"{stand.env_value('POSTGRES_DB')}.attachment.process.v1" + stand.start_queue_sampler(queue_name) + swap_before = swapouts() + control = dict(p.queue_control) + background = stand.k6_console( + "background.js", + { + "DOWNLOAD_RATE": control["download"], + "WRITE_RATE": control["write"], + "READ_RATE": control["read"], + "DURATION": "6h", + "PRE_VUS": 10, + "MAX_VUS": p.queue_control_max_vus, + "NAME": f"{name}-bg", + }, + f"{name}.bg.k6", + ) + extra: dict[str, Any] = {} + action_at = None + try: + time.sleep(2) + load_log = f"{name}.load.k6" + load = stand.k6_console( + "queue.js", + { + **base_env, + "WINDOWS": ( + f"before:{cell['rate_low']}:{cell['before_s']}:" + f"{p.queue_low_vus}," + f"over:{cell['rate_high']}:{cell['over_s']}:{vus_over}" + ), + "NAME": f"{name}-load", + }, + load_log, + ) + t0 = self.queue_wait_t0(load, load_log) + seen = time.monotonic() + over_start = cell["before_s"] + over_end = over_start + cell["over_s"] + action = cell["action"] + if action in ("kill-worker", "restart-broker"): + time.sleep( + max( + 0.0, + seen + + over_start + + cell["over_s"] / 2 + - time.monotonic(), + ), + ) + action_at = t0 + time.monotonic() - seen + if action == "kill-worker": + sh("docker", "kill", WORKER) + # демон считает это ручной остановкой: запуск — явный + sh("docker", "start", WORKER) + else: + stand.compose("restart", BROKER_SERVICE) + elif action == "second-worker": + time.sleep(max(0.0, seen + over_end - time.monotonic())) + action_at = t0 + time.monotonic() - seen + stand.compose( + "run", + "-d", + "--no-deps", + "--name", + WORKER_2, + "worker", + ) + extra["second_started_at"] = action_at + load.wait(timeout=over_end + 180) + if load.returncode != 0: + raise BenchError( + f"{name}: k6 queue.js exit {load.returncode}:\n" + + stand.read_work(f"{load_log}.out")[-3000:], + ) + _, first_part = overload.parse_uploads(stand.read_work(load_log)) + load_end = max( + (u.answered for u in first_part if u.window == "over"), + default=t0 + over_end, + ) + self.queue_wait_zero(load_end, p.queue_recovery_max_s) + after_log = f"{name}.after.k6" + extra["after_start"] = time.time() + after = stand.k6_console( + "queue.js", + { + **base_env, + "WINDOWS": ( + f"after:{cell['rate_low']}:{cell['after_s']}:" + f"{p.queue_low_vus}" + ), + "NAME": f"{name}-after", + }, + after_log, + ) + after.wait(timeout=cell["after_s"] + 180) + if after.returncode != 0: + raise BenchError( + f"{name}: k6 after window exit {after.returncode}:\n" + + stand.read_work(f"{after_log}.out")[-3000:], + ) + extra["after_end"] = time.time() + after_t0, second_part = overload.parse_uploads( + stand.read_work(after_log), + ) + if after_t0 is not None: + extra["after_start"] = after_t0 + extra["after_end"] = after_t0 + cell["after_s"] + after_end = max( + (u.answered for u in second_part), + default=extra["after_end"], + ) + self.queue_wait_zero(after_end, p.queue_recovery_max_s) + self.check_observer(name, t0, after_end) + finally: + sh( + "docker", + "exec", + K6, + "pkill", + "-INT", + "-f", + "background.js", + check=False, + ) + try: + background.wait(timeout=60) + except subprocess.TimeoutExpired: + background.kill() + requests = reconcile.parse_background(stand.read_work(f"{name}.bg.k6")) + bg_data = json.loads( + (self.results.dir / "raw" / f"{name}-bg.json").read_text( + encoding="utf-8", + ), + ) + problems, _ = reconcile.line_problems( + requests, + bg_data, + max_vus=p.queue_control_max_vus, + ) + if problems: + raise BenchError(f"{name}: " + "; ".join(problems)) + uploads_seen = [*first_part, *second_part] + dropped = 0 + for part, log, summary in ( + (first_part, load_log, f"{name}-load"), + (second_part, after_log, f"{name}-after"), + ): + data = json.loads( + (self.results.dir / "raw" / f"{summary}.json").read_text( + encoding="utf-8", + ), + ) + iterations = reconcile.summary_count(data, "iterations") + if iterations is None or iterations != len(part): + raise BenchError( + f"{name}: {len(part)} k6 lines in {log}, {iterations} " + "iterations", + ) + dropped += reconcile.summary_count(data, "dropped_iterations") or 0 + row, timeline = self.queue_collect( + cell, + t0, + uploads_seen, + requests, + dropped, + action_at, + swap_before, + extra, + ) + self.results.add_cell(row, timeline) + self.say( + f"{name}: accepted {row['accepted']}, 429 {row['s429']} (busy " + f"{row['busy_429']}, backlog {row['backlog_429']}), peak " + f"{row['peak_unfinished']}, ready/s {row['ready_s_over']} / " + f"{row['ready_s_recovery']}, recovery {row['recovery_s']} s, p95 " + f"{row['ready_over_p95_s']} s, memory.peak " + f"{row['memory_peak_mib']} MiB, oom {row['oom_kill']}, attempts>1 " + f"{row['attempts_over_one']}, flags [{row['flags']}]", + ) + for path in stand.work_dir.glob(f"{name}.*"): + path.unlink(missing_ok=True) + return row + + def queue_warm( + self, + cell: dict[str, Any], + classes: dict[str, Any], + ) -> None: + """Разогрев (решение 6): файлы `s` до `ready`; они же — готовые байты + контрольного потока.""" + p = self.profile + stand = self.stand + log = f"{cell['cell']}.warm.k6" + warm = stand.k6_console( + "queue.js", + { + "BODY": classes["s"]["file"], + "MEDIA": classes["s"]["media_type"], + "WARM": p.queue_warm, + "NAME": f"{cell['cell']}-warm", + }, + log, + ) + warm.wait(timeout=120) + _, seen = overload.parse_uploads(stand.read_work(log)) + ids = [u.attachment_id for u in seen if u.status == 202] + if warm.returncode != 0 or len(ids) != p.queue_warm: + raise BenchError( + f"{cell['cell']}: warmup accepted {len(ids)} of {p.queue_warm} " + f"(k6 exit {warm.returncode}, statuses " + f"{sorted({u.status for u in seen})})", + ) + deadline = time.monotonic() + QUEUE_WARM_WAIT_S + while True: + left = int( + stand.psql( + "SELECT count(*) FROM attachment_jobs " + "WHERE state IN ('queued', 'processing');\n", + ), + ) + if not left: + break + if time.monotonic() > deadline: + raise BenchError(f"{cell['cell']}: warmup left {left} jobs") + time.sleep(0.5) + (stand.work_dir / "downloads.json").write_text( + json.dumps(ids), + encoding="utf-8", + ) + + def queue_wait_t0( + self, + load: subprocess.Popen[bytes], + log_name: str, + ) -> float: + """Момент начала окон: k6 создаёт VU с телом до `setup()`, это секунды.""" + deadline = time.monotonic() + 120 + while time.monotonic() < deadline: + t0, _ = overload.parse_uploads(self.stand.read_work(log_name)) + if t0 is not None: + return t0 + if load.poll() is not None: + break + time.sleep(0.05) + raise BenchError( + f"k6 queue.js has not started: exit {load.poll()}\n" + + self.stand.read_work(f"{log_name}.out")[-3000:], + ) + + def queue_wait_zero(self, since: float, timeout: float) -> bool: + """Ноль незавершённых по строкам сэмплера после момента `since`; срок + вышел — `False`: пометку `not_recovered` ставит разбор.""" + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + jobs = overload.parse_jobs(self.stand.read_work("jobs.log")) + if any(t.t >= since and t.unfinished == 0 for t in jobs): + return True + time.sleep(1) + return False + + def queue_collect( + self, + cell: dict[str, Any], + t0: float, + uploads_seen: list[overload.Upload], + requests: list[Any], + dropped: int, + action_at: float | None, + swap_before: int | None, + extra: dict[str, Any], + ) -> tuple[dict[str, Any], list[dict[str, Any]]]: + """Обход метаданных, чтение SQL, журналов и счётчиков: строка ячейки.""" + p = self.profile + stand = self.stand + name = cell["cell"] + accepted = [u.attachment_id for u in uploads_seen if u.status == 202] + order = list(accepted) + random.Random(p.order_seed + cell["order"]).shuffle(order) + ids_file = f"{name}.ids.json" + (stand.work_dir / ids_file).write_text( + json.dumps(order), + encoding="utf-8", + ) + sweep_log = f"{name}.sweep.k6" + sweep = stand.k6_console( + "queue_sweep.js", + { + "IDS": ids_file, + "SAMPLE": p.queue_sample, + "NAME": f"{name}-sweep", + }, + sweep_log, + ) + sweep.wait(timeout=620) + if sweep.returncode != 0: + raise BenchError( + f"{name}: k6 queue_sweep.js exit {sweep.returncode}:\n" + + stand.read_work(f"{sweep_log}.out")[-3000:], + ) + metas, checks = overload.parse_sweep(stand.read_work(sweep_log)) + sql = json.loads( + stand.psql( + "SELECT json_build_object(" + "'extra_jobs', (SELECT count(*) FROM (SELECT attachment_id " + "FROM attachment_jobs GROUP BY attachment_id, pipeline_version " + "HAVING count(*) > 1) x), " + "'bad_variants', (SELECT count(*) FROM attachments a " + "WHERE a.status = 'ready' AND (SELECT count(*) FROM " + "attachment_variants v WHERE v.attachment_id = a.id) <> 3), " + "'attempts_over_one', (SELECT count(*) FROM attachment_jobs " + "WHERE attempt > 1), " + "'failed', (SELECT coalesce(json_object_agg(k, n), '{}') FROM " + "(SELECT coalesce(a.error_code, '-') || '/' || " + "coalesce(j.last_error_code, '-') AS k, count(*) AS n " + "FROM attachment_jobs j JOIN attachments a ON " + "a.id = j.attachment_id WHERE j.state = 'failed' GROUP BY 1) s)" + ");\n", + ), + ) + worker_records = reconcile.parse_records(self.queue_log(WORKER)) + started = overload.events(worker_records, "Started worker") + if not started: + raise BenchError(f"{name}: no «Started worker» record") + for record in started: + if ( + record.get("concurrency") != cell["concurrency"] + or record.get("prefetch") != cell["prefetch"] + ): + raise BenchError( + f"{name}: worker started with " + f"({record.get('concurrency')}, {record.get('prefetch')}), " + f"cell ({cell['concurrency']}, {cell['prefetch']})", + ) + second_records = ( + reconcile.parse_records(self.queue_log(WORKER_2)) + if cell["action"] == "second-worker" + else [] + ) + relay_records = reconcile.parse_records(self.queue_log(RELAY)) + api_records = [ + record + for replica in stand.replicas() + for record in reconcile.parse_records(self.queue_log(replica)) + ] + samples = scaling.parse_samples(stand.sampler_logs()[0]) + mapping = stand.container_map() + worker_ids = { + ident for ident, item in mapping.items() if item["name"] == WORKER + } + cg: dict[str, list[list[list[tuple[int, ...]]]]] = {} + for (_, ident), points in samples.cg.items(): + role = mapping.get(ident, {}).get("role", "") + if not role: + continue + cg.setdefault(role, []).append(overload.split_lives(points)) + text = stand.sampler_logs()[0] + mp_all = overload.parse_mp(text) + mp = { + "worker": [ + life + for ident in worker_ids + for life in overload.split_lives(mp_all.get(ident, [])) + ], + } + broker_id = next( + (i for i, item in mapping.items() if item["name"] == BROKER), + None, + ) + broker_points = [ + point + for key, points in samples.cg.items() + if key[1] == broker_id + for point in points + ] + extra["broker_memory_mib"] = ( + round(max(point[5] for point in broker_points) / 2**20, 1) + if broker_points + else None + ) + extra["broker_refused"] = sum( + 1 + for record in relay_records + if record.get("event") == "Relay pass" + and record.get("unconfirmed") + ) + mq, mq_missing = overload.parse_mq(text) + swap_after = swapouts() + swapped = ( + None + if swap_before is None or swap_after is None + else swap_after - swap_before + ) + hwm = sh( + "docker", + "exec", + WORKER, + "sh", + "-c", + "grep VmHWM /proc/1/status", + check=False, + ).split() + restarts = sh( + "docker", + "inspect", + "-f", + "{{.RestartCount}}", + WORKER, + check=False, + ) + lb_down = any( + sum(1 for row in rows if row.get("status") == "UP") < p.replicas + for rows in samples.lb.values() + ) + src = overload.Sources( + uploads=uploads_seen, + t0=t0, + metas=metas, + sha_checks=checks, + jobs=overload.parse_jobs(stand.read_work("jobs.log")), + mq=mq, + mq_missing=mq_missing, + cg=cg, + mp=mp, + control=requests, + worker_records=worker_records, + second_records=second_records, + relay_records=relay_records, + api_records=api_records, + sql=sql, + hwm_kib=int(hwm[1]) if len(hwm) >= 2 else None, + restarts=int(restarts) if restarts.isdigit() else 0, + dropped=dropped, + action_at=action_at, + swapouts=swapped, + lb_down=lb_down, + storage_down=bool(stand.down_storages()) + or not stand.exit_state(S3)["running"], + extra=extra, + ) + stand.stop_sampler() + return overload.cell_row(cell, src), overload.timeline_rows(cell, src) + + def queue_log(self, container: str) -> str: + proc = subprocess.run( + ["docker", "logs", container], + capture_output=True, + text=True, + errors="replace", + check=False, + ) + return proc.stdout + proc.stderr + # ------------------------------------------------ профиль сверки def run_reconcile(self) -> None: @@ -7348,8 +8401,8 @@ def main(argv: list[str]) -> int: ) return 2 profile, overrides = apply_overrides(PROFILES[args.profile], args) - if args.resume and not profile.is_series: - print("--resume: track 1 series profiles only", flush=True) + if args.resume and not (profile.is_series or profile.is_queue): + print("--resume: track 1 series and queue profiles only", flush=True) return 2 if profile.is_rollout: # commit методики — до стенда, а не на шестой секунде сборки @@ -7395,6 +8448,10 @@ def main(argv: list[str]) -> int: # стоимость сверки — рядом с evidence change track2-reconciler # (решение 1 design change track2-reconcile-cost) kind = "reconcile" + if profile.is_queue: + # очередь под перегрузкой: трек 1 лабы 5 (design change + # track1-queue-overload, решение 14) + kind = "queue" label_dir = ROOT / "evidence" / kind / args.label relative = label_dir.relative_to(ROOT) if label_dir.exists() and not args.resume: @@ -7402,7 +8459,11 @@ def main(argv: list[str]) -> int: return 2 # чистота дерева серии — без своей метки: её частичные результаты при # продолжении не изменение кода (решение 5 design change scaling-bench) - git = git_info(exclude=str(relative) if profile.is_series else None) + git = git_info( + exclude=( + str(relative) if profile.is_series or profile.is_queue else None + ), + ) if args.resume: problems = resume_problems(label_dir, profile, git) if problems: @@ -7419,7 +8480,7 @@ def main(argv: list[str]) -> int: return 2 plan_budget: dict[str, Any] | None = None peak_budget: dict[str, Any] | None = None - if profile.is_series or profile.sample_resources: + if profile.is_series or profile.sample_resources or profile.is_queue: info = sh( "docker", "info", @@ -7442,6 +8503,17 @@ def main(argv: list[str]) -> int: flush=True, ) return 2 + if profile.is_queue: + # профиль очереди: сумма лимитов с двумя worker (решение 10 design + # change track1-queue-overload) + peak_budget = queue_budget(profile, vm_cpus, vm_memory) + if peak_budget["cpus"] > vm_cpus: + print( + f"CPU limits at peak {peak_budget['cpus']:g} CPU exceed docker " + f"VM CPUs ({vm_cpus})", + flush=True, + ) + return 2 if profile.is_series: # сумма лимитов CPU конфигурации не больше CPU ВМ (решение 1) plan_budget = budget(profile, vm_cpus, vm_memory) @@ -7515,7 +8587,7 @@ def main(argv: list[str]) -> int: if git["dirty"]: say("NOTE: working tree has uncommitted changes (dirty: true)") try: - if profile.is_series: + if profile.is_series or (profile.is_queue and args.resume): # блокировка взята: остатки — от прерванного прогона, серия # убирает их сама (решение 5 design change scaling-bench) stand_check.remove_leftovers(say) diff --git a/bench/sampler.sh b/bench/sampler.sh index 1a15983b..17c8dca6 100644 --- a/bench/sampler.sh +++ b/bench/sampler.sh @@ -34,6 +34,14 @@ # `pk <нс> <роль> 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 <нс> +# ` на контейнер и `mq <нс> +# ` — метрики брокера 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 < 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 diff --git a/config_example.toml b/config_example.toml index be114351..2b9768c1 100644 --- a/config_example.toml +++ b/config_example.toml @@ -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 diff --git a/openspec/changes/track1-queue-overload/design.md b/openspec/changes/track1-queue-overload/design.md index 37e6a9b2..cc10c99b 100644 --- a/openspec/changes/track1-queue-overload/design.md +++ b/openspec/changes/track1-queue-overload/design.md @@ -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`: ни один не меняет подход и задачи; другой ответ меняет строку таблицы ошибок и сценарий. diff --git a/openspec/changes/track1-queue-overload/tasks.md b/openspec/changes/track1-queue-overload/tasks.md index 0839b1fe..f47b6b07 100644 --- a/openspec/changes/track1-queue-overload/tasks.md +++ b/openspec/changes/track1-queue-overload/tasks.md @@ -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`. diff --git a/openspec/specs/attachments/spec.md b/openspec/specs/attachments/spec.md index 3d28cd09..8e02c3b8 100644 --- a/openspec/specs/attachments/spec.md +++ b/openspec/specs/attachments/spec.md @@ -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: Посторонний с большим файлом diff --git a/openspec/specs/health/spec.md b/openspec/specs/health/spec.md index 61d016dc..34b8b14c 100644 --- a/openspec/specs/health/spec.md +++ b/openspec/specs/health/spec.md @@ -37,6 +37,9 @@ MUST NOT зависеть от состояния хранилища. - relay — публикация заданий: без него задания ждут в PostgreSQL; - worker — фоновая обработка: без него загрузки ждут в очереди. +Предел незавершённых заданий (`queue-overload`) на готовность MUST NOT влиять: реплика, которая +отвечает на загрузку 429, обслуживает остальные запросы и остаётся готовой. + Проверка MUST NOT обращаться к S3 и брокеру и MUST NOT требовать идентификации. Перечень критичных и некритичных зависимостей с причинами SHALL быть в `REPORT.md`. diff --git a/openspec/specs/job-outbox/spec.md b/openspec/specs/job-outbox/spec.md index beddd344..6bba1e6a 100644 --- a/openspec/specs/job-outbox/spec.md +++ b/openspec/specs/job-outbox/spec.md @@ -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: Очередь ограничена пределом diff --git a/openspec/specs/load-benchmark/spec.md b/openspec/specs/load-benchmark/spec.md index d3c7b4dd..f2e1fcbf 100644 --- a/openspec/specs/load-benchmark/spec.md +++ b/openspec/specs/load-benchmark/spec.md @@ -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** у каждой гипотезы есть вывод со ссылкой на ячейки сводки, числа совпадают со сводкой, а рекомендуемая настройка следует из правила и таблиц diff --git a/openspec/specs/message-broker/spec.md b/openspec/specs/message-broker/spec.md index f4b78f8a..03404113 100644 --- a/openspec/specs/message-broker/spec.md +++ b/openspec/specs/message-broker/spec.md @@ -76,8 +76,9 @@ PostgreSQL, и следующий проход публикует его сно Отдельный вызов публикации MUST NOT зависать дольше этого срока. Брокер не критичен для обязательного пути и для приёма файлов: без него SHALL работать -загрузка (202), отправка текста, история, метаданные, скачивание готового вложения и -`/health/ready` (`health`, «Readiness»). +загрузка (202, пока не достигнут предел незавершённых заданий — `queue-overload`), отправка +текста, история, метаданные, скачивание готового вложения и `/health/ready` (`health`, +«Readiness»). После возврата брокера публикация SHALL проходить без перезапуска процесса. diff --git a/openspec/specs/queue-overload/spec.md b/openspec/specs/queue-overload/spec.md new file mode 100644 index 00000000..9e19608d --- /dev/null +++ b/openspec/specs/queue-overload/spec.md @@ -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 не изменились diff --git a/openspec/specs/service-configuration/spec.md b/openspec/specs/service-configuration/spec.md index 884961c3..7c63ef28 100644 --- a/openspec/specs/service-configuration/spec.md +++ b/openspec/specs/service-configuration/spec.md @@ -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** сервис не стартует, в журнале — ошибка проверки настроек с именем поля diff --git a/openspec/specs/student-tests/spec.md b/openspec/specs/student-tests/spec.md index 90b22f47..2e31dfe2 100644 --- a/openspec/specs/student-tests/spec.md +++ b/openspec/specs/student-tests/spec.md @@ -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 объекта по ключу; diff --git a/service-tests/db/test_uow.py b/service-tests/db/test_uow.py index 65d4b62d..ae77c487 100644 --- a/service-tests/db/test_uow.py +++ b/service-tests/db/test_uow.py @@ -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, diff --git a/service-tests/fakes/repos.py b/service-tests/fakes/repos.py index 7e297c70..768b14e8 100644 --- a/service-tests/fakes/repos.py +++ b/service-tests/fakes/repos.py @@ -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, *, diff --git a/service-tests/repo_contract.py b/service-tests/repo_contract.py index d93d0c98..81539747 100644 --- a/service-tests/repo_contract.py +++ b/service-tests/repo_contract.py @@ -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)) diff --git a/service-tests/unit/conftest.py b/service-tests/unit/conftest.py index f09d7041..4ec6856e 100644 --- a/service-tests/unit/conftest.py +++ b/service-tests/unit/conftest.py @@ -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: diff --git a/service-tests/unit/test_attachment_service.py b/service-tests/unit/test_attachment_service.py index 781d97dc..6a0df711 100644 --- a/service-tests/unit/test_attachment_service.py +++ b/service-tests/unit/test_attachment_service.py @@ -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, diff --git a/src/api/errors.py b/src/api/errors.py index d11f0930..1d38100f 100644 --- a/src/api/errors.py +++ b/src/api/errors.py @@ -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]] = { diff --git a/src/config/settings.py b/src/config/settings.py index 77048a70..6e11e4b4 100644 --- a/src/config/settings.py +++ b/src/config/settings.py @@ -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): diff --git a/src/core/exceptions/__init__.py b/src/core/exceptions/__init__.py index 2b6da361..ee84a0a9 100644 --- a/src/core/exceptions/__init__.py +++ b/src/core/exceptions/__init__.py @@ -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", diff --git a/src/core/exceptions/attachment.py b/src/core/exceptions/attachment.py index 9e65e1ba..d4dbc09f 100644 --- a/src/core/exceptions/attachment.py +++ b/src/core/exceptions/attachment.py @@ -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): """Тело загрузки не пришло целиком за срок после занятия места.""" diff --git a/src/core/ports/attachment_job.py b/src/core/ports/attachment_job.py index 5fedadf8..e9a8056d 100644 --- a/src/core/ports/attachment_job.py +++ b/src/core/ports/attachment_job.py @@ -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, diff --git a/src/core/repos/attachment_job.py b/src/core/repos/attachment_job.py index 60ca2c49..644a92ea 100644 --- a/src/core/repos/attachment_job.py +++ b/src/core/repos/attachment_job.py @@ -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, *, diff --git a/src/core/services/attachment.py b/src/core/services/attachment.py index 8dd55abb..2a7895d0 100644 --- a/src/core/services/attachment.py +++ b/src/core/services/attachment.py @@ -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: diff --git a/src/main.py b/src/main.py index 539af910..4b48e82c 100644 --- a/src/main.py +++ b/src/main.py @@ -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 diff --git a/src/utils/constants.py b/src/utils/constants.py index 186b06ab..3274eb87 100644 --- a/src/utils/constants.py +++ b/src/utils/constants.py @@ -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 diff --git a/student-tests/conftest.py b/student-tests/conftest.py index b5ce42ec..aef54170 100644 --- a/student-tests/conftest.py +++ b/student-tests/conftest.py @@ -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 diff --git a/student-tests/fault_hook.py b/student-tests/fault_hook.py index b5aa4c7f..d1d4f3c0 100755 --- a/student-tests/fault_hook.py +++ b/student-tests/fault_hook.py @@ -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: diff --git a/student-tests/run_failures.py b/student-tests/run_failures.py index ba3e84fe..139bdc50 100644 --- a/student-tests/run_failures.py +++ b/student-tests/run_failures.py @@ -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 diff --git a/student-tests/spec_coverage.py b/student-tests/spec_coverage.py index 370a6c73..8100e3e6 100644 --- a/student-tests/spec_coverage.py +++ b/student-tests/spec_coverage.py @@ -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") diff --git a/student-tests/test_failures.py b/student-tests/test_failures.py index 1bdb4ad4..498d5a47 100644 --- a/student-tests/test_failures.py +++ b/student-tests/test_failures.py @@ -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)