From 8d4cf7eebf0b3b952699da97389d2f2c57f9744c Mon Sep 17 00:00:00 2001 From: roman Date: Fri, 23 Oct 2026 04:52:56 +0300 Subject: [PATCH] feat: add reconcile strategies, deep check, rate limit and cost profile - reconcile --strategy head, --deep (checksum_mismatch), restore needs the same SHA-256 - [reconciler] max_objects_per_second (2000), pause interrupted by signal - --apply stops rechecks once the limit is exceeded (unchecked) - pass cost in the summary: S3 objects and requests, bytes, DB sessions, phases - S3 client counters, cleaner exits with os._exit after main() - fault tests, hook args, driver reconcile-signal --pace - bench profile reconcile / reconcile_quick: fill outside the API, gateway metrics, background load - sync spec deltas, rules, AGENTS.md, PLAN.md Co-Authored-By: Claude Opus 5.5 --- .claude/rules/bench.md | 108 +- .claude/rules/docker.md | 6 +- .claude/rules/dto.md | 11 + .claude/rules/infra.md | 13 +- .claude/rules/logging.md | 12 +- .claude/rules/run-modes.md | 14 +- .claude/rules/service-layer.md | 45 +- .claude/rules/settings.md | 13 + .claude/rules/student-tests.md | 35 +- .claude/skills/run-mtusi-messenger/SKILL.md | 3 +- .claude/skills/run-mtusi-messenger/driver.py | 209 +- .gitignore | 2 + AGENTS.md | 50 +- Makefile | 31 +- PLAN.md | 46 + bench/bench.compose.yml | 19 +- bench/fill_objects.py | 116 + bench/k6/background.js | 125 ++ bench/reconcile.py | 1908 +++++++++++++++++ bench/run.py | 1027 ++++++++- config_example.toml | 4 + .../changes/track2-reconcile-cost/design.md | 72 + .../changes/track2-reconcile-cost/tasks.md | 52 +- openspec/specs/graceful-shutdown/spec.md | 14 +- openspec/specs/load-benchmark/spec.md | 192 +- openspec/specs/service-configuration/spec.md | 24 +- openspec/specs/service-logging/spec.md | 36 +- openspec/specs/storage-consistency/spec.md | 163 +- openspec/specs/student-tests/spec.md | 3 +- src/cleaner/__main__.py | 12 +- src/cleaner/main.py | 81 +- src/config/settings.py | 4 + src/core/services/attachment_reconcile.py | 871 +++++--- src/infra/s3/__init__.py | 2 + src/infra/s3/client.py | 54 +- src/schemas/dataclasses/attachment.py | 36 +- src/schemas/enums/__init__.py | 2 + src/schemas/enums/attachment.py | 15 + src/utils/constants.py | 4 + student-tests/fault_hook.py | 60 +- student-tests/test_failures.py | 291 ++- 41 files changed, 5344 insertions(+), 441 deletions(-) create mode 100644 bench/fill_objects.py create mode 100644 bench/k6/background.js create mode 100644 bench/reconcile.py diff --git a/.claude/rules/bench.md b/.claude/rules/bench.md index ff4268e7..7bc7e1aa 100644 --- a/.claude/rules/bench.md +++ b/.claude/rules/bench.md @@ -99,6 +99,7 @@ change `s3-storage`, решение 9): старт стенда перечисл | `run.py` (профили `failover`, `failover_quick`), `failover.py`, `resources.py`, `sampler.sh` (режим `scan`), `k6/failover.js`, `k6/retry.js` | `make bench_failover`, `make bench_failover_quick` | две реплики с лимитами рабочего стенда, постоянная интенсивность записи с ключом и чтения, каждая реплика в каждом режиме (`stop`, `kill`, `pause`) с возвратом: посекундная шкала, время обнаружения и восстановления, сверка записей, CPU и память каждого компонента по окнам фазы; результаты — `evidence/failover/<метка>/` | | `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` (профили `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` | дельта двух меток стенда (ячейки матрицы или общие конфигурации серий), эффект или шум | @@ -158,10 +159,15 @@ change `s3-storage`, решение 9): старт стенда перечисл поля в паспорте не имеют. Там же исправлено: контейнер сэмплера (образ PostgreSQL) удаляется с `-v`, иначе каждый запуск оставлял анонимный volume `/var/lib/postgresql`; -- **S3** — запускает только профиль `uploads`: образ, аргументы и - лимиты рабочего стенда (`BENCH_S3_*`, 1 CPU / 512 МБ, swap = память), - bucket `bench` (`bench.env`) и пользователи — тот же `s3-bootstrap`; - override `s3` нужен compose и в остальных профилях; +- **S3** — запускают только профили `uploads` и `reconcile`: образ, + аргументы и лимиты рабочего стенда (`BENCH_S3_*`, 1 CPU / 512 МБ, swap = + память; у `reconcile` — ещё порт метрик шлюза на loopback), bucket + `bench` (`bench.env`) и пользователи — тот же `s3-bootstrap`; override + `s3` нужен compose и в остальных профилях; +- **уборщик** — запускает только профиль `reconcile` разовыми проходами: + лимиты `BENCH_CLEANER_*` (`cleaner_cpus` 0,25, `cleaner_memory` 256m — + рабочего стенда, без swap) compose требует при разборе у всех профилей; + окружение реплик (`stand.app_env`) они не меняют; - **PostgreSQL `max_connections`:** 100, как у образа (`-c max_connections` в override); у серий — из конфигурации ячейки, лимиты конфигурации в паспорте (`limits.<конфигурация>`); @@ -375,6 +381,100 @@ docker — `bench/uploads.py` (`--selftest`). рабочий стенд остановлен (`make stop`), гипотезы H1–H4 закоммичены раньше метки. +## Профиль сверки (`reconcile`) + +Спек `load-benchmark`, «Профиль сверки» и «Стоимость сверки в отчёте»; +design change `track2-reconcile-cost`, решения 1–3, 7–13. Методика — поля +`Profile` (`reconcile_*`, `cleaner_*`) в `run.py`, модель набора, план, +разбор, вердикты и сводка без docker — `bench/reconcile.py` +(`--selftest`), загрузчик объектов — `bench/fill_objects.py`, фоновая +нагрузка — `bench/k6/background.js`. + +- **Стенд:** LB, две реплики 1 CPU / 512 МБ, PostgreSQL 2 / 1 ГБ, Valkey + 0,5 / 128 МБ, S3 и `s3-bootstrap` рабочего стенда; к аргументам S3 + добавлен `-metricsPort=9327` (override `.work/s3-metrics.compose.yml` + из `command` сервиса `s3` по `docker compose config` того же стенда — + списка аргументов в двух местах нет). Порт слушает loopback контейнера + S3, из сети стенда недоступен; **у прочих профилей и рабочего стенда его + нет**. Сэмплер `scan` с интервалом 0,5 с (`reconcile_sample_interval_s`) + на этап, k6 без лимита. +- **Проход** — разовый уборщик `docker compose run -d --name + mtusi-bench-reconcile- --no-deps -e CLEANER__PENDING_GRACE_SECONDS=30 + cleaner reconcile …` (лимиты `BENCH_CLEANER_*` в `bench.compose.yml` — + 0,25 CPU / 256 МБ без swap, в управляемом опыте `BENCH_CLEANER_CPUS=1` + на вызов), затем `docker wait`, журнал, `docker inspect` и `docker rm` + при любом исходе. Вариант «до» — тот же вызов с override + `.work/cleaner-before.compose.yml` (`image: mtusi-messenger:bench-from`, + `Profile.reconcile_before` — `7f4e626`, последний commit до change; + `git archive` → тег `bench-from`, проверка commit до стенда — код 2, как + у `rollout_from`; смена при переходе в лабу 5 — так же). Тег стенда не + меняется. +- **Этапы полной метки:** A — свежий стенд, 1 000 × 1 MiB, `batch`, + `deep`, `deep-fast`; B — свежий, 10 000 × 4 KiB, `batch`, `head`, + `deep`; C — тот же, +20 000, `batch`, `head`; D — тот же, +70 000, + `batch` и блок под нагрузкой `stand`, `stand-unlimited`, + `fast-unlimited`, `fast-limited`; S4 — свежий, 10 000 согласованных и + 1 000, затем 10 000 строк `ready` без объектов, `before` и `after` + (`--apply --max-changes 100`, у `after` — без предела скорости). Три + повтора кругами внутри группы (`reconcile.plan_passes`), план — в + `meta.json` до первого прохода. Ячейки без нагрузки — dry-run без + предела скорости. `reconcile_quick` — один стенд 2 000 × 4 KiB, все + виды по одному проходу, окна 5 с, S4 с 300 кандидатами на своём свежем + стенде. +- **Набор** (решение 2): объект `i` — `id` UUID v4 из SHA-256 + `<зерно>:`, содержимое — повторённый SHA-256 `<зерно>::c`, класс — + `i mod 400` (0 — объект без строки, 1 — строка без объекта, 2 — размер + в строке на байт больше, 3 — зависшая загрузка `pending` с объектом); + строки — читаемый чат и его владелец из `prepare.js`, `created_at` = + `updated_at` = сутки назад. Проходы этапа — через grace + 2 с после + последнего PUT. Каждый проход сверяет `found` по классам, + `listed_objects` и `checked_rows` с моделью (`reconcile.model`): + расхождение — отказ команды с проходом, классом и обоими числами. +- **Граница чёрного ящика** — новые исключения, только у этого профиля и + только на свежем стенде `mtusi-bench`: + - метаданные набора — `\copy attachments (…) FROM STDIN` через `docker + exec -i … psql` (данные стенда, схему не трогает; файла CSV нет — + строки генерирует `reconcile.rows_csv`); + - объекты — `bench/fill_objects.py` в контейнере `mtusi-bench-fill` на + образе стенда (botocore образа, `src` не импортируется, `bench/` на + чтение, ключи API — `docker run -e <имя>` без значения в argv, три + процесса × 24 потока); + - метрики шлюза S3 — `docker exec mtusi-bench-s3 wget` на loopback до + и после прохода; `pg_stat_database` — psql до и после; + - проход — процесс уборщика из образа, результат — его записи + «Started cleaner», «Finished reconcile pass», «Reconcile changes + exceed limit» (`raw/<проход>-cleaner.json`; записи о расхождениях — + числом). + `mtusi-bench-fill` и `mtusi-bench-reconcile-*` — в остатках стенда и в + уборке `Stand.stop()`. +- **Счёт S3:** шлюз считает HEAD типом GET, поэтому `LIST = list`, + `GET = head + get`, `DELETE = delete`; в ячейках без нагрузки неравенство + — пометка `count_mismatch` (строка остаётся). +- **Ресурсы:** окно прохода — `[t − duration_ms, t]`, `t` — время записи + «Finished reconcile pass» (часы ВМ); CPU уборщика (по `id` контейнера + прохода), S3, PostgreSQL, реплик и LB — по отсчётам сэмплера; память + уборщика — выборка у начала окна и наибольшая за жизнь контейнера. +- **Фоновая нагрузка (H4):** один k6 `background.js` на блок — 300 + скачиваний (5 000 согласованных вложений от зерна, `.work/downloads.json`), + 50 записей и 50 чтений истории в секунду; тихие окна 30 с перед первым + проходом и после каждого; окна «до» и «после» — по старту и выходу + контейнера, окно прохода — по итогу. k6 останавливается `pkill -INT -f + background.js` в контейнере k6 (итог он пишет и тогда); строк `bg,…` + столько же, сколько итераций сценариев, иначе отказ. `r` = p95 прохода + / p95 тихих, `a` = p95 до / p95 после; 5xx — пометка `bg_5xx`. +- **Сравнение:** все варианты — внутри одной метки; второй метки A/A нет + (шум — разброс повторов и `a`). `make bench_compare` метки сверки не + сравнивает: он читает `evidence/bench/`, у сверки другая методика. +- **Результаты:** `evidence/reconcile/<метка>/` — `meta.json` (раздел + `reconcile`: план, этапы и модели, commit и образы «до», аргументы S3, + CPU уборщика, фоновая нагрузка; `limits.cleaner` по CPU), `passes.csv` + (строка на проход, новые столбцы — в конец), `windows.csv`, `summary.md` + (таблицы, S4, вердикты H1–H4 и S4), `cost-by-n.svg`, `requests-by-n.svg`, + `background-p95.svg`, `raw/`. `quick-reconcile-*` — в `.gitignore`. +- **Время:** полная метка ~50 мин, быстрая ~6 мин. Замер для отчёта — + `make bench_reconcile` на тихом хосте, рабочий стенд остановлен (`make + stop`), гипотезы H1–H4 закоммичены раньше метки. + ## Серии трека 1 (`scaling_*`) Доказательство уровня «5», трек 1 «Цена масштабирования» (design change diff --git a/.claude/rules/docker.md b/.claude/rules/docker.md index 565c26ec..05c267fa 100644 --- a/.claude/rules/docker.md +++ b/.claude/rules/docker.md @@ -313,7 +313,11 @@ git ls-files -z -co --exclude-standard | tar --null -T - -cf - | docker build -t уборщика нет; разовый проход — `docker compose run --rm --no-deps cleaner --once`. Стенд отказов запускает его с grace 20 с, интервалом 1 с и без плановой сверки (`RECONCILER__INTERVAL_SECONDS: "0"`, - `student-tests.md`), `bench/` описывает (тоже с 0), но не запускает. + `student-tests.md`), `bench/` описывает (тоже с 0) и запускает только + разовыми проходами профиля сверки (`bench.md`, «Профиль сверки»). Выход + процесса — `os._exit` после `main()` (`src/cleaner/__main__.py`): + финализация интерпретатора при 0,25 CPU — до 1,5 с (design change + `track2-reconcile-cost`, «Уточнения apply», п. 14). С change `track2-reconciler` сервис ещё и сверяет bucket с БД — при старте и раз в `[reconciler] interval_seconds` (3600 с); разовая сверка — `make reconcile [APPLY=1] [MAX_CHANGES=N]` (`docker compose diff --git a/.claude/rules/dto.md b/.claude/rules/dto.md index e75eea6e..bf2d7cf9 100644 --- a/.claude/rules/dto.md +++ b/.claude/rules/dto.md @@ -56,3 +56,14 @@ paths: `ReconcileFindingDTO` (класс, ключ, `id`, возраст, размеры) и `ReconcilePassDTO` (итог прохода; `found` и `fixed` — неизменяемые отображения `MappingProxyType`, а не `dict`: DTO frozen). +- Стоимость сверки (design change `track2-reconcile-cost`, решения 8 и + 15): `ReconcileFinding.CHECKSUM_MISMATCH` (`checksum_mismatch`) и + `ReconcileStrategy` (`batch`, `head`) в `enums/attachment.py`; + `ReconcilePassDTO` — новые поля в конце со значениями по умолчанию: + `strategy`, `deep`, `max_objects_per_second`, `storage_objects`, + `s3_requests` и `phase_ms` (`MappingProxyType`, по умолчанию пустой — + `field(default_factory=…)`), `read_bytes`, `db_sessions`, `unchecked`; + `ReconcileFindingDTO.sha256: bytes | None = None` — SHA-256 строки для + перепроверки прочитанного объекта, в журнал не попадает. Снимок + счётчиков клиента S3 `StorageStats` — тип `src/infra/s3`, не DTO + слоёв. diff --git a/.claude/rules/infra.md b/.claude/rules/infra.md index 8e001292..9bab9f34 100644 --- a/.claude/rules/infra.md +++ b/.claude/rules/infra.md @@ -219,12 +219,21 @@ paths: префикс). Нет bucket — `ObjectStorageUnavailable` («bucket is missing»), а не пустая страница: у списка и 404 без тела считается отсутствующим bucket; отказ в списке — «denied access». - `StoredObjectInfo.last_modified` — из списка и HEAD (часы S3, - точность — секунда), у `open` — `None`. Порядок списка SeaweedFS — + `StoredObjectInfo.last_modified` — из списка, HEAD и GET (часы S3, + точность — секунда). Порядок списка SeaweedFS — обход каталогов, а не порядок байтов: сверка не сливает отсортированные потоки, а собирает множество ключей. Префикс — только `/attachments/` (repo): политика уборщика другие префиксы запрещает; + - счётчики клиента (design change `track2-reconcile-cost`, решение 8): + попытки вызовов по операциям — в `_call` до вызова, в том числе + неудачные (`OPERATION_NAMES`: `list`, `head`, `get`, `delete`, `put`), + ключи страниц — в `list_page`, прочитанные байты — в `_read_chunk`. + `stats()` — неизменяемый снимок `StorageStats` (`calls` — + `MappingProxyType`); стоимость прохода сверка считает разностью + снимков. На поведение, сроки и перевод ошибок счётчики не влияют. + `open` отдаёт и `last_modified` (GET), чтобы глубокая сверка `head` + проверяла свежесть без HEAD; - адресация `path`: `bucket.s3` Docker DNS не разрешает; простаивающее соединение aiohttp закрывает через `S3_KEEPALIVE_TIMEOUT_SECONDS` (15 с), раньше шлюза (120 с); diff --git a/.claude/rules/logging.md b/.claude/rules/logging.md index 8d5de8fb..d226fa92 100644 --- a/.claude/rules/logging.md +++ b/.claude/rules/logging.md @@ -201,7 +201,17 @@ paths: `fresh_rows`, `lost_known`, `refused`, `unlogged`, `interrupted_by`, `duration_ms`): `info`, если ничего не осталось, иначе `warning`; - предел — `error` «Reconcile changes exceed limit» (`changes`, - `max_changes`); + `max_changes`, с change `track2-reconcile-cost` — `unchecked`; + `changes` после раннего отказа — `max_changes + 1`, нижняя граница); + - стоимость прохода (change `track2-reconcile-cost`, решения 8 и 15): + записи прохода связаны полями `strategy` и `deep`; итог ещё называет + `max_objects_per_second`, `storage_objects`, `s3_requests` (`list`, + `head`, `get`, `delete`), `read_bytes`, `db_sessions`, `unchecked`, + `phase_ms` (`list`, `rows`, `stale`, `recheck`, `act`) — ключи + постоянные, значения числа; «Started cleaner» — ещё + `reconcile_max_objects_per_second`, а у разового прохода + `reconcile_strategy` и `reconcile_deep` (у сервиса — `null`). SHA-256 + объектов и строк в записях нет; - непредвиденная ошибка — `error` «Reconcile pass failed» с traceback (`cleaner`); «Started cleaner» с change называет ещё `mode`, `reconcile_interval_seconds`, `reconcile_page_size`, diff --git a/.claude/rules/run-modes.md b/.claude/rules/run-modes.md index f632fadc..404b8a86 100644 --- a/.claude/rules/run-modes.md +++ b/.claude/rules/run-modes.md @@ -137,7 +137,19 @@ access_log=False)`. Импорты в `src/__main__.py` — внутри `if __n уборки и времени до сверки. Пока идёт сверка, уборка ждёт; - SIGTERM во время сверки: текущий вызов S3 или шаг с БД доводится, новые страницы и действия не начинаются, итог — `interrupted_by: - stop`; сервис выходит с кодом 0, разовый проход — с 1. + stop`; сервис выходит с кодом 0, разовый проход — с 1. Паузу предела + скорости сигнал прерывает сразу (куски по 0,2 с): остановка — не + позже секунды (`driver.py reconcile-signal --pace`). Для этого + `src/cleaner/__main__.py` после `main()` выходит `os._exit(code)` + (stdout и stderr сброшены, клиенты закрыты): финализация + интерпретатора при 0,25 CPU — 0,8–1,5 с (design change + `track2-reconcile-cost`, «Уточнения apply», п. 14); + - с change `track2-reconcile-cost` (решения 4–6) у разового прохода ещё + `--strategy {batch,head}` (по умолчанию `batch`), `--deep` и + `--max-objects-per-second R` (≥ 0, иначе ошибка argparse, код 2; без + аргумента — `[reconciler] max_objects_per_second`); `make reconcile + STRATEGY=head DEEP=1 RATE=R`. Плановая сверка — всегда `batch`, без + глубокой, предел из настроек. - Непредвиденная ошибка прохода — `error` с traceback, процесс живёт до следующего прохода; отказ S3 или PostgreSQL — `warning`, без перезапуска (решение 5). diff --git a/.claude/rules/service-layer.md b/.claude/rules/service-layer.md index 3a5187e7..f5d8e008 100644 --- a/.claude/rules/service-layer.md +++ b/.claude/rules/service-layer.md @@ -180,9 +180,48 @@ paths: объект»: без HEAD, без пометки и без уборки; HEAD, пометка, снятие и DELETE ещё раз проверяют префикс (design change `track2-reconciler`, «Уточнения apply», п. 19). Отказ S3 или БД — `interrupted_by`, после - сигнала — `stop`; `stop_requested()` (`_check_stop`) — перед каждым - вызовом S3 и шагом с БД: остановка ждёт не больше одного вызова (п. - 20); + сигнала — `stop`; `stop_requested()` (`_Pass.check_stop`) — перед + каждым вызовом S3 и шагом с БД: остановка ждёт не больше одного вызова + (п. 20); + - стоимость сверки (design change `track2-reconcile-cost`, решения + 4–8): `reconcile(…, strategy, deep, max_objects_per_second, …)`. + Параметры, счётчики и находки прохода — `_Pass`, вызовы S3 — свои + обёртки сервиса (`_list_page`, `_probe`, `_head`, `_read`, `_delete`): + сигнал до вызова, предел скорости после; + - `strategy=head` — только разовый проход: шаг S3 → БД — выборка + строки на объект (`get_attachments_for_objects` с одним элементом), + пара «строка — объект» с тем же ключом пропускается; шаг БД → S3 — + HEAD на строку своей базы (с `deep` у непомеченной строки старше + grace — сразу GET). Множества `seen` нет. Классификация пары — + общая `_row_with_object`, строки без объекта — `_row_without_object`: + расхождения те же, что у `batch`; + - `deep` — GET и SHA-256 потоком (`open_original`, блоки клиента, + `hashlib`) у строки `ready` без пометки, старше grace, с объектом + того же размера, не моложе grace; класс `checksum_mismatch` — в + `LIMITED_KINDS` и `ACTION_ORDER` (пометка), не в `NEEDS_BUCKET`. + «Оригинал вернулся» и «другой SHA-256» (`NEEDS_READ`) перепроверка и + действие подтверждают заново прочитанным объектом: размер и SHA-256 + строки (`ReconcileFindingDTO.sha256`). Без `deep` вернувшийся объект + тоже читается — пометку снимает только тот же SHA-256; другой — + `lost_known`; + - предел скорости — после каждого вызова S3 (`_pace`): затронуто + (`_touched` — ключи страниц и HEAD/GET/DELETE, разность + `storage.stats()` с начала) больше `R × время с начала прохода` — + `asyncio.sleep` кусками ≤ `RECONCILE_PACE_STEP_SECONDS` (0,2 с) с + проверкой сигнала. Пауза после вызова, а не перед следующим: тогда и + последний вызов прохода не обгоняет предел (design, «Уточнения + apply»). DELETE шага уборки зависшей — тоже: `_pace` после + `remove_stale_pending`; + - ранний отказ: с `apply` в `_recheck_all`, как только подтверждённых + классов `LIMITED_KINDS` больше `max_changes`, остальные кандидаты + этих классов не перепроверяются, а считаются в `unchecked`; `_act` + отказывает тем же условием (`changes` = `max_changes + 1`). Dry-run + перепроверяет всех; + - счёт сеансов — обёртка `db_scope` сервиса (`self.db_scope` считает + и вызывает фабрику), её же получает внутренний + `AttachmentCleanupService`; длительность шагов — `_Pass.phase` (`list`, + `rows`, `stale`, `recheck`, `act`). Плановая сверка — `batch`, без + `deep`, предел из настроек (`src/cleaner/main.py`); - `MessageService.send_message(..., attachment_ids)`: членство → `get_attachments` (все найдены, чат этого сообщения, `ready`; иначе `AttachmentNotFound` до захвата ключа) → хэш → ключ → сообщение → diff --git a/.claude/rules/settings.md b/.claude/rules/settings.md index bbbc3c4b..539e8be9 100644 --- a/.claude/rules/settings.md +++ b/.claude/rules/settings.md @@ -241,6 +241,19 @@ pending_grace_seconds` и его проверка при старте (одна `reconcile_page_size`, `reconcile_max_changes` и `mode`. Стенд отказов и `bench/` — `RECONCILER__INTERVAL_SECONDS: "0"`. +С change `track2-reconcile-cost` (решение 6) ещё `max_objects_per_second` +(float, `ge=0`, 2000; 0 — без предела) — предел скорости прохода: +объектов S3 в секунду в среднем от начала прохода (ключи страниц списка, +HEAD, GET, DELETE). Разовая подмена — `RECONCILER__MAX_OBJECTS_PER_SECOND`, +у разового прохода — `--max-objects-per-second R` (`make reconcile +RATE=R`); плановая сверка берёт значение из настроек. Почему 2000: CPU +шлюза на ключ списка — 0,085–0,11 мс (проба), 2000 ключей в секунду — +~0,2 ядра S3 из 1; проход 100k на лимите стенда — с ~30 до ~65 с, на +рабочем стенде (2–3 тыс. объектов) — ~1,5 с в час; граница нагрузки на +S3 не зависит от CPU уборщика. Проверка выбора — метка профиля сверки +(`bench.md`), итог — `REPORT.md`. «Started cleaner» называет +`reconcile_max_objects_per_second`. + `.env.example` skeleton lab2 предлагает «логические» имена: `APP_HOST`, `APP_PORT`, `APP_ENV`, `SESSION_TTL_SECONDS`, `DATABASE_URL_FILE`, `SESSION_STORE`, `CACHE_URL_FILE`; шапка шаблона просит сопоставить их diff --git a/.claude/rules/student-tests.md b/.claude/rules/student-tests.md index 04d1c857..171ffae9 100644 --- a/.claude/rules/student-tests.md +++ b/.claude/rules/student-tests.md @@ -289,6 +289,37 @@ paths: первом раунде (загрузки 4, 8, 3: 503 `unavailable`, в журнале API — `put_object` `ReadTimeoutError` за 1 мс); после правки — 1 passed, ~16 с (`evidence/tests/failure-checks.md`); +- с change `track2-reconcile-cost` (design, решение 14) — стоимость + сверки, тоже проверки отказов, в конце `test_failures.py`: + - hook: `reconcile dry-run|apply [<предел>] [--strategy batch|head] + [--deep] [--max-objects-per-second R]` — каждый аргумент по списку + (`reconcile_options`: стратегия из двух, R — неотрицательное число, + повтор флага — отказ), иначе код 2 hook; команде передаются как есть. + `run_reconcile(stand, mode, limit, options=…)` в тестах; + - тесты: `test_reconcile_head_strategy_same_findings` (расхождения как в + `…_finds_and_fixes`, уборщик стоит; dry-run `batch` и `head` — свои + классы и ключи, весь отчёт, `found`, `listed_objects`, `checked_rows` и + коды равны, у `head` больше HEAD и сеансов; затем apply — стенд без + внесённого), `test_reconcile_deep_checksum` (A в сообщении + перезаписано другими байтами того же размера, `age-row`, G + 1: + поверхностная A не называет, `--deep` — `checksum_mismatch`, + `read_bytes`, код 3, ничего не изменилось, SHA-256 обоих тел в журнале + нет; `--deep --apply` — пометка, 404 / 200), + `test_reconcile_restore_needs_same_bytes` (помечено → другие байты + того же размера, G + 1: apply пометку не снимает, 404 → те же байты, + G + 1: снята, 200 с тем же SHA-256), `test_reconcile_rate_limit` + (восемь загрузок и одна потеря, уборщик стоит; dry-run с пределом 0 и + с R = max(5, ⌈объектов / 4⌉): `duration_ms ≥ 1000 × storage_objects / + R × 0,95`, без предела короче, находки и коды равны), + `test_reconcile_limit_stops_rechecks` (6 потерь, apply с пределом 2: + код 3, `changes` = 3, `unchecked` ≥ 3, ни одной пометки; dry-run + называет все шесть, `unchecked` 0; apply 100 — помечены). Байты + «того же размера» — `same_size_bytes(data, seed=…)` от зерна теста; + - красный прогон на `7f4e626` (тесты и hook из рабочего дерева): упали + все пять — новые аргументы — ошибка argparse (код 2; у `head` пустой + отчёт, у предела скорости нет итога), у глубокой нет поля `deep`, + пометку снимал другой объект того же размера, `changes` 7 вместо 3 + (`evidence/tests/failure-checks.md`); - исключения сверки: «Принявшая реплика остановлена» — `driver.py attachment-failover` → `evidence/attachments/failover.md`; «Байты не в БД и не на диске API» — `driver.py attachment-storage` → @@ -379,7 +410,9 @@ paths: С change `track2-reconciler` — без плановой сверки (`RECONCILER__INTERVAL_SECONDS: "0"`, строка `start cleaner` называет и её интервал), а `<проект>-cleaner-scheduled` hook `run-cleaner` - убирается вместе с API. Прогон — ~10 мин (с change + убирается вместе с API. Прогон — ~13 мин (с change + `track2-reconcile-cost` — 54 проверки, pytest ~760 с: пять тестов + стоимости сверки ~3,5 мин, из них ожидание grace — 4 × 21 с; с change `fix-upload-put-flake` — 49 проверок, pytest ~550–570 с: тест простоя S3 ~17 с, остальное — разброс хоста; до него 48 проверок, pytest ~535 с; до правок по verify `track2-reconciler` — 45 и ~460 с; diff --git a/.claude/skills/run-mtusi-messenger/SKILL.md b/.claude/skills/run-mtusi-messenger/SKILL.md index 1add7524..a94e0903 100644 --- a/.claude/skills/run-mtusi-messenger/SKILL.md +++ b/.claude/skills/run-mtusi-messenger/SKILL.md @@ -126,7 +126,7 @@ python3 $D stop | `upload-consistency` | только стенд с LB: спеки `attachments` «Порядок записи» и `storage-consistency` (design change `upload-consistency`, решение 11). Синтетические Алиса, Боб и чат; готовое вложение R. Шаги: (1) `docker compose pause s3` → загрузка через LB — 503 за ~5 с → `unpause` в `finally`; новая строка `pending` по psql (`id`, статус, возраст, ключ); (2) триггер «фиксация `ready` падает» (SQLSTATE 08006) на рабочей базе только для уникального `filename` прогона → загрузка 503 → строка `pending`, объекта уже нет (компенсация), триггер снят (`finally`, и остаток прошлого прогона — в начале); (3) метаданные, байты и сообщение со ссылкой на обе строки — 404; (4) после grace прогона 30 с — `docker compose run --rm --no-deps -e CLEANER__PENDING_GRACE_SECONDS=30 cleaner --once`, его JSON-вывод; (5) psql и `weed shell fs.tree` (файлы `original`, а не каталоги) — ни строк, ни объектов обеих загрузок, объектов без строки под префиксом рабочей базы нет; R скачивается с тем же SHA-256. Таблица «проверка → ожидаемо → получено» без токенов и секретов; код 1 при расхождении, без LB — код 2. ~45 с. Вывод — `evidence/attachments/consistency.md` | | `reconcile-cycle` | только стенд с LB: спеки `storage-consistency` (сверка bucket и БД) и `attachments` «Потерянный оригинал» (design change `track2-reconciler`, решение 12). (1) исходный dry-run с grace по умолчанию — расхождений нет, иначе код 2; (2) синтетические Алиса, Боб, чат, вложения A (в сообщении), B, C; (3) объект O без строки и чужой ключ X — `docker exec` реплики (botocore образа её ключами), объект A удалён (`weed shell fs.rm`), строка B удалена и размер C изменён (psql), P — триггер COMMIT на уникальный `filename` (503, строка `pending` и объект); (4) после grace 30 с dry-run: таблица «класс → действие → ключ → `id` → возраст», снимки строк, объектов и пометок до и после совпали; (5) байты A — 500; (6) свежий F, `--apply`: O, B удалены, A, C помечены, P убрана, F не тронут, байты A — 404, метаданные A — 200 и равны ответу загрузки, история отдаёт A; (7) повтор — только чужой X, код 3; оператор удаляет X — код 0; после grace F удалён; (8) A возвращён теми же байтами — «оригинал вернулся», байты 200 с тем же SHA-256, итоговый dry-run — код 0. Таблица «проверка → ожидаемо → получено» без токенов; код 1 при расхождении, без LB — код 2. ~2 мин. Вывод — `evidence/reconcile/cycle.md` | | `reconcile-stress [--seconds S] [--clients N]` | только стенд с LB: «Сверка под нагрузкой». Предусловие — dry-run с grace 20 с без расхождений (иначе код 2); два объекта без строки и два вложения без объекта; N клиентов (4) S секунд (40, больше grace) загружают PNG ~100 KiB из шума и отправляют сообщения, поток сверки — `--apply` с grace 20 с раз в ~3 с, затем ещё один проход. Итог: загрузки по кодам, сообщения, коды проходов, исправления по классам; проверки — внесённые исправлены (объекты удалены, новые пометки — ровно внесённые), каждое 201 скачивается с тем же SHA-256, каждое сообщение отдаёт своё вложение, ни одного прерванного прохода, повтор dry-run — код 0. Проверка корректности, не замер. Вывод — `evidence/reconcile/stress.md` | -| `reconcile-signal` | только не рабочий проект compose (выбор — окружением `COMPOSE_PROJECT_NAME`, `COMPOSE_FILE`, `COMPOSE_ENV_FILES`; `mtusi-lab4` — отказ, код 2): спек `graceful-shutdown`, разовый проход сверки, прерванный сигналом, — код 1 (design change `track2-reconciler`, «Уточнения apply», п. 23). Нужны запущенные `s3` и образ уборщика, LB и реплики не нужны. `docker compose pause s3` → `run -d --no-deps --name <проект>-reconcile-signal cleaner reconcile --apply` → через секунду после «Started cleaner» `docker stop` → код контейнера и журнал → `rm`, `unpause s3` в `finally`. Записи процесса (событие, уровень, операция, `interrupted_by`, `exit_code`) и таблица: код 1, `interrupted_by: stop`, «Stopped cleaner» с `exit_code` 1, записей «Fixed» 0, остановка быстрее 10 с; код 1 при расхождении. ~10 с. Вывод — раздел `evidence/reconcile/service.md` | +| `reconcile-signal` | только не рабочий проект compose (выбор — окружением `COMPOSE_PROJECT_NAME`, `COMPOSE_FILE`, `COMPOSE_ENV_FILES`; `mtusi-lab4` — отказ, код 2): спек `graceful-shutdown`, разовый проход сверки, прерванный сигналом, — код 1 (design change `track2-reconciler`, «Уточнения apply», п. 23). Нужны запущенные `s3` и образ уборщика, LB и реплики не нужны. `docker compose pause s3` → `run -d --no-deps --name <проект>-reconcile-signal cleaner reconcile --apply` → через секунду после «Started cleaner» `docker stop` → код контейнера и журнал → `rm`, `unpause s3` в `finally`. Записи процесса (событие, уровень, операция, `interrupted_by`, `exit_code`) и таблица: код 1, `interrupted_by: stop`, «Stopped cleaner» с `exit_code` 1, записей «Fixed» 0, остановка быстрее 10 с; код 1 при расхождении. ~10 с. `--pace` (design change `track2-reconcile-cost`, решение 14): вместо `pause s3` — 8 объектов пробы под `<база>/attachments/pace-signal-*` мимо API (`docker compose run --rm --no-deps -T --entrypoint python api -`: botocore образа ключами API из окружения контейнера), `cleaner reconcile --max-objects-per-second 1` (dry-run), `docker stop` через 2 с после «Started cleaner» — во время паузы предела скорости; ожидание — код 1, `interrupted_by: stop`, «Stopped cleaner» с `exit_code` 1, остановка ≤ 1 с; объекты пробы удаляются в `finally`. Нужен ещё сервис `api` в конфигурации проекта (реплики не нужны). Вывод — раздел `evidence/reconcile/service.md` | | `s3-idle [--rounds 3] [--downloads 10] [--puts 12] [--size-mib 4] [--pause-ms 0.5]` | только стенд с LB: спеки `object-storage` «Вызов после простоя» и `attachments` «Загрузка после простоя S3» (design change `fix-upload-put-flake`, решение 4). Проба клиента S3 в первой работающей реплике `api`: `docker exec -i <реплика> python -` со скриптом из stdin — код, настройки и ключи образа, ключи в драйвер не попадают; uvloop, если есть. Два варианта по очереди, у каждого свой `ObjectStorage` и пул: `image` (как в образе) и `reference` (прежний `read_timeout` aiohttp = `[s3] timeout_seconds`, подменой `AioConfig` при создании клиента). Раунд: `--downloads` одновременных скачиваний объекта `--size-mib` MiB через `open` / `iter_chunks` с паузой `--pause-ms` после блока 64 KiB, простой `[s3] timeout_seconds + 0,5` с, `--puts` PUT по 128 KiB по одному. Таблица по раундам: `read_timeout` клиента, скачивания с тем же SHA-256, соединения пула со взведённым сроком чтения после скачиваний (`armed`) и с сохранённым исключением после простоя (`broken`) — закрытые поля aiohttp `_conns`, `_read_timeout_handle`, `_exception`, нет их — «n/a», тогда судят только по PUT; PUT прошло и упало, у упавших — цепочка исключений и мс; каждый записанный объект читается обратно (размер и SHA-256). Объекты — под `<база>/.s3-idle-probe//` (сверка этот префикс не читает), удаляются в `finally` отдельным клиентом; затем `weed shell fs.tree` — файлов пробы 0. Код 0 — у `image` ни испорченного соединения, ни упавшего PUT, ни расхождения байтов, все раунды пройдены и файлов не осталось; 1 — иначе (эталон может падать: так видно механизм); 2 — нет реплики или консольный процесс драйвера. Пул API не трогает (отдельный процесс), но на время команды берёт ~100 MiB и CPU реплики — без нагрузки на стенд. ~40 с при 3 раундах и `timeout_seconds` 5. Вывод — `evidence/s3/idle-connection.md` | | `lb-upload-timeouts [--config F] [--image ТЕГ]` | без стенда (рабочий стенд и проекты compose не трогает): спек `load-balancing` «Загрузки через балансировщик» и «Ошибки балансировщика в формате контракта» (design change `upload-memory`, решение 7). `haproxy -c` конфигурации F (по умолчанию `infra/haproxy/haproxy.cfg`) в закреплённом образе LB из `docker-compose.yml`, затем временная сеть `mtusi-lbto-<метка>`: заглушка реплики на образе API (по умолчанию `mtusi-messenger:lab4`, asyncio stdlib) под сетевым именем `api` и HAProxy с F и `API_PORT=8080` на свободном `127.0.0.1`; ожидание `UP` заглушки по `/health/ready` через LB. Пять случаев параллельно, у каждого своё соединение и свой `case` в строке запроса: заглушка молчит 12 с до чтения тела загрузки 10 MiB и после него — 201 от заглушки; 12 с на `GET /api/v1/users/me` — 504 LB через ~10 с; 32 с на пути загрузки — 504 LB через ~30 с; клиент отправил половину тела и молчит — 400 LB через ~30 с (`timeout client`). Ошибки LB — `application/json`, ровно `{"error": {"code", "message", "request_id"}}`, `code` по статусу, `request_id` = `X-Request-Id`. Таблица «случай → ожидаемо → получено → время», код 1 при расхождении. Сеть и контейнеры (метка `mtusi.lb-upload-timeouts`) удаляются при любом исходе, в том числе по Ctrl+C, SIGTERM, SIGHUP. ~35 с. На `haproxy.cfg` до change (`git archive f894040 infra/haproxy/haproxy.cfg \| tar -x -C <каталог>`, `--config <каталог>/infra/haproxy/haproxy.cfg`) — код 1: 502 и 504 через 10 с на пути загрузки, 400 в HTML. Вывод — `evidence/uploads/lb-timeouts.md` | | `stop-at-start [--image ТЕГ] [--delays 0.2,0.3,0.4,1.5,5] [--server-start 3]` | спек `graceful-shutdown` «Остановка во время старта»: контейнеры образа (по умолчанию `mtusi-messenger:lab4`) с лимитами реплики (1 CPU / 512 МиБ без swap), без сети и `config.toml`; `docker stop --timeout 10` через паузу после `docker run` и сразу по строке «Started server process». По потоку `docker events` и журналу: «сигнал через», время `docker stop`, «выход после сигнала», код выхода, этап (`import` / `server-start` / `running`), кто остановил (`early` / `uvicorn`). Код 0 — каждая попытка с кодом 0 и `docker stop` ≤ 1 с, есть `import`, остановленный ранним обработчиком, и `running`. Проекты compose не трогает, свои контейнеры удаляет по метке `mtusi.stop-at-start`. Вывод — `evidence/failover/stop-at-start.md` | @@ -184,6 +184,7 @@ make reconcile APPLY=1 [MAX_CHANGES=N] # то же с исправлени python3 $D --port 8080 reconcile-cycle # расхождения с обеих сторон: dry-run, --apply, 404/200, повтор = 0, возврат оригинала; ~2 мин python3 $D --port 8080 reconcile-stress # --apply раз в 3 с под загрузками 4 клиентов 40 с: все 201 скачиваются с тем же SHA-256 COMPOSE_PROJECT_NAME=<временный> python3 $D reconcile-signal # pause s3 + docker stop разового --apply: код 1, interrupted_by stop; не на mtusi-lab4 +COMPOSE_PROJECT_NAME=<временный> python3 $D reconcile-signal --pace # docker stop во время паузы предела скорости: код 1, ≤ 1 с python3 $D --port 8080 s3-idle # клиент S3 после скачиваний и простоя: у образа 0 испорченных соединений и упавших PUT, эталон портит; ~40 с python3 $D lb-upload-timeouts # сроки LB пути загрузки на заглушке: 201 после 12 с молчания, 504 через 10/30 с, 400 в формате контракта; ~35 с docker compose logs --no-log-prefix cleaner | tail -3 # уборщик: Started cleaner (60/900/100), проходы, отказы diff --git a/.claude/skills/run-mtusi-messenger/driver.py b/.claude/skills/run-mtusi-messenger/driver.py index ba2f902e..7e7ccef2 100644 --- a/.claude/skills/run-mtusi-messenger/driver.py +++ b/.claude/skills/run-mtusi-messenger/driver.py @@ -119,7 +119,12 @@ --apply, через секунду после «Started cleaner» docker stop; interrupted_by stop, «Stopped cleaner» с exit_code 1, остановка быстрее stop_grace_period 10 с; S3 размораживается в finally; - код 1 при расхождении + код 1 при расхождении. --pace (change track2-reconcile-cost): + вместо pause s3 — объекты пробы мимо API (botocore в одноразовом + контейнере api его ключами), reconcile --max-objects-per-second + 1, docker stop через 2 с после «Started cleaner» во время паузы + предела скорости — остановка не дольше секунды; объекты + удаляются в finally s3-idle [--rounds 3] [--downloads 10] [--puts 12] [--size-mib 4] [--pause-ms 0.5] только стенд с LB: спеки object-storage «Вызов после простоя» и attachments «Загрузка после простоя @@ -3644,15 +3649,81 @@ RS_START_TIMEOUT_S = 30 RS_AFTER_START_S = 1.0 # stop_grace_period уборщика в docker-compose.yml: дольше — был бы SIGKILL RS_STOP_LIMIT_S = 10 +# режим --pace (design change track2-reconcile-cost, решение 14): пауза +# предела скорости вместо замороженного S3. Объекты под префиксом вложений +# с ключом, которого API не пишет (чужие для сверки): при пределе 1 объект/с +# проход после страницы списка ждёт столько секунд, сколько ключей +RS_PACE_OBJECTS = 8 +RS_PACE_RATE = "1" +RS_PACE_AFTER_START_S = 2.0 +# остановка во время паузы — не позже секунды после сигнала +RS_PACE_STOP_LIMIT_S = 1.0 +# объекты пробы — botocore в одноразовом контейнере сервиса api его +# ключами из окружения (как put-object hook стенда отказов); в argv и +# вывод ключи не попадают +RS_PACE_OBJECTS_PY = r""" +import os, sys +import botocore.session +from botocore.config import Config + +s3 = botocore.session.get_session().create_client( + "s3", + endpoint_url=f"http://{os.environ['S3__HOST']}:{os.environ['S3__PORT']}", + region_name="us-east-1", + aws_access_key_id=os.environ["S3__ACCESS_KEY_ID"], + aws_secret_access_key=os.environ["S3__SECRET_ACCESS_KEY"], + config=Config(s3={"addressing_style": "path"}), +) +bucket = os.environ["S3__BUCKET"] +prefix = os.environ["DATABASE__NAME"] + "/attachments/pace-signal-" +for i in range(int(sys.argv[2])): + key = f"{prefix}{i}" + if sys.argv[1] == "put": + s3.put_object(Bucket=bucket, Key=key, Body=b"pace", ContentType="image/png") + else: + s3.delete_object(Bucket=bucket, Key=key) +print(f"{sys.argv[1]} {sys.argv[2]} objects") +""" -def cmd_reconcile_signal() -> int: +def rfc3339_ns(text: str) -> int: + """`2026-10-23T01:33:32.338748123Z` (Docker) → наносекунды эпохи; + без `fromisoformat`: Python 3.9 не принимает `Z` и наносекунды.""" + base, _, rest = text.strip().partition(".") + digits = "".join(ch for ch in rest if ch.isdigit()) + moment = datetime.strptime(base.rstrip("Z"), "%Y-%m-%dT%H:%M:%S") + seconds = int(moment.replace(tzinfo=UTC).timestamp()) + return seconds * 10**9 + int((digits + "0" * 9)[:9]) + + +def rs_pace_objects(action: str) -> None: + """`put` или `delete` объектов пробы режима `--pace`.""" + compose( + "run", + "--rm", + "--no-deps", + "-T", + "--entrypoint", + "python", + "api", + "-", + action, + str(RS_PACE_OBJECTS), + stdin=RS_PACE_OBJECTS_PY, + ) + + +def cmd_reconcile_signal(*, pace: bool = False) -> int: """Спек `graceful-shutdown`, разовый проход сверки, прерванный сигналом, — код 1: на стенде проекта compose из окружения (`COMPOSE_PROJECT_NAME` и др., рабочий `mtusi-lab4` — отказ, код 2) `docker compose pause s3`, `run -d --no-deps cleaner reconcile --apply`, через секунду после «Started cleaner» — `docker stop`; S3 размораживается в `finally`. - Таблица и записи процесса без секретов; код 1 при расхождении.""" + `pace` — вместо замороженного S3 пауза предела скорости: объекты пробы, + `reconcile --max-objects-per-second 1` (dry-run), `docker stop` через + 2 с после «Started cleaner», остановка не дольше секунды; объекты + удаляются в `finally`. Таблица и записи процесса без секретов; код 1 + при расхождении.""" try: config = json.loads(compose("config", "--format", "json")) except (RuntimeError, ValueError) as e: @@ -3661,8 +3732,8 @@ def cmd_reconcile_signal() -> int: project = str(config.get("name", "")) if project == RS_WORKING_PROJECT: print( - "reconcile-signal pauses S3: run it on a temporary stand " - f"(COMPOSE_PROJECT_NAME), not {RS_WORKING_PROJECT}", + "reconcile-signal pauses S3 or adds probe objects: run it on a " + f"temporary stand (COMPOSE_PROJECT_NAME), not {RS_WORKING_PROJECT}", ) return 2 services = config.get("services", {}) @@ -3676,21 +3747,23 @@ def cmd_reconcile_signal() -> int: subprocess.run(["docker", "rm", "-f", name], capture_output=True) started = False took = -1.0 + after_signal = -1.0 exit_code = "" logs = "" - compose("pause", "s3") - print(f"{project}: s3 paused") + if pace: + rs_pace_objects("put") + print(f"{project}: {RS_PACE_OBJECTS} probe objects put") + args = ["reconcile", "--max-objects-per-second", RS_PACE_RATE] + after_start, limit = RS_PACE_AFTER_START_S, RS_PACE_STOP_LIMIT_S + waiting = "the rate limit pause" + else: + compose("pause", "s3") + print(f"{project}: s3 paused") + args = ["reconcile", "--apply"] + after_start, limit = RS_AFTER_START_S, float(RS_STOP_LIMIT_S) + waiting = "paused S3" try: - compose( - "run", - "-d", - "--no-deps", - "--name", - name, - "cleaner", - "reconcile", - "--apply", - ) + compose("run", "-d", "--no-deps", "--name", name, "cleaner", *args) deadline = time.monotonic() + RS_START_TIMEOUT_S while time.monotonic() < deadline: logs = docker_logs(name) @@ -3699,28 +3772,68 @@ def cmd_reconcile_signal() -> int: break time.sleep(0.2) if started: - time.sleep(RS_AFTER_START_S) - print("docker stop while reconcile waits for paused S3") + time.sleep(after_start) + print(f"docker stop while reconcile waits for {waiting}") + # момент сигнала — событие kill Docker (часы ВМ, как FinishedAt): + # время docker stop включает ещё разбор контейнера демоном + events = subprocess.Popen( + [ + "docker", + "events", + "--filter", + f"container={name}", + "--filter", + "event=kill", + "--format", + "{{.TimeNano}}", + ], + stdout=subprocess.PIPE, + stderr=subprocess.DEVNULL, + text=True, + ) + time.sleep(0.3) began = time.monotonic() subprocess.run(["docker", "stop", name], capture_output=True) took = time.monotonic() - began - exit_code = subprocess.run( - ["docker", "inspect", "-f", "{{.State.ExitCode}}", name], - capture_output=True, - text=True, - check=False, - ).stdout.strip() + time.sleep(0.3) + events.terminate() + kill_lines = (events.communicate()[0] or "").split() + exit_code, finished_at = ( + subprocess.run( + [ + "docker", + "inspect", + "-f", + "{{.State.ExitCode}}|{{.State.FinishedAt}}", + name, + ], + capture_output=True, + text=True, + check=False, + ).stdout.strip() + + "|" + ).split("|")[:2] + if kill_lines and finished_at: + after_signal = ( + rfc3339_ns(finished_at) - int(kill_lines[0]) + ) / 1e9 logs = docker_logs(name) finally: subprocess.run(["docker", "rm", "-f", name], capture_output=True) - compose("unpause", "s3") - print(f"{project}: s3 unpaused") + if pace: + rs_pace_objects("delete") + print(f"{project}: probe objects deleted") + else: + compose("unpause", "s3") + print(f"{project}: s3 unpaused") records = [] for line in logs.splitlines(): if line.startswith("{"): with contextlib.suppress(json.JSONDecodeError): records.append(json.loads(line)) shown = ("event", "level", "mode", "operation", "error_type") + shown += ("reconcile_max_objects_per_second", "listed_objects") + shown += ("storage_objects", "max_objects_per_second") shown += ("duration_ms", "interrupted_by", "exit_code", "timestamp") print("== records of the one-off reconcile") for record in records: @@ -3734,7 +3847,11 @@ def cmd_reconcile_signal() -> int: stopped = [ item for item in records if item.get("event") == "Stopped cleaner" ] - print(f"docker stop took {took:.1f} s, exit code {exit_code or '-'}") + print( + f"docker stop took {took:.1f} s, container exited " + f"{after_signal:.2f} s after the kill event, exit code " + f"{exit_code or '-'}", + ) rows = [ ("Started cleaner (mode reconcile)", "yes", yes(started)), ("exit code", "1", exit_code), @@ -3754,14 +3871,39 @@ def cmd_reconcile_signal() -> int: str(len(rc_events(records, RC_FIXED))), ), ( - f"docker stop faster than {RS_STOP_LIMIT_S} s", + f"exited within {limit:g} s after the signal" + if pace + else f"docker stop faster than {limit:g} s", "yes", - yes(0 <= took < RS_STOP_LIMIT_S), + yes(0 <= after_signal <= limit if pace else 0 <= took < limit), ), ] + if pace: + rate = next( + ( + item.get("reconcile_max_objects_per_second") + for item in records + if item.get("event") == "Started cleaner" + ), + None, + ) + rows.insert( + 1, + ( + "Started cleaner reconcile_max_objects_per_second", + RS_PACE_RATE, + "-" if rate is None else f"{float(rate):g}", + ), + ) return report_reconcile( rows, - passed="one-off reconcile stopped by SIGTERM: exit 1, nothing changed", + passed=( + "one-off reconcile stopped by SIGTERM during the rate limit " + "pause: exit 1 within a second" + if pace + else "one-off reconcile stopped by SIGTERM: exit 1, nothing " + "changed" + ), ) @@ -4999,7 +5141,8 @@ def main() -> int: stress = sub.add_parser("reconcile-stress") stress.add_argument("--seconds", type=float, default=40) stress.add_argument("--clients", type=int, default=4) - sub.add_parser("reconcile-signal") + signal_cmd = sub.add_parser("reconcile-signal") + signal_cmd.add_argument("--pace", action="store_true") idle_s3 = sub.add_parser("s3-idle") idle_s3.add_argument("--rounds", type=int, default=3) idle_s3.add_argument("--downloads", type=int, default=10) @@ -5113,7 +5256,7 @@ def main() -> int: clients=args.clients, ) if args.cmd == "reconcile-signal": - return cmd_reconcile_signal() + return cmd_reconcile_signal(pace=args.pace) if args.cmd == "s3-idle": return cmd_s3_idle( port, diff --git a/.gitignore b/.gitignore index 9d63dad4..ed0b25b1 100644 --- a/.gitignore +++ b/.gitignore @@ -38,6 +38,8 @@ evidence/failover/quick-*/ evidence/rollout/quick-*/ # make bench_uploads_quick: то же для профиля загрузок evidence/uploads/quick-*/ +# make bench_reconcile_quick: то же для профиля сверки +evidence/reconcile/quick-reconcile-*/ # сравнения пробных меток evidence/compare/*quick-* # make bench_plots на пробных метках diff --git a/AGENTS.md b/AGENTS.md index f4e8220a..594b7a56 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -41,7 +41,14 @@ LB пути загрузки 30 с, дренаж замены 90 с, профи S3 нет срока чтения aiohttp (он переживал ответ и портил соединение в пуле), срок — только `asyncio.timeout` вызова и блока; четвёртый API стенда отказов со сроком S3 1 с (`test_upload_after_idle_s3`), проба -`driver.py s3-idle`. План работ, решения и +`driver.py s3-idle`. Стоимость сверки (трек 2) — change +`track2-reconcile-cost` (активный, +`openspec/changes/track2-reconcile-cost/`): стратегия «HEAD на строку» и +глубокая сверка (класс «другой SHA-256», пометку снимает только тот же +SHA-256) в разовом проходе, предел скорости `[reconciler] +max_objects_per_second` (2000 объектов S3/с), отказ по пределу без +лишних перепроверок, стоимость прохода в его итоге, профиль `reconcile` +стенда `bench/`. План работ, решения и трек «5» — `PLAN.md`. Из лабы 2: PostgreSQL как источник истины, вход по Basic → Bearer-сессия, Valkey — кэш карточек чатов. Из лабы 3: HAProxy перед ≥2 репликами API @@ -55,7 +62,8 @@ S3 нет срока чтения aiohttp (он переживал ответ и `profile-resources`). Changes лаб 2 и 3 и `s3-storage`, `attachments`, `upload-consistency`, `upload-memory`, `track2-reconciler`, `fix-upload-put-flake` лабы 4 — в -`openspec/changes/archive/`, активных нет, спеки синхронизированы +`openspec/changes/archive/`, активный — `track2-reconcile-cost` (его +дельты уже синхронизированы в основные спеки), спеки синхронизированы (новые capability: с `s3-storage` — `object-storage`, с `attachments` — `attachments`, с `upload-consistency` — `storage-consistency`); в `KNOWN_ISSUES.md` три открытые записи (bootstrap после удаления @@ -180,7 +188,16 @@ structlog (JSON в stdout), redis-py (клиент Valkey), aiobotocore 201 (вопрос преподавателю, `PLAN.md`). Уборщику разрешён список только с префиксом `<база>/attachments/` (`S3_CLEANER_LIST_PREFIX` у bootstrap). На время восстановления базы уборщик останавливают - (`docker.md`). + (`docker.md`). С change `track2-reconcile-cost`: проход затрагивает в + среднем не больше `[reconciler] max_objects_per_second` (2000; 0 — без + предела) объектов S3 в секунду, паузу прерывает сигнал; разовый проход + — ещё `--strategy head` (выборка строки на объект, HEAD на строку, без + множества ключей) и `--deep` (GET и SHA-256: «другой SHA-256» помечается + потерянным), плановая — всегда `batch`, поверхностная; «оригинал + вернулся» — только тот же SHA-256; с `--apply`, как только + подтверждённых изменений больше предела, остальные кандидаты не + перепроверяются (`unchecked`); итог называет стоимость — объекты и + запросы S3, байты, сеансы, длительность шагов (`service-layer.md`). - Лаба 4, память загрузок (change `upload-memory`): память загрузок реплики ограничена числом мест, а не числом клиентов. Место берётся после проверок 401/400/404/415/413 и до чтения тела, держится до @@ -374,10 +391,12 @@ structlog (JSON в stdout), redis-py (клиент Valkey), aiobotocore | `driver.py --port upload-consistency` | согласованность БД и S3 на рабочем стенде (~45 с): загрузка при `pause` S3 и со сбоем фиксации `ready` (триггер на `filename` прогона) — 503, строки `pending` не видны, компенсация удалила объект; `cleaner --once` с grace 30 с убирает обе, объектов без строки нет, готовое вложение цело; `evidence/attachments/consistency.md` | | `driver.py lb-upload-timeouts [--config F]` | сроки LB пути загрузки без стенда (~35 с): `haproxy -c`, временная сеть, HAProxy закреплённого образа с F (по умолчанию `infra/haproxy/haproxy.cfg`) и заглушка реплики `api` на образе API; молчание 12 с до и после тела загрузки — 201, 12 с на другом пути — 504 через ~10 с, 32 с на пути загрузки — 504 через ~30 с, клиент молчит посреди тела — 400 в формате контракта; уборка при любом исходе, код 1 при расхождении; `evidence/uploads/lb-timeouts.md` | | `driver.py --port s3-idle [--rounds 3]` | клиент S3 после простоя (~40 с, change `fix-upload-put-flake`): проба в реплике стенда (`docker exec -i … python -`, код и ключи образа), варианты «образ» и «эталон» с прежним `read_timeout` aiohttp; раунд — 10 одновременных медленных скачиваний 4 MiB, простой срока вызова + 0,5 с, 12 PUT; взведённые и испорченные соединения пула, PUT прошло и упало (цепочка ошибки, мс), чтение обратно; объекты под `<база>/.s3-idle-probe/` удаляются в `finally`; код 0 — у образа ни порчи, ни упавших PUT, 1 — иначе, 2 — нет стенда; `evidence/s3/idle-connection.md` | -| `make reconcile [APPLY=1] [MAX_CHANGES=N]` | разовая сверка bucket и БД в контейнере уборщика (`docker compose run --rm --no-deps cleaner reconcile [--apply] [--max-changes N]`): по умолчанию dry-run — записи «Found storage discrepancy» по классам и итог; `APPLY=1` — исправить; 0 — расхождений нет, 3 — остались (чужие объекты, отказ по пределу), 1 — прервана, 2 — конфигурация | +| `make reconcile [APPLY=1] [MAX_CHANGES=N] [STRATEGY=head] [DEEP=1] [RATE=R]` | разовая сверка bucket и БД в контейнере уборщика (`docker compose run --rm --no-deps cleaner reconcile [--apply] [--max-changes N] [--strategy batch\|head] [--deep] [--max-objects-per-second R]`): по умолчанию dry-run — записи «Found storage discrepancy» по классам и итог со стоимостью прохода; `APPLY=1` — исправить; `STRATEGY=head` — HEAD на строку, `DEEP=1` — SHA-256 содержимого, `RATE` — предел скорости (0 — без него); 0 — расхождений нет, 3 — остались (чужие объекты, отказ по пределу), 1 — прервана, 2 — конфигурация | | `driver.py --port reconcile-cycle` | сверка на рабочем стенде (~2 мин): исходный dry-run без расхождений (иначе код 2), расхождения с обеих сторон, dry-run без изменений, 500 → `--apply` → 404 и 200, повтор, удаление чужого объекта, свежий объект после grace, возврат оригинала; `evidence/reconcile/cycle.md` | | `driver.py --port reconcile-stress [--seconds S] [--clients N]` | `--apply` раз в ~3 с под загрузками и отправками N клиентов S секунд (4 × 40 с): внесённое исправлено, каждое 201 скачивается с тем же SHA-256, повтор — 0; `evidence/reconcile/stress.md` | -| `driver.py reconcile-signal` | только не рабочий проект compose (`COMPOSE_PROJECT_NAME` и др., `mtusi-lab4` — код 2): `pause s3`, разовый `reconcile --apply` отдельным контейнером, `docker stop` через секунду после «Started cleaner» — код 1, `interrupted_by: stop`, «Stopped cleaner» с `exit_code` 1, быстрее 10 с; `unpause` в `finally`; `evidence/reconcile/service.md` | +| `driver.py reconcile-signal [--pace]` | только не рабочий проект compose (`COMPOSE_PROJECT_NAME` и др., `mtusi-lab4` — код 2): `pause s3`, разовый `reconcile --apply` отдельным контейнером, `docker stop` через секунду после «Started cleaner» — код 1, `interrupted_by: stop`, «Stopped cleaner» с `exit_code` 1, быстрее 10 с; `unpause` в `finally`. `--pace` (change `track2-reconcile-cost`) — вместо `pause s3` объекты пробы мимо API и `reconcile --max-objects-per-second 1`, `docker stop` через 2 с во время паузы предела скорости — остановка ≤ 1 с; объекты удаляются в `finally`; `evidence/reconcile/service.md` | +| `make bench_reconcile [RECONCILE_LABEL=...]` | трек 2, стоимость сверки (~50 мин, метка `baseline`; change `track2-reconcile-cost`): стенд `mtusi-bench` с LB, двумя репликами, PostgreSQL, Valkey и S3 с лимитами рабочего стенда, порт метрик шлюза S3 на loopback; наполнение мимо API (`\copy` метаданных, PUT объектов загрузчиком `bench/fill_objects.py`), 1 000 × 1 MiB и 10k → 30k → 100k × 4 KiB с 0,25 % расхождений каждого класса; разовые проходы уборщика (0,25 CPU / 256 МБ, управляемый опыт — 1 CPU): `batch`, `head`, глубокая, фоновая нагрузка с пределом скорости и без, отказ по пределу на образе `Profile.reconcile_before` (`7f4e626`) и checkout; 3 повтора, найденное сверяется с моделью (иначе отказ), счёт сверки — с метриками шлюза; `evidence/reconcile/<метка>/` (`passes.csv`, `windows.csv`, `summary.md` с H1–H4 и S4, SVG). Перед запуском — проверка хоста (`bench.md`), рабочий стенд — `make stop` | +| `make bench_reconcile_quick` | то же на 2 000 × 4 KiB, по одному проходу каждого вида, окна 5 с, S4 с 300 кандидатами (~4 мин), метка `quick-reconcile-<время>`, в git не идёт | | `docker compose run --rm --no-deps cleaner --once` | разовый проход уборщика незавершённых загрузок (grace — `[cleaner]` или `-e CLEANER__PENDING_GRACE_SECONDS=…`, не меньше 18 с): 0 — проход дошёл до конца, 1 — прерван отказом, 2 — неверная конфигурация; журнал сервиса — `docker compose logs --no-log-prefix cleaner` | | `make lb_stats` | слоты HAProxy: адрес, состояние проверки (`DRAIN`, `MAINT` при замене), запросы, повторы, перенаправления (CSV статистики изнутри контейнера LB) | | `make rolling_update [COMMIT=...] [MIGRATE=0]` | поочерёдная замена реплик без простоя (`scripts/rolling-update.sh`, `balancer.md`): сборка из рабочего дерева (или файлов `COMMIT` через `git archive`), миграции один раз, затем по одной — новая `healthy` и `UP` в LB, старая `drain` → запросов в полёте 0 → `maint` → stop → rm → слот `ready`. Нужен штатный стенд (`make replicas`) без слотов LB в ручном `drain` / `maint` (иначе код 2 и команда `set server … state ready`); сбой и Ctrl+C — `API_REPLICAS` готовых реплик, повтор доводит; `MIGRATE=0` — откат на прежний образ (после него `docker compose up` без сборки не запускать: `migrate` прежнего образа упадёт на новой ревизии) | @@ -423,8 +442,8 @@ src/ __main__.py # python -m src: early_stop.install() до импорта приложения → main.main() main.py # FastAPI app: lifespan, middlewares, обработчики ошибок, uvicorn.run cleaner/__main__.py # python -m src.cleaner [--once]: early_stop.install("cleaner") до импорта → main(); неверные настройки — запись без значений и код 2 - cleaner/main.py # уборщик незавершённых загрузок: проверка grace > 2 × request_timeout + s3 timeout (иначе код 2), свой engine и клиент S3, цикл с интервалом и плановой сверкой (при старте и раз в [reconciler] interval_seconds), SIGTERM — довести текущий шаг и выйти 0, --once — коды 0/1/2; reconcile [--apply] [--max-changes N] — разовая сверка, коды 0/3/1/2 - config/settings.py # Settings (pydantic-settings), экземпляр settings; [app] instance_id (пусто → hostname) и keep_alive_seconds, [database] pool_size 10 и max_overflow 0 (постоянный пул без переполнения), idle_in_transaction_timeout_ms, [s3] адрес, bucket (валидатор имени), ключи API, регион, сроки, пул и endpoint_url, [idempotency] ttl_seconds, [uploads] max_concurrent 4, max_waiting 16, wait_timeout_seconds 5, body_timeout_seconds 30 (места загрузок процесса API), [cleaner] interval_seconds 60, pending_grace_seconds 900, batch_size 100, [reconciler] interval_seconds 3600, page_size 1000, max_changes 100 + cleaner/main.py # уборщик незавершённых загрузок: проверка grace > 2 × request_timeout + s3 timeout (иначе код 2), свой engine и клиент S3, цикл с интервалом и плановой сверкой (при старте и раз в [reconciler] interval_seconds), SIGTERM — довести текущий шаг и выйти 0, --once — коды 0/1/2; reconcile [--apply] [--max-changes N] [--strategy batch|head] [--deep] [--max-objects-per-second R] — разовая сверка, коды 0/3/1/2; плановая — batch, поверхностная, предел скорости из настроек + config/settings.py # Settings (pydantic-settings), экземпляр settings; [app] instance_id (пусто → hostname) и keep_alive_seconds, [database] pool_size 10 и max_overflow 0 (постоянный пул без переполнения), idle_in_transaction_timeout_ms, [s3] адрес, bucket (валидатор имени), ключи API, регион, сроки, пул и endpoint_url, [idempotency] ttl_seconds, [uploads] max_concurrent 4, max_waiting 16, wait_timeout_seconds 5, body_timeout_seconds 30 (места загрузок процесса API), [cleaner] interval_seconds 60, pending_grace_seconds 900, batch_size 100, [reconciler] interval_seconds 3600, page_size 1000, max_changes 100, max_objects_per_second 2000 (предел скорости сверки; 0 — без него) api/ routers/health.py # /health/live, /health/ready: вне версии, без идентификации routers/v1/.py # ручки под /api/v1, сборка в routers/v1/__init__.py; Idempotency-Key — параметр POST сообщения (message.py); attachment.py — один роутер с двумя префиксами: загрузка (тело через request.stream(), схема — openapi_extra, строгий UTF-8 filename по scope["query_string"]), метаданные, байты StreamingResponse @@ -442,7 +461,7 @@ src/ services/.py # Service: логика, проверки доступа, id и время, логи; чаты и сообщения — с кэшем; отправка — ключ, сообщение и связи с вложениями одной транзакцией services/attachment.py # AttachmentService(db_scope, cache, storage, slots): загрузка (проверки → место загрузки, 429 → тело со счётчиком и сроком в BytesIO, 400 по сроку → структура и SHA-256 в потоке над getvalue() → del → pending → PUT тем же BytesIO → ready; сбой ready до COMMIT или пропавшая строка — удаление объекта и 503; место — до ответа), метаданные, отдача потоком services/attachment_cleanup.py # AttachmentCleanupService(db_scope, storage): проход уборщика — кандидаты keyset, каждая строка в два шага (remove_stale_pending): блокировка и пометка (commit) → блокировка, DELETE объекта и DELETE строки (commit); отказ S3 или БД прерывает проход, SIGTERM — после текущего шага; CleanupPassDTO - services/attachment_reconcile.py # AttachmentReconcileService(db_scope, storage): сверка bucket и БД — S3 → БД (страницы списка, выборка на страницу, множество ключей), БД → S3 (keyset ready; ключ строки вне префикса вложений — чужой объект без HEAD), зависшие, перепроверка в БД и HEAD (bucket — probe), сигнал — перед каждым вызовом хранилища, предел изменений, действия с apply (зависшие шагом уборщика → объекты без строки → пометки → снятия); журнал Found / Fixed / Finished; ReconcilePassDTO + services/attachment_reconcile.py # AttachmentReconcileService(db_scope, storage): сверка bucket и БД — S3 → БД (страницы списка, выборка на страницу, множество ключей), БД → S3 (keyset ready; ключ строки вне префикса вложений — чужой объект без HEAD), зависшие, перепроверка в БД и HEAD (bucket — probe), сигнал — перед каждым вызовом хранилища, предел изменений, действия с apply (зависшие шагом уборщика → объекты без строки → пометки → снятия); журнал Found / Fixed / Finished; ReconcilePassDTO. С change track2-reconcile-cost: strategy head (выборка строки на объект, HEAD на строку, без множества), deep (GET и SHA-256 потоком, checksum_mismatch; «оригинал вернулся» — тот же SHA-256), предел скорости после каждого вызова S3 (_pace, куски 0,2 с с сигналом), ранний отказ по пределу (unchecked), счёт сеансов обёрткой db_scope, стоимость в итоге (storage_objects, s3_requests, read_bytes, db_sessions, phase_ms) exceptions/.py # доменные исключения, реэкспорт в __init__.py; storage.py — ObjectStorageUnavailable (503) и StoredObjectMissing; attachment.py — 404, 413, 415, 400 обрыва и срока тела (UploadTimedOut), 429 занятых мест (UploadsBusy), 500 пропавшего объекта infra/ early_stop.py # ранний обработчик SIGTERM/SIGINT (только stdlib): до старта сервера — запись «Stopped <процесс> before startup» (API, cleaner) и выход 0; disarm() — первая строка lifespan; write_record — запись мимо structlog @@ -456,7 +475,7 @@ src/ db/models/ # модели SQLAlchemy (Base с created_at и to_dict); idempotency.py — ключи, FK на сообщение отложен до commit; attachment.py — Attachment (частичный индекс pending по (created_at, id), lost_at — пометка потерянного оригинала) и MessageAttachment (порядок position, FK без каскада) cache/client.py # create_cache (redis-py: повтор только на обрыв, блокирующий пул), Cache: срок на команду, отказ — промах и пропуск cache/instance.py # глобал cache процесса API - s3/client.py # create_object_storage (aiobotocore: path-адресация, без повторов, пул), ObjectStorage: put (поток read/seek/tell и size) / head / open (чтение блоками) / delete / list_page (ListObjectsV2 по префиксу, нет bucket — ошибка), срок на вызов и блок — единственный срок клиента (read_timeout aiohttp выключен: переживал ответ и портил соединение в пуле, change fix-upload-put-flake), ошибки → ObjectStorageUnavailable / StoredObjectMissing; StoredObjectInfo (с last_modified), StoredObject, StoredObjectPage + s3/client.py # create_object_storage (aiobotocore: path-адресация, без повторов, пул), ObjectStorage: put (поток read/seek/tell и size) / head / open (чтение блоками) / delete / list_page (ListObjectsV2 по префиксу, нет bucket — ошибка), срок на вызов и блок — единственный срок клиента (read_timeout aiohttp выключен: переживал ответ и портил соединение в пуле, change fix-upload-put-flake), ошибки → ObjectStorageUnavailable / StoredObjectMissing; StoredObjectInfo (с last_modified, у open — тоже), StoredObject, StoredObjectPage; счётчики попыток по операциям, ключей списка и прочитанных байт — stats() → StorageStats (change track2-reconcile-cost) s3/instance.py # глобал object_storage процесса API, namespace — имя базы; start() и aclose() в lifespan schemas/ dataclasses/.py # DTO между repo → service → api @@ -480,20 +499,22 @@ student-tests/ # black-box тесты по HTTP (уровень 4) test_failures.py # проверки отказов (маркер fault): только make failure_checks run_isolated.py # make test_isolated: образ на временной базе test_, уборка базы и префикса test_/ в S3 (weed shell fs.rm, затем проверка fs.ls: код 0 weed shell успеха не значит; префикс только из проверенного имени) (stdlib) run_failures.py # make failure_checks: стенд <рабочий>-failures (Postgres, Valkey, S3 + bootstrap, уборщик с grace 20 с и интервалом 1 с без плановой сверки → FAULT_CLEANER_*, FAULT_RECONCILER_INTERVAL_S; уборщик с плановой сверкой <проект>-cleaner-scheduled убирается вместе с API), четыре API (обычный, «тесный», «узкий по загрузкам» с UPLOADS_ENV → FAULT_UPLOADS_BASE_URL / FAULT_UPLOADS_ENV, «с коротким сроком S3» с S3_ENV → FAULT_S3_BASE_URL / FAULT_S3_ENV), pytest -m fault, журнал PostgreSQL стенда (сводка, признаки аварии — ненулевой код), журналы API и уборщика при падении, уборка (stdlib) - fault_hook.py # hook стенда отказов: stop/start/pause/unpause postgres|valkey|s3, кэш, триггеры сбоя участников, сообщений и вложений (fail-attachments insert|ready|stall|commit|outlive|undeletable: сбой вставки, перевода в ready до и на COMMIT, задержка, строка «старше grace» с ожиданием уборщика, неудаляемая строка), заполнение слотов max_connections, счётчик сессий PostgreSQL db-sessions, attachment-ids, last-pending, object-ids (файлы original по fs.tree), kill-api / start-api; расхождения и сверка (change track2-reconciler): put-object (тело — stdin, botocore в контейнере API его ключами) / delete-object (weed fs.rm) только под <база>/attachments/, delete-row, set-size, age-row, set-key (object_key строки под <база>/), lost-ids, fail-attachments mark, reconcile dry-run|apply [предел] (записи и exit_code=), stop|start cleaner, run-cleaner <с> (stdlib) + fault_hook.py # hook стенда отказов: stop/start/pause/unpause postgres|valkey|s3, кэш, триггеры сбоя участников, сообщений и вложений (fail-attachments insert|ready|stall|commit|outlive|undeletable: сбой вставки, перевода в ready до и на COMMIT, задержка, строка «старше grace» с ожиданием уборщика, неудаляемая строка), заполнение слотов max_connections, счётчик сессий PostgreSQL db-sessions, attachment-ids, last-pending, object-ids (файлы original по fs.tree), kill-api / start-api; расхождения и сверка (change track2-reconciler): put-object (тело — stdin, botocore в контейнере API его ключами) / delete-object (weed fs.rm) только под <база>/attachments/, delete-row, set-size, age-row, set-key (object_key строки под <база>/), lost-ids, fail-attachments mark, reconcile dry-run|apply [предел] [--strategy batch|head] [--deep] [--max-objects-per-second R] (аргументы по списку, записи и exit_code=), stop|start cleaner, run-cleaner <с> (stdlib) failures.compose.yml # override стенда отказов: без публикации портов (Postgres, Valkey, S3, LB), уборщик с CLEANER__* 20 / 1, RECONCILER__INTERVAL_SECONDS 0 и restart "no", stop_grace_period 2 с у S3, healthcheck PostgreSQL — на служебную базу postgres (не добавляет сессий в базу приложения), init: true у PostgreSQL (сирот psql из fill-connections подбирает init, а не postmaster) bench/ # нагрузочный стенд на HAProxy + N реплик API + Postgres + Valkey: make bench / bench_quick / bench_restore / bench_failover / bench_rollout / bench_scaling / bench_uploads (с S3) - run.py # оркестратор: стенд compose, реплики и готовность по LB, фоновые чаты и расписание наполнения, матрица, обслуживание БД, планы и варианты, пробы записи, backup и восстановление во второе хранилище со сверкой, фазы профиля failover (события цели — поток docker events по контейнеру, а не буфер демона), профиль rollout (образ прежнего commit через git archive, scripts/rolling-update.sh против проекта стенда, поток событий Docker с exec_start), ресурсы профилей failover и rollout (Profile.sample_resources: сэмплер scan, карта контейнеров по меткам compose, окна, бюджет на пике, сторож), серии трека 1 (профили scaling_*, ячейки на свежем стенде, ступени k6 и поиск R*, сэмплер, продолжение RESUME, блокировка bench/.bench.lock), метрики (сумма по репликам), runs.csv / phases.csv / searches.csv / samples.csv / summary.md / meta.json; профиль uploads (S3 и bootstrap на стенде, на прогон — новый volume S3 и реплика с окружением варианта через .work/variant.compose.yml, образ «до» — тег bench-from, сэмплер peak), в паспорте всех профилей stand.api_tcp_rmem и docker.kernel + run.py # оркестратор: стенд compose, реплики и готовность по LB, фоновые чаты и расписание наполнения, матрица, обслуживание БД, планы и варианты, пробы записи, backup и восстановление во второе хранилище со сверкой, фазы профиля failover (события цели — поток docker events по контейнеру, а не буфер демона), профиль rollout (образ прежнего commit через git archive, scripts/rolling-update.sh против проекта стенда, поток событий Docker с exec_start), ресурсы профилей failover и rollout (Profile.sample_resources: сэмплер scan, карта контейнеров по меткам compose, окна, бюджет на пике, сторож), серии трека 1 (профили scaling_*, ячейки на свежем стенде, ступени k6 и поиск R*, сэмплер, продолжение RESUME, блокировка bench/.bench.lock), метрики (сумма по репликам), runs.csv / phases.csv / searches.csv / samples.csv / summary.md / meta.json; профиль uploads (S3 и bootstrap на стенде, на прогон — новый volume S3 и реплика с окружением варианта через .work/variant.compose.yml, образ «до» — тег bench-from, сэмплер peak), в паспорте всех профилей stand.api_tcp_rmem и docker.kernel; профиль reconcile (S3 с портом метрик через .work/s3-metrics.compose.yml, наполнение \copy и загрузчиком, разовые проходы mtusi-bench-reconcile- с лимитом CPU варианта, «до» — .work/cleaner-before.compose.yml, метрики шлюза и pg_stat_database до и после, блок H4 с k6 background.js, отказ по пределу S4) scaling.py # серии трека 1 без docker: лестница и автомат поиска R*, разбор итога k6 и строк сэмплера, агрегаты окна, вердикт SLO и брака генератора, признаки узкого места (THRESHOLDS), предельный CPU на запрос, сводка серии; --selftest plots.py # make bench_plots: SVG на stdlib (R* от числа реплик, p95 от интенсивности, CPU по компонентам) и сводка с точкой насыщения; render_series — графики в каталоге метки 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 + 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, cleaner описан (mtusi-bench-cleaner, без порта), но профили его не запускают; буфер приёма реплики — sysctls основного compose + 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 — одна загрузка); 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: constant-arrival-rate скачиваний, записи и чтения истории, строка bg на запрос, остановка SIGINT); 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) @@ -510,7 +531,8 @@ docker-compose.yml # проект mtusi-lab4: postgres, valkey, s3 (Se config_example.toml, .env.example evidence/attachments/ # change attachments: smoke.md, failover.md (driver.py attachment-failover stop и kill), storage.md (driver.py attachment-storage), slow-transfer.md (10 MiB через LB дольше 6 с); change upload-consistency: consistency.md (driver.py upload-consistency и журналы API и уборщика), cleaner-process.md (старт, отказ конфигурации, остановка, окно 0, рестарт хранилищ, отказ S3 во время прохода) evidence/s3/ # change s3-storage: bootstrap.md (первый запуск, повтор, смена секрета, ошибка шага, до bootstrap), privacy.md (make s3_check, нарушение и исправление, порты, секреты по сервисам), grpc-admin.md (gRPC шлюза без токена), restart.md (restart.sh и SIGKILL S3), client.md (операции, pause/stop, неверный секрет, журнал), memory.md (20 × 10 MiB PUT); change upload-consistency: cleaner-key.md (пользователь уборщика в bootstrap, смена секрета, make s3_check с ключом уборщика, секреты по сервисам); change track2-reconciler: cleaner-list.md (bootstrap с политикой списка по префиксу, неверный префикс, make s3_check со строками списка уборщика, окружение s3-bootstrap) -evidence/reconcile/ # change track2-reconciler: cycle.md (driver.py reconcile-cycle), stress.md (driver.py reconcile-stress), service.md (Started cleaner с параметрами сверки, плановая сверка при старте, docker stop во время сверки при pause s3, код 1 разового прохода по сигналу — driver.py reconcile-signal, отказ старта на RECONCILER__*, коды 3 и 0) +evidence/reconcile/ # change track2-reconciler: cycle.md (driver.py reconcile-cycle), stress.md (driver.py reconcile-stress), service.md (Started cleaner с параметрами сверки, плановая сверка при старте, docker stop во время сверки при pause s3, код 1 разового прохода по сигналу — driver.py reconcile-signal, отказ старта на RECONCILER__*, коды 3 и 0; с change track2-reconcile-cost — остановка во время паузы предела скорости, driver.py reconcile-signal --pace) +evidence/reconcile/<метка>/ # результаты make bench_reconcile (change track2-reconcile-cost): meta.json (раздел reconcile: план, этапы и модели, commit и образы «до», аргументы S3), passes.csv, windows.csv, summary.md (H1–H4 и S4), cost-by-n.svg, requests-by-n.svg, background-p95.svg, raw/ (записи уборщика по проходам, итог k6 блока H4) evidence/storage/ # отказы БД, пул, statement_timeout, рестарт, порты Postgres, свежий clone; connection-cost.md — цена нового соединения и пинга evidence/migrations/ # миграции с нуля и повторно, ошибка миграции; лаба 4: pending-index.md (ревизия 739b8f04d5fb с нуля, повтор, откат, EXPLAIN общего плана кандидатов уборщика на рабочей базе с откатом, rollout_quick), lost-at.md (ревизия 5c3e1f0a9b7d колонки lost_at: с нуля, повтор, откат, --sql с lock_timeout, make rolling_update с ревизией до и после) evidence/auth/ # passwords-and-tokens.md — driver.py auth-storage на стенде текущей лабы: Argon2id в users, SHA-256 токена в sessions, ни токена, ни пароля в pg_dump (исключения сверки покрытия) diff --git a/Makefile b/Makefile index b499dc87..c432a484 100644 --- a/Makefile +++ b/Makefile @@ -210,11 +210,15 @@ s3_check: # разовая сверка bucket и БД в контейнере уборщика (образ собирает # make run_docker): по умолчанию dry-run — отчёт без изменений; APPLY=1 — # исправить, MAX_CHANGES=N — предел изменений прохода вместо [reconciler] -# max_changes. Код 0 — расхождений нет, 3 — остались, 1 — прерван, 2 — -# конфигурация (design change track2-reconciler, решения 1 и 8) +# max_changes; STRATEGY=head — HEAD на строку вместо страниц, DEEP=1 — +# глубокая (SHA-256 содержимого), RATE=R — предел скорости, объектов S3 в +# секунду (0 — без предела) вместо [reconciler] max_objects_per_second. +# Код 0 — расхождений нет, 3 — остались, 1 — прерван, 2 — конфигурация +# (design change track2-reconciler, решения 1 и 8; track2-reconcile-cost, +# решения 4–6) .PHONY: reconcile reconcile: - $(DC) run --rm --no-deps cleaner reconcile$(if $(filter 1,$(APPLY)), --apply)$(if $(MAX_CHANGES), --max-changes $(MAX_CHANGES)) + $(DC) run --rm --no-deps cleaner reconcile$(if $(filter 1,$(APPLY)), --apply)$(if $(MAX_CHANGES), --max-changes $(MAX_CHANGES))$(if $(STRATEGY), --strategy $(STRATEGY))$(if $(filter 1,$(DEEP)), --deep)$(if $(RATE), --max-objects-per-second $(RATE)) # ------------------------- @@ -363,6 +367,27 @@ 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) +RECONCILE_LABEL ?= baseline + +# трек 2 «5» лабы 4: стоимость сверки bucket и БД на стенде mtusi-bench +# (HAProxy, две реплики, PostgreSQL, Valkey и S3 с лимитами рабочего +# стенда, разовые проходы уборщика 0,25 CPU / 256 МБ, в управляемом опыте +# 1 CPU): наполнение мимо API, этапы 1 000 × 1 MiB и 10k → 30k → 100k × +# 4 KiB, стратегии batch и head, глубокая сверка, фоновая нагрузка с +# пределом скорости и без, отказ по пределу на образе до change +# (Profile.reconcile_before) и checkout, 3 повтора; ~50 мин; результат — +# evidence/reconcile/$(RECONCILE_LABEL)/ (design change track2-reconcile-cost) +.PHONY: bench_reconcile +bench_reconcile: + $(KEEP_AWAKE) uv run python bench/run.py --profile reconcile --label $(RECONCILE_LABEL) + +# то же коротко (самопроверка): 2 000 × 4 KiB, по одному проходу каждого +# вида, окна под нагрузкой по 5 с, отказ по пределу с 300 кандидатами, +# ~6 мин; в git не идёт +.PHONY: bench_reconcile_quick +bench_reconcile_quick: + $(KEEP_AWAKE) uv run python bench/run.py --profile reconcile_quick --label quick-reconcile-$(shell date -u +%Y%m%dT%H%M%SZ) + SCALING_LABEL ?= scaling-$(SERIES) # уровень 5, трек 1 «Цена масштабирования»: серия на стенде mtusi-bench — diff --git a/PLAN.md b/PLAN.md index 8296fbe6..29a652d9 100644 --- a/PLAN.md +++ b/PLAN.md @@ -1515,6 +1515,52 @@ compose `rccost`, тот же `docker-compose.yml`, образ рабочего — на `7f4e626`. Остановку во время паузы предела проверяет `driver.py reconcile-signal --pace` → `evidence/reconcile/service.md`. +Решения apply (2026-10-23, `/opsx:apply` без пользователя; подробно — +design, «Уточнения apply», пп. 1–13): + +13. Пауза предела скорости — после каждого вызова S3: иначе последний + вызов прохода предел не ограничивал бы (п. 1). +14. GET отдаёт `last_modified`, находка несёт SHA-256 строки; глубокая и + свежесть, вернувшийся объект с другим SHA-256 — `lost_known` (пп. 2–5). +15. Hook и тесты: позиционный предел и флаги по одному разу; тест предела + скорости — своя потеря и остановленный уборщик (пп. 6–7). +16. Быстрый профиль — два свежих стенда (S4 — свой), k6 блока H4 + останавливается `pkill -INT`, длительности — 0,01 мс (пп. 8–9). +17. Память в H1 и H2 — наклон и рост пика от N, а не прирост прохода: + постоянная часть прохода ~14 МиБ (п. 10). +18. Модель сверяется в каждом проходе (`found`, `listed_objects`, + `checked_rows`), окно шага списка — справочно (пп. 11–12). +19. `reconcile-signal --pace` — объекты пробы, иначе на пустом bucket + паузы нет; остановка — от события `kill` до `FinishedAt` (п. 13). + Проверка на временном проекте `rcpace` (tmpfs, без портов): до правки + п. 14 — 1,16 с (FAIL), после — 0,22 с, код драйвера 0; режим без + `--pace` — PASS (4,6 с при замороженном S3). Проект убран: volumes + 155, сети 17. +20. Уборщик выходит `os._exit` после `main()`: финализация + интерпретатора при 0,25 CPU — 0,8–1,5 с, остановка по сигналу иначе + больше секунды (п. 14). +21. Красный прогон 1.3 (`make failure_checks FAULT_ARGS='-k "head_strategy + or deep_checksum or restore_needs or rate_limit or limit_stops"'`, + код `7f4e626`, тесты из дерева): 5 failed за 117 с — `head` и предел + скорости — argparse (пустой отчёт, нет итога), глубокая — нет поля + `deep`, восстановление — пометку снял другой объект того же размера, + предел — `changes` 7 вместо 3. Затем все 16 тестов сверки на дереве — + 16 passed за 500 с. +22. `make bench_reconcile_quick` на дереве (хост тихий: все контейнеры, + включая рабочий стенд и `domains-*`, остановлены пользователем; дерево + грязное): первый — код 0 за 3 мин 39 с, после правок пп. 16–17 — + код 0 за 3 мин 30 с (быстрее оценки design ~6 мин). 9 проходов, + найденное = внесённому, `count_mismatch` нет, 5xx фона нет, строки k6 + = итерациям; volumes 155, сети 17, тег `bench-from` снят. Во втором у + проходов 1 CPU (0,3 и 1,1 с) CPU уборщика не посчитан — окно короче + отсчёта сэмплера в конце жизни контейнера; исправлено + (`reconcile.window_cpu` — по охватывающим отсчётам). +23. Регресс `bench/`: `make bench_quick` — complete 18/18 за 3 мин 26 с, + `make bench_uploads_quick` — complete 6/6 за 4 мин 9 с (у «без лимита» + при 40 × 10 MiB — OOM, как у метки `baseline`); `--selftest` + `uploads`, `resources`, `scaling`, `failover`, `rollout`, + `reconcile` — код 0. + #### Вопросы Нет. Вопрос 1 раздела `### track2-reconciler` (ответ API на потерянный diff --git a/bench/bench.compose.yml b/bench/bench.compose.yml index c79fdb26..b370231b 100644 --- a/bench/bench.compose.yml +++ b/bench/bench.compose.yml @@ -62,12 +62,13 @@ services: memswap_limit: ${BENCH_S3_MEMORY:?run make bench} # уборщик незавершённых загрузок (design change upload-consistency, - # решение 9) описан, как s3, и тоже не запускается: старт стенда - # перечисляет сервисы, реплики — с --no-deps. Если его всё же запустят — - # образ стенда, без config.toml рабочего стенда, без перезапуска и без - # плановой сверки bucket и БД: профиль сверки (change - # track2-reconcile-cost) задаст её интервал сам (design change - # track2-reconciler, решение 9) + # решение 9) описан, как s3; сервис не запускается: старт стенда + # перечисляет сервисы, реплики — с --no-deps. Профиль сверки (change + # track2-reconcile-cost, решения 1 и 3) запускает его разовыми проходами + # `docker compose run --name mtusi-bench-reconcile- cleaner reconcile`. + # Образ стенда, без config.toml рабочего стенда, без перезапуска и без + # плановой сверки bucket и БД; лимиты BENCH_CLEANER_* без swap — рабочего + # стенда, в управляемом опыте — CPU варианта cleaner: container_name: mtusi-bench-cleaner image: mtusi-messenger:bench @@ -75,6 +76,12 @@ services: volumes: !reset [] environment: RECONCILER__INTERVAL_SECONDS: "0" + deploy: + resources: + limits: + cpus: ${BENCH_CLEANER_CPUS:?run make bench} + memory: ${BENCH_CLEANER_MEMORY:?run make bench} + memswap_limit: ${BENCH_CLEANER_MEMORY:?run make bench} migrate: image: mtusi-messenger:bench diff --git a/bench/fill_objects.py b/bench/fill_objects.py new file mode 100644 index 00000000..716d0134 --- /dev/null +++ b/bench/fill_objects.py @@ -0,0 +1,116 @@ +"""Загрузчик объектов профиля сверки: прямой PUT в S3 стенда мимо API. + +Работает только в контейнере `mtusi-bench-fill` на образе стенда +(`mtusi-messenger:bench`): botocore образа, `src` не импортируется, каталог +`bench/` смонтирован только на чтение, номера, ключи и содержимое объектов +— генератор набора `bench/reconcile.py` (design change +`track2-reconcile-cost`, решение 3). Ключи пользователя API — окружение +контейнера (`S3__ACCESS_KEY_ID`, `S3__SECRET_ACCESS_KEY`: `docker run -e +<имя>` без значения в argv); в вывод они не попадают. + +Объекты — номера диапазона [--start, --end), у которых по модели набора +есть объект; несколько процессов по нескольку потоков, у каждого процесса +свой клиент. Вывод — одна строка `fill: <объектов> objects, +put/s, <с> s`; ошибка любого PUT — код 1. +""" + +import argparse +import os +import sys +import time +from concurrent.futures import ThreadPoolExecutor +from multiprocessing import Pool +from pathlib import Path +from typing import Any + +sys.path.insert(0, str(Path(__file__).resolve().parent)) + +import reconcile # noqa: E402 + +KEY_ENV = ("S3__ACCESS_KEY_ID", "S3__SECRET_ACCESS_KEY") + + +def client(endpoint: str, threads: int) -> Any: + import botocore.session + from botocore.config import Config + + session = botocore.session.get_session() + return session.create_client( + "s3", + endpoint_url=endpoint, + region_name="us-east-1", + aws_access_key_id=os.environ[KEY_ENV[0]], + aws_secret_access_key=os.environ[KEY_ENV[1]], + config=Config( + s3={"addressing_style": "path"}, + retries={"total_max_attempts": 3}, + max_pool_connections=threads, + ), + ) + + +def put_chunk(job: tuple[dict[str, Any], list[int]]) -> int: + """Один процесс: свой клиент, потоки по номерам; число записанных.""" + args, indices = job + s3 = client(args["endpoint"], args["threads"]) + + def put(index: int) -> None: + attachment_id = reconcile.object_id(args["seed"], index) + s3.put_object( + Bucket=args["bucket"], + Key=reconcile.object_key(args["namespace"], attachment_id), + Body=reconcile.content(args["seed"], index, args["size"]), + ContentType=reconcile.CONTENT_TYPE, + ) + + with ThreadPoolExecutor(max_workers=args["threads"]) as pool: + for _ in pool.map(put, indices): + pass + return len(indices) + + +def main(argv: list[str]) -> int: + parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + parser.add_argument("--endpoint", required=True) + parser.add_argument("--bucket", required=True) + parser.add_argument("--namespace", required=True) + parser.add_argument("--seed", type=int, required=True) + parser.add_argument("--start", type=int, required=True) + parser.add_argument("--end", type=int, required=True) + parser.add_argument("--size", type=int, required=True) + parser.add_argument("--force", choices=(reconcile.FORCE_OK,)) + parser.add_argument("--processes", type=int, default=3) + parser.add_argument("--threads", type=int, default=24) + args = parser.parse_args(argv) + if not Path("/.dockerenv").exists(): + print("fill: run only in the bench container", flush=True) + return 2 + if any(not os.environ.get(name) for name in KEY_ENV): + print(f"fill: {' and '.join(KEY_ENV)} are required", flush=True) + return 2 + indices = reconcile.object_indices(args.start, args.end, args.force) + parts = [indices[i :: args.processes] for i in range(args.processes)] + shared = { + key: getattr(args, key) + for key in ("endpoint", "bucket", "namespace", "seed", "size") + } + shared["threads"] = args.threads + started = time.monotonic() + try: + with Pool(args.processes) as pool: + done = sum(pool.map(put_chunk, [(shared, p) for p in parts if p])) + except Exception as exc: + # без текста исключения botocore: в нём может быть адрес и заголовки + print(f"fill: put failed ({type(exc).__name__})", flush=True) + return 1 + seconds = time.monotonic() - started + print( + f"fill: {done} objects, {done / seconds if seconds else 0:.0f} " + f"put/s, {seconds:.1f} s", + flush=True, + ) + return 0 if done == len(indices) else 1 + + +if __name__ == "__main__": + sys.exit(main(sys.argv[1:])) diff --git a/bench/k6/background.js b/bench/k6/background.js new file mode 100644 index 00000000..3ac72c99 --- /dev/null +++ b/bench/k6/background.js @@ -0,0 +1,125 @@ +// Фоновая нагрузка профиля сверки (design change track2-reconcile-cost, +// решение 10): открытая модель, три сценария constant-arrival-rate через +// LB — скачивания оригиналов вложений набора (`/work/downloads.json` от +// run.py; читатель фикстуры — владелец и участник чата набора), запись +// сообщений в чат записи и чтение его первой страницы истории. Каждый +// запрос — строка «bg,,<отправка мс>,<длительность мс>,<статус>» в +// файл консоли k6; run.py делит их на окна до, во время и после прохода +// сверки и сверяет число строк с итерациями сценариев. Оркестратор +// останавливает прогон сигналом SIGINT, когда блок проходов закончен: +// итог (handleSummary) k6 пишет и тогда. +import exec from "k6/execution"; +import http from "k6/http"; +import { SharedArray } from "k6/data"; + +import { + API, + PAGE_LIMIT, + SUMMARY_THRESHOLDS, + SUMMARY_TREND_STATS, + WORK_DIR, + authHeaders, + messageHeaders, + summaryFiles, + syntheticText, +} from "./lib.js"; + +const fixture = JSON.parse(open(`${WORK_DIR}/fixture.json`)); +const ids = new SharedArray( + "downloads", + () => JSON.parse(open(`${WORK_DIR}/downloads.json`)), +); +const DURATION = __ENV.DURATION || "1h"; +const PRE_VUS = Number(__ENV.PRE_VUS || 100); +const MAX_VUS = Number(__ENV.MAX_VUS || 600); +const TIMEOUT = __ENV.TIMEOUT || "15s"; +const READER = authHeaders(fixture.tokens[fixture.readerId]); +const WRITE_URL = `${API}/chats/${fixture.writeChatId}/messages`; + +function scenario(fn, rate) { + return { + executor: "constant-arrival-rate", + exec: fn, + rate, + timeUnit: "1s", + duration: DURATION, + preAllocatedVUs: PRE_VUS, + maxVUs: MAX_VUS, + gracefulStop: "5s", + }; +} + +export const options = { + scenarios: { + download: scenario("download", Number(__ENV.DOWNLOAD_RATE)), + write: scenario("write", Number(__ENV.WRITE_RATE)), + read: scenario("read", Number(__ENV.READ_RATE)), + }, + summaryTrendStats: SUMMARY_TREND_STATS, + // пороги всегда выполняются: подметрики итераций по сценариям попадают + // в итог, и run.py сверяет с ними число строк о запросах + thresholds: { + ...SUMMARY_THRESHOLDS, + "iterations{scenario:download}": ["count>=0"], + "iterations{scenario:write}": ["count>=0"], + "iterations{scenario:read}": ["count>=0"], + }, +}; + +// длительность — по монотонным таймингам k6 (как в failover.js), с точностью +// 0,01 мс: p95 чтения истории — единицы миллисекунд, и целые мс огрубляли +// бы отношение r; без ответа (status 0) — разность часов +function report(kind, start, res) { + 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) * 100) / 100, + ); + console.log(`bg,${kind},${start},${duration},${res.status}`); +} + +export function download() { + const n = exec.scenario.iterationInTest; + const id = ids[n % ids.length]; + const start = Date.now(); + const res = http.get(`${API}/attachments/${id}/content`, { + headers: READER, + responseType: "none", + timeout: TIMEOUT, + responseCallback: http.expectedStatuses(200), + }); + report("d", start, res); +} + +export function write() { + const n = exec.scenario.iterationInTest; + const sender = fixture.memberIds[n % fixture.memberIds.length]; + const start = Date.now(); + const res = http.post( + WRITE_URL, + JSON.stringify({ text: syntheticText("bg", n) }), + { + headers: messageHeaders(fixture.tokens[sender]), + responseType: "none", + timeout: TIMEOUT, + responseCallback: http.expectedStatuses(201), + }, + ); + report("w", start, res); +} + +export function read() { + const start = Date.now(); + const res = http.get(`${WRITE_URL}?limit=${PAGE_LIMIT}`, { + headers: READER, + responseType: "none", + timeout: TIMEOUT, + responseCallback: http.expectedStatuses(200), + }); + report("r", start, res); +} + +export function handleSummary(data) { + return summaryFiles(data); +} diff --git a/bench/reconcile.py b/bench/reconcile.py new file mode 100644 index 00000000..691c5278 --- /dev/null +++ b/bench/reconcile.py @@ -0,0 +1,1908 @@ +"""Профиль сверки: набор, план, разбор и сводка без docker. + +Оркестрирует проходы `run.py` (профили `reconcile`, `reconcile_quick`), +здесь — чистые функции на stdlib: модель набора (id, содержимое и класс +объекта по номеру и зерну), строки CSV метаданных для `\\copy`, план +ячеек кругами, разбор записей уборщика, метрик шлюза S3, строк фоновой +нагрузки k6 и отсчётов сэмплера, окна и отношения p95 гипотезы 4, строки +`passes.csv` и `windows.csv`, вердикты H1–H4 и S4, `summary.md` и графики +SVG. Методика — design change `track2-reconcile-cost`, решения 1–3, 8–13; +правило — `.claude/rules/bench.md`, «Профиль сверки». Проверка — +`uv run python bench/reconcile.py --selftest`. + +Генератор набора импортирует и загрузчик `bench/fill_objects.py` в +контейнере на образе стенда: модуль на верхнем уровне берёт только +stdlib, графики (`plots`) — внутри функций. +""" + +import hashlib +import json +import math +import random +import re +import statistics +import sys +import uuid +from collections.abc import Iterable +from dataclasses import dataclass, field +from datetime import datetime +from typing import Any + +# класс объекта i — по i mod PERIOD: 0 — объект без метаданных, 1 — +# метаданные без объекта, 2 — другой размер, 3 — зависшая загрузка; по +# 0,25 % на класс (решение 2) +PERIOD = 400 +CLASSES = ("orphan_object", "missing_object", "size_mismatch", "stale_pending") +# принудительный класс диапазона (набор S4): все согласованы или все — +# метаданные без объекта +FORCE_OK = "ok" +FORCE_MISSING = "missing_object" +CONTENT_TYPE = "image/png" +KIB = 1024 +MIB = 2**20 +# размер объекта набора отказа по пределу (S4) +S4_OBJECT_BYTES = 4 * KIB +# столбцы `\copy attachments`: created_at и updated_at — одно значение +COPY_COLUMNS = ( + "id", + "chat_id", + "owner_id", + "filename", + "content_type", + "size_bytes", + "sha256", + "object_key", + "status", + "created_at", + "updated_at", +) +# ячейки: стратегия, глубина, CPU уборщика («stand» — лимит рабочего +# стенда, «fast» — управляемый опыт), предел скорости («default» — из +# настроек, иначе число), фоновая нагрузка (решения 1 и 10) +CELLS: dict[str, dict[str, Any]] = { + "batch": {"strategy": "batch", "deep": False, "cpu": "stand", "rate": 0}, + "head": {"strategy": "head", "deep": False, "cpu": "stand", "rate": 0}, + "deep": {"strategy": "batch", "deep": True, "cpu": "stand", "rate": 0}, + "deep-fast": { + "strategy": "batch", + "deep": True, + "cpu": "fast", + "rate": 0, + }, + "stand": { + "strategy": "batch", + "deep": False, + "cpu": "stand", + "rate": "default", + "load": True, + }, + "stand-unlimited": { + "strategy": "batch", + "deep": False, + "cpu": "stand", + "rate": 0, + "load": True, + }, + "fast-unlimited": { + "strategy": "batch", + "deep": False, + "cpu": "fast", + "rate": 0, + "load": True, + }, + "fast-limited": { + "strategy": "batch", + "deep": False, + "cpu": "fast", + "rate": "default", + "load": True, + }, + # отказ по пределу (решение 7): образ до change и checkout, --apply + # --max-changes 100; у checkout — без предела скорости + "before": {"apply": True, "before": True, "cpu": "stand", "rate": None}, + "after": { + "strategy": "batch", + "deep": False, + "apply": True, + "cpu": "stand", + "rate": 0, + }, +} +LOAD_CELLS = ("stand", "stand-unlimited", "fast-unlimited", "fast-limited") +LIMITED_LOAD = ("stand", "stand-unlimited", "fast-limited") +# сценарии фоновой нагрузки: скачивания, запись, чтение истории +SCENARIOS = {"d": "download", "w": "write", "r": "read"} +WINDOWS = ("before", "pass", "after") +# пороги гипотез (решение 12) +H1_SPREAD = 0.20 +H1_BYTES_PER_KEY = 300 +H2_TIME_RATIO = 10 +H2_HEAD_GROWTH_MIB = 5 +H3_DEEP_RATIO = 5 +H3_MS_PER_MIB = 5 +H3_CLEANER_SHARE = 0.9 +H3_S3_CORES = 0.5 +H3_FAST_RATIO = 1.5 +H4_THRESHOLD = 1.5 +S4_AFTER_EXTRA_MS = 1000 +S4_MS_PER_CANDIDATE = 5 +# записи журнала уборщика, которые идут в raw/<проход>-cleaner.json +STARTED = "Started cleaner" +FINISHED = "Finished reconcile pass" +EXCEEDED = "Reconcile changes exceed limit" +FOUND = "Found storage discrepancy" +FIXED = "Fixed storage discrepancy" +# операции S3 в итоге прохода и типы запросов шлюза: HEAD шлюз считает +# типом GET (проба, design, Context) +S3_OPS = ("list", "head", "get", "delete") +GATEWAY_TYPES = ("LIST", "GET", "DELETE") + +PASS_FIELDS = [ + "pass", + "stage", + "cell", + "repeat", + "order", + "strategy", + "deep", + "apply", + "image", + "cleaner_cpus", + "max_objects_per_second", + "load", + "objects", + "object_bytes", + "ready_rows", + "candidates", + *(f"expected_{kind}" for kind in CLASSES), + *(f"found_{kind}" for kind in CLASSES), + "found_checksum_mismatch", + "found_other", + "listed_objects", + "checked_rows", + "exit_code", + "duration_ms", + "phase_list_ms", + "phase_rows_ms", + "phase_stale_ms", + "phase_recheck_ms", + "phase_act_ms", + "us_per_object", + "storage_objects", + *(f"s3_{op}" for op in S3_OPS), + "read_bytes", + "db_sessions", + "unchecked", + "refused", + "limit_changes", + "gw_list", + "gw_get", + "gw_delete", + "gw_other", + "pg_xact", + "pg_tup_returned", + "pg_tup_fetched", + "pg_blks_hit", + "pg_blks_read", + "pg_sessions", + "cpu_cleaner", + "cpu_s3", + "cpu_postgres", + "cpu_api", + "cpu_haproxy", + "mem_start_mib", + "mem_peak_mib", + "mem_growth_bytes_per_object", + "flags", +] +WINDOW_FIELDS = [ + "pass", + "stage", + "cell", + "repeat", + "window", + "scenario", + "start_s", + "end_s", + "responses", + "errors", + "s5xx", + "p50_ms", + "p95_ms", + "p99_ms", +] + + +# ------------------------------------------------------------------ набор + + +def object_class(index: int, force: str | None = None) -> str | None: + """Класс расхождения объекта `index`; `None` — согласован.""" + if force == FORCE_OK: + return None + if force is not None: + return force + slot = index % PERIOD + return CLASSES[slot] if slot < len(CLASSES) else None + + +def object_id(seed: int, index: int) -> str: + """UUID v4 из SHA-256 строки `<зерно>:<номер>` — запись сервера.""" + digest = hashlib.sha256(f"{seed}:{index}".encode()).digest() + return str(uuid.UUID(bytes=digest[:16], version=4)) + + +def content(seed: int, index: int, size: int) -> bytes: + """Повторённый SHA-256 строки `<зерно>:<номер>:c`, обрезанный до + размера.""" + block = hashlib.sha256(f"{seed}:{index}:c".encode()).digest() + return (block * (size // len(block) + 1))[:size] + + +def object_key(namespace: str, attachment_id: str) -> str: + return f"{namespace}/attachments/{attachment_id}/original" + + +def has_object(kind: str | None) -> bool: + return kind != "missing_object" + + +def has_row(kind: str | None) -> bool: + return kind != "orphan_object" + + +def object_indices( + start: int, + end: int, + force: str | None = None, +) -> list[int]: + """Номера объектов диапазона, у которых есть объект в bucket.""" + return [i for i in range(start, end) if has_object(object_class(i, force))] + + +def rows_csv( + *, + seed: int, + start: int, + end: int, + size: int, + namespace: str, + chat_id: str, + owner_id: str, + created_at: str, + force: str | None = None, +) -> str: + """Строки CSV `\\copy attachments (COPY_COLUMNS)` диапазона: + `ready` — у согласованных, метаданных без объекта и другого размера + (`size_bytes` на байт больше), `pending` — у зависшей загрузки; объект + без метаданных строки не имеет. SHA-256 — от того же содержимого.""" + lines = [] + for index in range(start, end): + kind = object_class(index, force) + if not has_row(kind): + continue + attachment_id = object_id(seed, index) + digest = hashlib.sha256(content(seed, index, size)).hexdigest() + size_bytes = size + 1 if kind == "size_mismatch" else size + status = "pending" if kind == "stale_pending" else "ready" + lines.append( + ",".join( + ( + attachment_id, + chat_id, + owner_id, + f"bench-{index}.png", + CONTENT_TYPE, + str(size_bytes), + f"\\x{digest}", + object_key(namespace, attachment_id), + status, + created_at, + created_at, + ), + ), + ) + return "\n".join(lines) + ("\n" if lines else "") + + +def class_count(n: int, slot: int) -> int: + """Сколько номеров `i < n` дают `i mod PERIOD == slot`.""" + return n // PERIOD + (1 if n % PERIOD > slot else 0) + + +@dataclass(frozen=True) +class Model: + """Ожидаемое у набора: объекты в bucket, строки `ready`, расхождения + по классам (внесено).""" + + objects: int + ready_rows: int + pending_rows: int + found: dict[str, int] + + @property + def candidates(self) -> int: + return sum(self.found.values()) + + +def model(n: int, *, clean: int = 0, missing: int = 0) -> Model: + """Набор из `n` объектов с классами по номеру; у набора S4 — `clean` + согласованных и `missing` строк без объектов (тогда `n` не важен).""" + if clean or missing: + return Model( + objects=clean, + ready_rows=clean + missing, + pending_rows=0, + found={"missing_object": missing} if missing else {}, + ) + found = {kind: class_count(n, slot) for slot, kind in enumerate(CLASSES)} + return Model( + objects=n - found["missing_object"], + ready_rows=n - found["orphan_object"] - found["stale_pending"], + pending_rows=found["stale_pending"], + found={kind: count for kind, count in found.items() if count}, + ) + + +def downloads(seed: int, n: int, count: int) -> list[str]: + """`id` согласованных вложений набора для фоновых скачиваний: выборка + от зерна (решение 10).""" + pool = [i for i in range(n) if object_class(i) is None] + rng = random.Random(seed) + chosen = rng.sample(pool, min(count, len(pool))) + return [object_id(seed, i) for i in chosen] + + +# ------------------------------------------------------------------- план + + +def plan_passes( + stages: Iterable[tuple[str, tuple[str, ...]]], + repeats: int, + seed: int, +) -> list[dict[str, Any]]: + """Проходы этапов кругами: в круге r — перестановка ячеек этапа + генератором `Random(seed + номер этапа × 100 + r)`, круг не начинается + с ячейки, которой кончился прежний (как `uploads.plan_runs`).""" + plan: list[dict[str, Any]] = [] + for stage_no, (stage, cells) in enumerate(stages): + previous = None + for round_no in range(1, repeats + 1): + order = list(range(len(cells))) + random.Random(seed + stage_no * 100 + round_no).shuffle(order) + if len(order) > 1 and order[0] == previous: + order[0], order[1] = order[1], order[0] + for index in order: + cell = cells[index] + plan.append( + { + "pass": f"{stage}-{cell}-r{round_no}", + "stage": stage, + "cell": cell, + "repeat": round_no, + "order": len(plan) + 1, + }, + ) + previous = order[-1] + return plan + + +# ----------------------------------------------------------------- разбор + + +def parse_records(text: str) -> list[dict[str, Any]]: + """JSON-записи журнала уборщика; остальное (вывод compose) — мимо.""" + records = [] + for line in text.splitlines(): + line = line.strip() + if not line.startswith("{"): + continue + try: + records.append(json.loads(line)) + except json.JSONDecodeError: + continue + return records + + +def pick(records: list[dict[str, Any]], event: str) -> dict[str, Any] | None: + found = [item for item in records if item.get("event") == event] + return found[-1] if found else None + + +def kept_records(records: list[dict[str, Any]]) -> dict[str, Any]: + """`raw/<проход>-cleaner.json`: записи старта, итога и предела; записи + о расхождениях — только числом (их до тысячи на проход).""" + return { + "started": pick(records, STARTED), + "finished": pick(records, FINISHED), + "exceeded": pick(records, EXCEEDED), + "found_records": sum(1 for r in records if r.get("event") == FOUND), + "fixed_records": sum(1 for r in records if r.get("event") == FIXED), + } + + +def timestamp(value: str) -> float: + """ISO 8601 с `Z` (записи structlog, Docker) → секунды эпохи; дробь + Docker — до наносекунд, Python берёт микросекунды.""" + text = value.strip().replace("Z", "+00:00") + match = re.match(r"(.*\.\d{6})\d*(.*)", text) + if match: + text = match.group(1) + match.group(2) + return datetime.fromisoformat(text).timestamp() + + +def parse_metrics(text: str) -> dict[str, float]: + """`SeaweedFS_s3_request_total` по типам запроса (сумма по прочим + меткам).""" + totals: dict[str, float] = {} + for line in text.splitlines(): + if not line.startswith("SeaweedFS_s3_request_total{"): + continue + kind = re.search(r'type="([^"]+)"', line) + try: + value = float(line.rsplit(" ", 1)[1]) + except (IndexError, ValueError): + continue + name = kind.group(1) if kind else "?" + totals[name] = totals.get(name, 0.0) + value + return totals + + +def metrics_delta( + before: dict[str, float], + after: dict[str, float], +) -> dict[str, int]: + names = set(before) | set(after) + return { + name: round(after.get(name, 0.0) - before.get(name, 0.0)) + for name in sorted(names) + } + + +def gateway_mismatch( + s3_requests: dict[str, int], + gateway: dict[str, int], +) -> bool: + """Счёт сверки и метрики шлюза: LIST = list, GET = head + get, DELETE + = delete; запросов других типов быть не должно (решение 8).""" + expected = { + "LIST": s3_requests.get("list", 0), + "GET": s3_requests.get("head", 0) + s3_requests.get("get", 0), + "DELETE": s3_requests.get("delete", 0), + } + other = sum(v for k, v in gateway.items() if k not in GATEWAY_TYPES) + return other != 0 or any( + gateway.get(name, 0) != value for name, value in expected.items() + ) + + +PG_STAT_SQL = ( + "SELECT xact_commit + xact_rollback, tup_returned, tup_fetched, " + "blks_hit, blks_read, sessions FROM pg_stat_database " + "WHERE datname = current_database();\n" +) +PG_STAT_NAMES = ( + "pg_xact", + "pg_tup_returned", + "pg_tup_fetched", + "pg_blks_hit", + "pg_blks_read", + "pg_sessions", +) + + +def parse_pg_stat(text: str) -> dict[str, int]: + values = [int(v) for v in text.strip().split("|")] + return dict(zip(PG_STAT_NAMES, values, strict=True)) + + +@dataclass(frozen=True) +class Request: + """Запрос фоновой нагрузки: сценарий, отправка (мс часов ВМ), + длительность и статус.""" + + kind: str + start_ms: int + duration_ms: float + status: int + + +def parse_background(text: str) -> list[Request]: + """Строки `bg,,<отправка мс>,<длительность мс>,<статус>`.""" + out = [] + for line in text.splitlines(): + line = line.strip() + if not line.startswith("bg,"): + continue + parts = line.split(",") + if len(parts) != 5 or parts[1] not in SCENARIOS: + continue + try: + out.append( + Request( + kind=parts[1], + start_ms=int(parts[2]), + duration_ms=float(parts[3]), + status=int(parts[4]), + ), + ) + except ValueError: + continue + return out + + +def percentile(values: list[float], q: float) -> float | None: + """Перцентиль ближайшего ранга, как у k6 (p(95)).""" + if not values: + return None + ordered = sorted(values) + rank = max(1, math.ceil(q / 100 * len(ordered))) + return float(ordered[rank - 1]) + + +OK_STATUS = {"d": 200, "w": 201, "r": 200} + + +def window_stats( + requests: list[Request], + kind: str, + start: float, + end: float, +) -> dict[str, Any]: + """Ответы сценария, отправленные в [start, end) (секунды часов ВМ): + число, ошибки, 5xx и перцентили успешных.""" + inside = [ + r + for r in requests + if r.kind == kind and start * 1000 <= r.start_ms < end * 1000 + ] + ok = [r.duration_ms for r in inside if r.status == OK_STATUS[kind]] + return { + "responses": len(inside), + "errors": len(inside) - len(ok), + "s5xx": sum(1 for r in inside if 500 <= r.status < 600), + "p50_ms": percentile(ok, 50), + "p95_ms": percentile(ok, 95), + "p99_ms": percentile(ok, 99), + } + + +def ratio(a: float | None, b: float | None) -> float | None: + if a is None or b is None or b <= 0: + return None + return round(a / b, 3) + + +def windows_of( + requests: list[Request], + bounds: dict[str, tuple[float, float]], +) -> tuple[list[dict[str, Any]], dict[str, dict[str, float | None]]]: + """Строки окон прохода по сценариям и отношения: `r` — p95 окна + прохода к p95 окон до и после вместе (строка `quiet`), `a` — p95 до к + p95 после.""" + rows = [] + ratios: dict[str, dict[str, float | None]] = {} + for kind, scenario in SCENARIOS.items(): + stats = {} + for name in WINDOWS: + w0, w1 = bounds[name] + stats[name] = window_stats(requests, kind, w0, w1) + rows.append( + { + "window": name, + "scenario": scenario, + "start_s": round(w0, 3), + "end_s": round(w1, 3), + **stats[name], + }, + ) + quiet = [ + r + for r in requests + if any( + bounds[name][0] * 1000 <= r.start_ms < bounds[name][1] * 1000 + for name in ("before", "after") + ) + ] + stats["quiet"] = window_stats(quiet, kind, -math.inf, math.inf) + rows.append( + { + "window": "quiet", + "scenario": scenario, + "start_s": round(bounds["before"][0], 3), + "end_s": round(bounds["after"][1], 3), + **stats["quiet"], + }, + ) + if "list" in bounds: + # шаг списка (`phase_ms.list` от начала прохода): справочно, без + # вердикта — в нём у `batch` нагружен S3 (решение 10) + w0, w1 = bounds["list"] + rows.append( + { + "window": "list", + "scenario": scenario, + "start_s": round(w0, 3), + "end_s": round(w1, 3), + **window_stats(requests, kind, w0, w1), + }, + ) + ratios[scenario] = { + "r": ratio(stats["pass"]["p95_ms"], stats["quiet"]["p95_ms"]), + "a": ratio(stats["before"]["p95_ms"], stats["after"]["p95_ms"]), + "s5xx": sum(stats[name]["s5xx"] for name in WINDOWS), + } + return rows, ratios + + +# ------------------------------------------------------------- сэмплер + + +def usage_at(points: list[tuple[int, ...]], t: float) -> float | None: + """`usage_usec` контейнера на момент `t` (секунды): линейно между + соседними отсчётами; вне отсчётов — None.""" + if not points: + return None + ns = t * 1e9 + if ns < points[0][0] or ns > points[-1][0]: + return None + for prev, cur in zip(points, points[1:], strict=False): + if prev[0] <= ns <= cur[0]: + if cur[0] == prev[0]: + return float(cur[1]) + share = (ns - prev[0]) / (cur[0] - prev[0]) + return prev[1] + (cur[1] - prev[1]) * share + return float(points[-1][1]) + + +def window_cpu( + points: list[tuple[int, ...]], + w0: float, + w1: float, +) -> float | None: + """Ядер в среднем за окно [w0, w1]: разность `usage_usec` на концах. + Окно у края отсчётов — по ближайшим отсчётам внутри. Короткий проход + в конце жизни контейнера (последний отсчёт раньше конца окна, внутри + меньше половины окна) — по отсчётам, охватывающим окно: среднее за + чуть большее время, а не пропуск.""" + if w1 <= w0 or len(points) < 2: + return None + first, last = points[0][0] / 1e9, points[-1][0] / 1e9 + a, b = max(w0, first), min(w1, last) + if b - a >= (w1 - w0) / 2: + ua, ub = usage_at(points, a), usage_at(points, b) + if ua is not None and ub is not None: + return round((ub - ua) / 1e6 / (b - a), 4) + before = [p for p in points if p[0] <= w0 * 1e9] + after = [p for p in points if p[0] >= w1 * 1e9] + p0 = before[-1] if before else points[0] + p1 = after[0] if after else points[-1] + if p1[0] <= p0[0]: + return None + return round((p1[1] - p0[1]) * 1e3 / (p1[0] - p0[0]), 4) + + +def memory_start_peak( + points: list[tuple[int, ...]], + w0: float, +) -> tuple[float | None, float | None]: + """Память контейнера (МиБ): последняя выборка не позже начала окна и + наибольшая за жизнь (решение 9).""" + if not points: + return None, None + before = [p for p in points if p[0] <= w0 * 1e9] + start = (before[-1] if before else points[0])[5] / MIB + peak = max(p[5] for p in points) / MIB + return round(start, 1), round(peak, 1) + + +# ---------------------------------------------------------- строка прохода + + +def pass_row( + entry: dict[str, Any], + *, + cell: dict[str, Any], + expected: Model, + object_bytes: int, + kept: dict[str, Any], + exit_code: int, + gateway: dict[str, int] | None, + pg: dict[str, int] | None, + cpu: dict[str, float | None], + memory: tuple[float | None, float | None], + cleaner_cpus: str, + rate: float | None, + image: str, +) -> dict[str, Any]: + """Строка `passes.csv`: модель и найденное, итог прохода, метрики + шлюза и PostgreSQL, CPU и память за окно; пометки — `count_mismatch` + (счёт сверки ≠ метрикам шлюза в ячейке без нагрузки).""" + finished = kept.get("finished") or {} + exceeded = kept.get("exceeded") or {} + found = finished.get("found") or {} + phases = finished.get("phase_ms") or {} + s3 = finished.get("s3_requests") or {} + duration = finished.get("duration_ms") + row: dict[str, Any] = { + **{key: entry[key] for key in ("pass", "stage", "cell", "repeat")}, + "order": entry["order"], + "strategy": finished.get("strategy", cell.get("strategy", "batch")), + "deep": finished.get("deep", cell.get("deep", False)), + "apply": bool(cell.get("apply")), + "image": image, + "cleaner_cpus": cleaner_cpus, + "max_objects_per_second": finished.get( + "max_objects_per_second", + rate, + ), + "load": bool(cell.get("load")), + "objects": expected.objects, + "object_bytes": object_bytes, + "ready_rows": expected.ready_rows, + "candidates": expected.candidates, + "listed_objects": finished.get("listed_objects"), + "checked_rows": finished.get("checked_rows"), + "exit_code": exit_code, + "duration_ms": duration, + "us_per_object": ( + round(duration * 1000 / expected.objects, 2) + if duration is not None and expected.objects + else None + ), + "storage_objects": finished.get("storage_objects"), + "read_bytes": finished.get("read_bytes"), + "db_sessions": finished.get("db_sessions"), + "unchecked": finished.get("unchecked"), + "refused": finished.get("refused"), + "limit_changes": exceeded.get("changes"), + "cpu_cleaner": cpu.get("cleaner"), + "cpu_s3": cpu.get("s3"), + "cpu_postgres": cpu.get("postgres"), + "cpu_api": cpu.get("api"), + "cpu_haproxy": cpu.get("haproxy"), + "mem_start_mib": memory[0], + "mem_peak_mib": memory[1], + } + for kind in CLASSES: + row[f"expected_{kind}"] = expected.found.get(kind, 0) + row[f"found_{kind}"] = found.get(kind, 0) + row["found_checksum_mismatch"] = found.get("checksum_mismatch", 0) + row["found_other"] = sum( + count + for kind, count in found.items() + if kind not in CLASSES and kind != "checksum_mismatch" + ) + for name in ("list", "rows", "stale", "recheck", "act"): + row[f"phase_{name}_ms"] = phases.get(name) + for op in S3_OPS: + row[f"s3_{op}"] = s3.get(op) + if memory[0] is not None and memory[1] is not None and expected.objects: + row["mem_growth_bytes_per_object"] = round( + (memory[1] - memory[0]) * MIB / expected.objects, + 1, + ) + flags = [] + if gateway is not None: + row["gw_list"] = gateway.get("LIST", 0) + row["gw_get"] = gateway.get("GET", 0) + row["gw_delete"] = gateway.get("DELETE", 0) + row["gw_other"] = sum( + v for k, v in gateway.items() if k not in GATEWAY_TYPES + ) + if s3 and not cell.get("load") and gateway_mismatch(s3, gateway): + flags.append("count_mismatch") + if pg is not None: + row.update(pg) + row["flags"] = " ".join(flags) + return row + + +def found_problems( + entry: dict[str, Any], + expected: dict[str, int], + kept: dict[str, Any], +) -> list[str]: + """Найдено не то, что внесено: класс, ячейка и оба числа (спек + `load-benchmark`, «Найдено не то, что внесено»).""" + finished = kept.get("finished") + if finished is None: + return [f"{entry['pass']}: no «{FINISHED}» record"] + found = finished.get("found") or {} + problems = [] + for kind in sorted(set(expected) | set(found)): + if found.get(kind, 0) != expected.get(kind, 0): + problems.append( + f"{entry['pass']}: {kind} found {found.get(kind, 0)}, " + f"injected {expected.get(kind, 0)}", + ) + return problems + + +# ------------------------------------------------------------- агрегаты + + +def num(value: Any) -> float | None: + if value is None or value == "": + return None + try: + return float(value) + except (TypeError, ValueError): + return None + + +def med(values: Iterable[Any]) -> float | None: + present = [v for v in (num(x) for x in values) if v is not None] + return statistics.median(present) if present else None + + +def spread(values: Iterable[Any], digits: int = 1) -> str: + present = [v for v in (num(x) for x in values) if v is not None] + if not present: + return "—" + mid = statistics.median(present) + if len(present) == 1: + return f"{mid:.{digits}f}" + return ( + f"{mid:.{digits}f} ({min(present):.{digits}f}–" + f"{max(present):.{digits}f})" + ) + + +def cell_rows( + passes: list[dict[str, Any]], + stage: str, + cell: str, +) -> list[dict[str, Any]]: + return [ + row + for row in passes + if row.get("stage") == stage and row.get("cell") == cell + ] + + +def cell_median( + passes: list[dict[str, Any]], + stage: str, + cell: str, + column: str, +) -> float | None: + return med(row.get(column) for row in cell_rows(passes, stage, cell)) + + +def load_ratios( + window_rows: list[dict[str, Any]], +) -> dict[str, dict[str, dict[str, float | None]]]: + """Медиана `r` и `a` по повторам: ячейка → сценарий → значение; + `s5xx` — сумма.""" + by_pass: dict[str, dict[str, Any]] = {} + for row in window_rows: + item = by_pass.setdefault( + row["pass"], + {"cell": row["cell"], "stats": {}}, + ) + item["stats"][(row["scenario"], row["window"])] = row + values: dict[str, dict[str, dict[str, list[float]]]] = {} + fives: dict[str, dict[str, int]] = {} + for item in by_pass.values(): + cell = item["cell"] + for scenario in SCENARIOS.values(): + stats = item["stats"] + p = { + name: num(stats.get((scenario, name), {}).get("p95_ms")) + for name in WINDOWS + } + quiet = num(stats.get((scenario, "quiet"), {}).get("p95_ms")) + r = ratio(p["pass"], quiet) + a = ratio(p["before"], p["after"]) + bucket = values.setdefault(cell, {}).setdefault( + scenario, + {"r": [], "a": []}, + ) + if r is not None: + bucket["r"].append(r) + if a is not None: + bucket["a"].append(a) + fives.setdefault(cell, {}).setdefault(scenario, 0) + fives[cell][scenario] += sum( + int(num(stats.get((scenario, name), {}).get("s5xx")) or 0) + for name in WINDOWS + ) + return { + cell: { + scenario: { + "r": med(v["r"]), + "a": med(v["a"]), + "s5xx": fives[cell][scenario], + } + for scenario, v in scenarios.items() + } + for cell, scenarios in values.items() + } + + +# -------------------------------------------------------------- вердикты + + +CONFIRMED = "подтверждена" +REFUTED = "опровергнута" +UNTESTED = "не проверена" +NOISY = "не различимо на этом хосте" + + +@dataclass +class Verdict: + """Строка гипотезы: имя, критерий, измерено, вывод.""" + + name: str + criterion: str + measured: str + verdict: str + details: list[str] = field(default_factory=list) + + +def fmt(value: float | None, digits: int = 2) -> str: + return "—" if value is None else f"{value:.{digits}f}" + + +def stage_n(meta: dict[str, Any], stage: str) -> int | None: + for item in meta.get("reconcile", {}).get("stages", []): + if item["stage"] == stage: + return item["objects_total"] + return None + + +def verdict_h1(meta: dict[str, Any], passes: list[dict[str, Any]]) -> Verdict: + """Линейность `batch`: цена на объект, запросы S3, сеансы, память.""" + stages = [ + s + for s in meta.get("reconcile", {}).get("h1_stages", []) + if cell_rows(passes, s, "batch") + ] + if len(stages) < 2: + return Verdict( + "H1", + "цена на объект `batch` при трёх N в пределах 20 %", + "нет ячеек", + UNTESTED, + ) + costs = { + s: cell_median(passes, s, "batch", "us_per_object") for s in stages + } + present = [v for v in costs.values() if v] + spread_ratio = max(present) / min(present) - 1 if present else None + details = [] + ok_requests = True + for s in stages: + row = cell_rows(passes, s, "batch")[0] + n = int(num(row["objects"]) or 0) + int( + num(row["expected_missing_object"]) or 0, + ) + listed = int(num(row["objects"]) or 0) + want_list = math.ceil(listed / 1000) + 1 + want_head = sum( + int(num(row[f"expected_{k}"]) or 0) + for k in ("orphan_object", "missing_object", "size_mismatch") + ) + got_list, got_head = num(row["s3_list"]), num(row["s3_head"]) + ok_requests &= got_list is not None and abs(got_list - want_list) <= 1 + ok_requests &= got_head == want_head + details.append( + f"{s} (N = {n}): {fmt(costs[s])} мкс на объект, LIST " + f"{fmt(got_list, 0)} (ожидалось {want_list}), HEAD " + f"{fmt(got_head, 0)} (ожидалось {want_head}), сеансов " + f"{fmt(cell_median(passes, s, 'batch', 'db_sessions'), 0)}", + ) + slope = memory_slope(passes, stages, "batch") + memory_ok = slope is not None and slope <= H1_BYTES_PER_KEY + holds = ( + spread_ratio is not None + and spread_ratio <= H1_SPREAD + and ok_requests + and memory_ok + ) + spread_pct = None if spread_ratio is None else spread_ratio * 100 + return Verdict( + "H1", + f"цена на объект `batch` различается не больше чем на " + f"{H1_SPREAD:.0%}; LIST = ⌈N/1000⌉ + 1, HEAD — только у кандидатов; " + f"прирост пика памяти уборщика от N ≤ {H1_BYTES_PER_KEY} Б на ключ", + f"разброс цены {fmt(spread_pct, 1)} %, наклон пика памяти " + f"{fmt(slope, 0)} Б на ключ", + CONFIRMED if holds else REFUTED, + details, + ) + + +def memory_slope( + passes: list[dict[str, Any]], + stages: list[str], + cell: str, +) -> float | None: + """Прирост пика памяти уборщика на объект между наименьшим и + наибольшим набором (Б на ключ): постоянная часть прохода (модели + botocore, пул соединений) в разность не входит.""" + points = [] + for stage in stages: + rows = cell_rows(passes, stage, cell) + peak = cell_median(passes, stage, cell, "mem_peak_mib") + if rows and peak is not None: + points.append((num(rows[0]["objects"]) or 0, peak)) + if len(points) < 2: + return None + (n0, m0), (n1, m1) = min(points), max(points) + if n1 <= n0: + return None + return (m1 - m0) * MIB / (n1 - n0) + + +def verdict_h2(meta: dict[str, Any], passes: list[dict[str, Any]]) -> Verdict: + stages = [ + s + for s in meta.get("reconcile", {}).get("h2_stages", []) + if cell_rows(passes, s, "batch") and cell_rows(passes, s, "head") + ] + if not stages: + return Verdict( + "H2", + f"HEAD дороже `batch` по времени на объект ≥ {H2_TIME_RATIO}×", + "нет ячеек", + UNTESTED, + ) + details = [] + ok = True + peaks = {s: cell_median(passes, s, "head", "mem_peak_mib") for s in stages} + known = [v for v in peaks.values() if v is not None] + # память HEAD от N не растёт: разность пиков при наибольшем и наименьшем + # N; при одном N критерий не проверяется + head_growth = max(known) - min(known) if len(known) > 1 else None + if head_growth is not None: + ok &= head_growth <= H2_HEAD_GROWTH_MIB + for s in stages: + batch = cell_median(passes, s, "batch", "us_per_object") + head = cell_median(passes, s, "head", "us_per_object") + time_ratio = ratio(head, batch) + n = num(cell_rows(passes, s, "batch")[0]["objects"]) or 1 + + def per_k(cell: str, n: float = n, s: str = s) -> float | None: + total = 0.0 + for column in ("s3_list", "s3_head", "s3_get", "db_sessions"): + value = cell_median(passes, s, cell, column) + if value is None: + return None + total += value + return total / n * 1000 + + ok &= time_ratio is not None and time_ratio >= H2_TIME_RATIO + details.append( + f"{s}: HEAD / batch по времени {fmt(time_ratio, 1)}×; запросов " + f"S3 и сеансов на 1000 объектов — batch {fmt(per_k('batch'), 1)}, " + f"HEAD {fmt(per_k('head'), 0)}; пик памяти HEAD " + f"{fmt(peaks[s], 1)} МиБ", + ) + details.append( + f"рост пика памяти HEAD от N: {fmt(head_growth, 1)} МиБ" + + (" (одно N — не проверялся)" if head_growth is None else ""), + ) + return Verdict( + "H2", + f"HEAD дороже `batch` по времени на объект ≥ {H2_TIME_RATIO}×, " + f"пик памяти HEAD от N растёт не больше чем на {H2_HEAD_GROWTH_MIB} " + "МиБ", + "; ".join(details), + CONFIRMED if ok else REFUTED, + details, + ) + + +def verdict_h3(meta: dict[str, Any], passes: list[dict[str, Any]]) -> Verdict: + info = meta.get("reconcile", {}) + small, large = info.get("h3_small_stage"), info.get("h3_large_stage") + batch_small = cell_median(passes, small, "batch", "us_per_object") + deep_small = cell_median(passes, small, "deep", "us_per_object") + deep_large = cell_median(passes, large, "deep", "us_per_object") + fast_large = cell_median(passes, large, "deep-fast", "us_per_object") + if deep_small is None and deep_large is None: + return Verdict("H3", "глубокая дороже", "нет ячеек", UNTESTED) + checks = [] + details = [] + deep_ratio = ratio(deep_small, batch_small) + if deep_ratio is not None: + checks.append(deep_ratio >= H3_DEEP_RATIO) + details.append( + f"4 KiB: глубокая / batch по времени {fmt(deep_ratio, 1)}×", + ) + sizes = info.get("object_bytes", {}) + if deep_large is not None and deep_small is not None: + mib = (sizes.get(large, MIB) - sizes.get(small, 4 * KIB)) / MIB + per_mib = (deep_large - deep_small) / 1000 / mib if mib else None + checks.append(per_mib is not None and per_mib >= H3_MS_PER_MIB) + details.append(f"цена байтов {fmt(per_mib, 2)} мс на MiB") + if deep_large is not None: + cleaner = cell_median(passes, large, "deep", "cpu_cleaner") + s3 = cell_median(passes, large, "deep", "cpu_s3") + limit = num(info.get("cleaner_cpus", {}).get("stand")) + share = ratio(cleaner, limit) + checks.append(share is not None and share >= H3_CLEANER_SHARE) + checks.append(s3 is not None and s3 <= H3_S3_CORES) + details.append( + f"1 MiB на лимите стенда: уборщик {fmt(cleaner, 3)} ядра " + f"({fmt(share * 100 if share else None, 0)} % лимита), S3 " + f"{fmt(s3, 3)} ядра", + ) + if fast_large is not None and deep_large is not None: + fast = ratio(deep_large, fast_large) + checks.append(fast is not None and fast >= H3_FAST_RATIO) + details.append(f"1 CPU быстрее в {fmt(fast, 2)} раза") + holds = bool(checks) and all(checks) + return Verdict( + "H3", + f"глубокая на 4 KiB дороже `batch` ≥ {H3_DEEP_RATIO}×; ≥ " + f"{H3_MS_PER_MIB} мс на MiB; на лимите стенда — CPU уборщика ≥ " + f"{H3_CLEANER_SHARE:.0%} лимита, S3 ≤ {H3_S3_CORES} ядра; с 1 CPU " + f"быстрее ≥ {H3_FAST_RATIO}×", + "; ".join(details), + CONFIRMED if holds else REFUTED, + details, + ) + + +def verdict_h4(window_rows: list[dict[str, Any]]) -> Verdict: + ratios = load_ratios(window_rows) + if not ratios: + return Verdict( + "H4", + "медиана r ≤ 1,5", + "нет проходов под нагрузкой", + UNTESTED, + ) + details = [] + noisy = False + fives = False + holds = True + for cell in LOAD_CELLS: + if cell not in ratios: + continue + parts = [] + for scenario, value in ratios[cell].items(): + r, a = value["r"], value["a"] + parts.append(f"{scenario} r {fmt(r)} a {fmt(a)}") + if a is not None and not 1 / H4_THRESHOLD <= a <= H4_THRESHOLD: + noisy = True + if value["s5xx"]: + fives = True + if cell in LIMITED_LOAD and (r is None or r > H4_THRESHOLD): + holds = False + details.append(f"{cell}: " + ", ".join(parts)) + contrast = ratios.get("fast-unlimited", {}).get("download", {}).get("r") + if fives: + verdict = REFUTED if not holds else UNTESTED + elif noisy: + verdict = NOISY + elif contrast is None or contrast <= H4_THRESHOLD: + verdict = UNTESTED if holds else REFUTED + else: + verdict = CONFIRMED if holds else REFUTED + return Verdict( + "H4", + f"`stand`, `stand-unlimited`, `fast-limited` — медиана r ≤ " + f"{H4_THRESHOLD} по трём сценариям; контраст `fast-unlimited` — r " + f"скачиваний > {H4_THRESHOLD}; A/A a в [1/{H4_THRESHOLD}; " + f"{H4_THRESHOLD}]; без 5xx", + f"контраст r скачиваний {fmt(contrast)}", + verdict, + details, + ) + + +def verdict_s4(meta: dict[str, Any], passes: list[dict[str, Any]]) -> Verdict: + info = meta.get("reconcile", {}) + base_stage = info.get("s4_base_stage") + base = cell_median(passes, base_stage, "batch", "duration_ms") + details = [] + checks = [] + for count in info.get("s4_candidates", []): + stage = f"S4-{count}" + before = cell_median(passes, stage, "before", "duration_ms") + after = cell_median(passes, stage, "after", "duration_ms") + heads = cell_median(passes, stage, "after", "s3_head") + codes = { + int(num(row["exit_code"]) or -1) + for cell in ("before", "after") + for row in cell_rows(passes, stage, cell) + } + if before is None or after is None: + continue + extra_before = None if base is None else before - base + extra_after = None if base is None else after - base + limit = info.get("s4_max_changes", 100) + checks.append( + extra_after is not None and extra_after <= S4_AFTER_EXTRA_MS, + ) + checks.append(heads is not None and heads <= limit + 1) + checks.append(codes == {3}) + details.append( + f"{count} кандидатов: до {fmt(before / 1000, 1)} с (+" + f"{fmt(None if extra_before is None else extra_before / 1000, 1)} " + f"с, ожидалось ~{count * S4_MS_PER_CANDIDATE / 1000:.0f} с), " + f"после {fmt(after / 1000, 1)} с (+" + f"{fmt(None if extra_after is None else extra_after / 1000, 2)} " + f"с), HEAD после {fmt(heads, 0)}, коды {sorted(codes)}", + ) + if not checks: + return Verdict("S4", "цена отказа", "нет ячеек", UNTESTED) + return Verdict( + "S4", + f"после — не дольше прохода без кандидатов на " + f"{S4_AFTER_EXTRA_MS / 1000:.0f} с, HEAD ≤ предела + 1, код 3 у " + "обоих", + "; ".join(details), + CONFIRMED if all(checks) else REFUTED, + details, + ) + + +def verdicts( + meta: dict[str, Any], + passes: list[dict[str, Any]], + window_rows: list[dict[str, Any]], +) -> list[Verdict]: + return [ + verdict_h1(meta, passes), + verdict_h2(meta, passes), + verdict_h3(meta, passes), + verdict_h4(window_rows), + verdict_s4(meta, passes), + ] + + +# ---------------------------------------------------------------- сводка + + +def render_summary( + meta: dict[str, Any], + passes: list[dict[str, Any]], + window_rows: list[dict[str, Any]], +) -> str: + info = meta.get("reconcile", {}) + profile = meta.get("profile", {}) + lines = [ + f"# Профиль сверки: метка `{meta.get('label')}`", + "", + f"- commit `{meta.get('git', {}).get('commit')}`, dirty " + f"{meta.get('git', {}).get('dirty')}; статус {meta.get('status')}", + f"- профиль `{profile.get('name')}`, повторов " + f"{profile.get('repeats')}, зерно {profile.get('seed')}, grace " + f"проходов {info.get('grace_seconds')} с, предел скорости по " + f"умолчанию {info.get('default_rate')}/с", + f"- образ «до» — commit `{info.get('before_commit')}`", + f"- CPU уборщика: {info.get('cleaner_cpus')}", + f"- фоновая нагрузка: {info.get('background')}", + f"- аргументы S3: `{' '.join(info.get('s3_command') or [])}`", + f"- хост: {meta.get('host_state', {}).get('start')}; " + f"предупреждения {meta.get('host_warnings')}; посторонние " + f"контейнеры {meta.get('other_containers')}", + "", + "## Проходы без фоновой нагрузки", + "", + "Медиана и min–max повторов. Цена — микросекунд на объект bucket.", + "", + "| Этап | N | Ячейка | Проход, с | мкс/объект | LIST | HEAD | GET " + "| DELETE | Сеансов | Прочитано, МиБ | CPU уборщика | CPU S3 | CPU " + "PG | Память, МиБ (старт → пик) | Пометки |", + "|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|", + ] + stage_cells: dict[str, list[str]] = {} + for row in passes: + if row.get("load") in (True, "True"): + continue + cells = stage_cells.setdefault(row["stage"], []) + if row["cell"] not in cells: + cells.append(row["cell"]) + for stage, cells in stage_cells.items(): + for cell in cells: + rows = cell_rows(passes, stage, cell) + flags = sorted({f for r in rows for f in str(r["flags"]).split()}) + lines.append( + f"| {stage} | {rows[0]['objects']} | {cell} | " + f"{spread([num(r['duration_ms']) / 1000 if num(r['duration_ms']) is not None else None for r in rows], 2)} | " + f"{spread([r['us_per_object'] for r in rows], 1)} | " + f"{spread([r['s3_list'] for r in rows], 0)} | " + f"{spread([r['s3_head'] for r in rows], 0)} | " + f"{spread([r['s3_get'] for r in rows], 0)} | " + f"{spread([r['s3_delete'] for r in rows], 0)} | " + f"{spread([r['db_sessions'] for r in rows], 0)} | " + f"{spread([num(r['read_bytes']) / MIB if num(r['read_bytes']) is not None else None for r in rows], 1)} | " + f"{spread([r['cpu_cleaner'] for r in rows], 3)} | " + f"{spread([r['cpu_s3'] for r in rows], 3)} | " + f"{spread([r['cpu_postgres'] for r in rows], 3)} | " + f"{spread([r['mem_start_mib'] for r in rows], 1)} → " + f"{spread([r['mem_peak_mib'] for r in rows], 1)} | " + f"{' '.join(flags) or '—'} |", + ) + lines += [ + "", + "## Фоновая нагрузка (H4)", + "", + "r — p95 окна прохода к p95 окон до и после; a — p95 до к p95 после " + "(A/A). Медиана по повторам.", + "", + "| Ячейка | Проход, с | Сценарий | r | a | 5xx |", + "|---|---|---|---|---|---|", + ] + ratios = load_ratios(window_rows) + for cell in LOAD_CELLS: + if cell not in ratios: + continue + stage = next( + (r["stage"] for r in passes if r["cell"] == cell), + "", + ) + duration = cell_median(passes, stage, cell, "duration_ms") + for scenario, value in ratios[cell].items(): + lines.append( + f"| {cell} | {fmt(duration / 1000 if duration else None, 1)}" + f" | {scenario} | {fmt(value['r'])} | {fmt(value['a'])} | " + f"{value['s5xx']} |", + ) + lines += [ + "", + "## Отказ по пределу (S4)", + "", + "| Кандидатов | Ячейка | Проход, с | HEAD | Не перепроверено | " + "Изменений в ошибке | Код |", + "|---|---|---|---|---|---|---|", + ] + for count in info.get("s4_candidates", []): + stage = f"S4-{count}" + for cell in ("before", "after"): + rows = cell_rows(passes, stage, cell) + if not rows: + continue + lines.append( + f"| {count} | {cell} | " + f"{spread([num(r['duration_ms']) / 1000 if num(r['duration_ms']) is not None else None for r in rows], 2)} | " + f"{spread([r['s3_head'] for r in rows], 0)} | " + f"{spread([r['unchecked'] for r in rows], 0)} | " + f"{spread([r['limit_changes'] for r in rows], 0)} | " + f"{sorted({r['exit_code'] for r in rows})} |", + ) + lines += ["", "## Гипотезы", ""] + for item in verdicts(meta, passes, window_rows): + lines.append(f"### {item.name}: {item.verdict}") + lines += ["", f"- критерий: {item.criterion}"] + lines.append(f"- измерено: {item.measured}") + lines += [f" - {line}" for line in item.details] + lines.append("") + lines += [ + "Графики: `cost-by-n.svg`, `requests-by-n.svg`, `background-p95.svg`.", + "", + ] + return "\n".join(lines) + + +def render_plots( + meta: dict[str, Any], + passes: list[dict[str, Any]], + window_rows: list[dict[str, Any]], +) -> dict[str, str]: + """SVG метки: время прохода от N, запросы от N (лог. шкала), r фоновой + нагрузки по ячейкам и сценариям.""" + import plots + + info = meta.get("reconcile", {}) + stages = info.get("h1_stages", []) + points: dict[str, list[tuple[float, float]]] = {} + for cell in ("batch", "head", "deep"): + for stage in stages: + value = cell_median(passes, stage, cell, "duration_ms") + n = stage_n(meta, stage) + if value is not None and n: + points.setdefault(cell, []).append((n, value / 1000)) + out = {} + svg = plots.Svg(720, 420, "Время прохода сверки от числа объектов") + out["cost-by-n.svg"] = xy_chart( + svg, + points, + "объектов в bucket", + "проход, с", + ) + req: dict[str, list[tuple[float, float]]] = {} + for cell in ("batch", "head"): + for stage in stages: + n = stage_n(meta, stage) + s3 = sum( + cell_median(passes, stage, cell, f"s3_{op}") or 0 + for op in S3_OPS + ) + db = cell_median(passes, stage, cell, "db_sessions") + if n and cell_rows(passes, stage, cell): + req.setdefault(f"{cell}: S3", []).append((n, max(s3, 1))) + if db: + req.setdefault(f"{cell}: PostgreSQL", []).append((n, db)) + svg = plots.Svg(720, 420, "Запросы прохода от числа объектов") + out["requests-by-n.svg"] = xy_chart( + svg, + req, + "объектов в bucket", + "запросов (лог. шкала)", + log=True, + ) + out["background-p95.svg"] = ratio_chart(load_ratios(window_rows)) + return out + + +def xy_chart( + svg: Any, + series: dict[str, list[tuple[float, float]]], + x_title: str, + y_title: str, + *, + log: bool = False, +) -> str: + import plots + + left, top, width, height = 80, 60, 600, 290 + xs = [x for pts in series.values() for x, _ in pts] or [1] + ys = [y for pts in series.values() for _, y in pts] or [1] + x_hi = max(xs) * 1.05 + if log: + y_lo = 10 ** math.floor(math.log10(max(min(ys), 1))) + y_hi = 10 ** math.ceil(math.log10(max(ys) * 1.01)) + ticks = plots.log_ticks(y_lo, y_hi) + else: + ticks = plots.nice_ticks(max(ys) * 1.1) + y_lo, y_hi = 0.0, ticks[-1] + + def sx(x: float) -> float: + return left + width * x / x_hi + + def sy(y: float) -> float: + if log: + span = math.log10(y_hi) - math.log10(y_lo) + share = (math.log10(max(y, y_lo)) - math.log10(y_lo)) / span + else: + share = (y - y_lo) / (y_hi - y_lo) if y_hi > y_lo else 0 + return top + height * (1 - share) + + for tick in ticks: + svg.line(left, sy(tick), left + width, sy(tick)) + svg.text(left - 8, sy(tick) + 4, plots.compact(tick), anchor="end") + for x in sorted(set(xs)): + svg.text(sx(x), top + height + 18, plots.compact(x), anchor="middle") + svg.text(left + width / 2, top + height + 40, x_title, anchor="middle") + svg.text(24, top + height / 2, y_title, anchor="middle", rotate=True) + legend = [] + for index, (name, pts) in enumerate(series.items()): + color = plots.SERIES[index % len(plots.SERIES)] + ordered = sorted(pts) + svg.polyline([(sx(x), sy(y)) for x, y in ordered], color) + for x, y in ordered: + svg.dot(sx(x), sy(y), color, f"{name}: N {x:g}, {y:g}") + legend.append((color, name, "line")) + svg.legend(legend, left, 48, width) + return svg.render() + + +def ratio_chart(ratios: dict[str, dict[str, dict[str, Any]]]) -> str: + import plots + + svg = plots.Svg(720, 420, "Фоновая нагрузка: r = p95 прохода / p95 тихих") + left, top, width, height = 80, 70, 600, 280 + cells = [cell for cell in LOAD_CELLS if cell in ratios] + values = [ + v["r"] + for cell in cells + for v in ratios[cell].values() + if v["r"] is not None + ] + high = max([H4_THRESHOLD * 1.2, *values]) + ticks = plots.nice_ticks(high) + + def sy(y: float) -> float: + return top + height * (1 - y / ticks[-1]) + + for tick in ticks: + svg.line(left, sy(tick), left + width, sy(tick)) + svg.text(left - 8, sy(tick) + 4, f"{tick:g}", anchor="end") + # полоса A/A: [1/1,5; 1,5] и линия порога + svg.parts.append( + f'', + ) + svg.line( + left, + sy(H4_THRESHOLD), + left + width, + sy(H4_THRESHOLD), + color=plots.INK_2, + dash="5 4", + ) + group = width / max(1, len(cells)) + bar = group / (len(SCENARIOS) + 1) + for gi, cell in enumerate(cells): + x0 = left + gi * group + bar / 2 + for si, scenario in enumerate(SCENARIOS.values()): + r = ratios[cell].get(scenario, {}).get("r") + if r is None: + continue + color = plots.SERIES[si] + svg.bar( + x0 + si * bar, + sy(r), + bar * 0.9, + sy(0) - sy(r), + color, + f"{cell} {scenario}: r {r:.2f}", + top=True, + ) + svg.text( + left + gi * group + group / 2, + top + height + 18, + cell, + anchor="middle", + ) + svg.legend( + [ + (plots.SERIES[i], name, "box") + for i, name in enumerate(SCENARIOS.values()) + ] + + [(plots.INK_2, f"порог {H4_THRESHOLD}", "dash")], + left, + 56, + width, + ) + return svg.render() + + +# ------------------------------------------------------------ самопроверка + + +def selftest() -> int: + failures: list[str] = [] + + def expect(name: str, got: Any, want: Any) -> None: + if got != want: + failures.append(f"{name}: got {got!r}, want {want!r}") + + # набор: классы, id, содержимое, модель + expect("class 0", object_class(0), "orphan_object") + expect("class 3", object_class(403), "stale_pending") + expect("class ok", object_class(4), None) + expect("force ok", object_class(0, FORCE_OK), None) + expect("force missing", object_class(5, FORCE_MISSING), "missing_object") + first = object_id(7, 1) + expect("id deterministic", first, object_id(7, 1)) + expect("id v4", uuid.UUID(first).version, 4) + expect("id lower", first, str(uuid.UUID(first))) + expect("content size", len(content(7, 1, 4096)), 4096) + expect("content differs", content(7, 1, 64) == content(7, 2, 64), False) + m = model(10_000) + expect("model found", m.found, dict.fromkeys(CLASSES, 25)) + expect("model objects", m.objects, 9975) + expect("model ready", m.ready_rows, 9950) + expect("model 1000", model(1000).found["orphan_object"], 3) + expect("model 1000 stale", model(1000).found["stale_pending"], 3) + expect("model 1000 ready", model(1000).ready_rows, 994) + s4 = model(0, clean=10_000, missing=1000) + expect( + "s4 model", + (s4.objects, s4.ready_rows, s4.found), + ( + 10_000, + 11_000, + {"missing_object": 1000}, + ), + ) + text = rows_csv( + seed=7, + start=0, + end=800, + size=4096, + namespace="bench", + chat_id="c", + owner_id="o", + created_at="2026-10-22T00:00:00+00:00", + ) + lines = text.splitlines() + expect("csv rows", len(lines), 800 - 2) + expect("csv columns", len(lines[0].split(",")), len(COPY_COLUMNS)) + by_index = {line.split(",")[3]: line.split(",") for line in lines} + expect("csv size mismatch", by_index["bench-2.png"][5], "4097") + expect("csv pending", by_index["bench-3.png"][8], "pending") + expect("csv no orphan row", "bench-0.png" in by_index, False) + expect( + "csv sha", + by_index["bench-4.png"][6], + "\\x" + hashlib.sha256(content(7, 4, 4096)).hexdigest(), + ) + expect("objects without missing", 1 in object_indices(0, 10), False) + expect("objects count", len(object_indices(0, 800)), 798) + picked = downloads(7, 2000, 5000) + expect("downloads only consistent", len(picked), 2000 - 20) + + # план кругами + plan = plan_passes([("A", ("x", "y", "z")), ("B", ("x", "y"))], 3, 5) + expect("plan length", len(plan), 15) + expect("plan unique", len({p["pass"] for p in plan}), 15) + expect("plan stage order", [p["stage"] for p in plan][:9], ["A"] * 9) + for i in range(1, len(plan)): + same = plan[i]["cell"] == plan[i - 1]["cell"] + if same and plan[i]["stage"] == plan[i - 1]["stage"]: + failures.append(f"plan repeats a cell in a row at {i}") + + # записи уборщика + log = "\n".join( + [ + "Container mtusi-bench-reconcile-1 Creating", + json.dumps({"event": STARTED, "reconcile_strategy": "batch"}), + json.dumps({"event": FOUND, "kind": "orphan_object"}), + json.dumps({"event": FOUND, "kind": "orphan_object"}), + json.dumps( + { + "event": FINISHED, + "found": {"orphan_object": 2}, + "duration_ms": 1500, + "timestamp": "2026-10-23T01:02:03.456789Z", + "s3_requests": { + "list": 3, + "head": 2, + "get": 0, + "delete": 0, + }, + "phase_ms": {"list": 1000, "rows": 200}, + "listed_objects": 1000, + "storage_objects": 1003, + }, + ), + ], + ) + kept = kept_records(parse_records(log)) + expect("kept found count", kept["found_records"], 2) + expect("kept finished", kept["finished"]["duration_ms"], 1500) + expect( + "timestamp", + timestamp("2026-10-23T01:02:03.456789Z"), + 1792717323.456789, + ) + expect( + "timestamp nano", + timestamp("2026-10-23T01:02:03.456789123Z"), + 1792717323.456789, + ) + problems = found_problems( + {"pass": "B-batch-r1"}, + {"orphan_object": 2, "missing_object": 1}, + kept, + ) + expect( + "found problem", + problems, + ["B-batch-r1: missing_object found 0, injected 1"], + ) + expect( + "found ok", + found_problems({"pass": "p"}, {"orphan_object": 2}, kept), + [], + ) + + # метрики шлюза + metrics_a = ( + '# HELP x\nSeaweedFS_s3_request_total{bucket="bench",code="200",' + 'type="LIST"} 4\nSeaweedFS_s3_request_total{bucket="bench",' + 'code="200",type="GET"} 10\nSeaweedFS_s3_request_total{bucket=' + '"bench",code="404",type="GET"} 2\nother_metric 5\n' + ) + metrics_b = metrics_a.replace("} 4", "} 7").replace("} 10", "} 11") + delta = metrics_delta(parse_metrics(metrics_a), parse_metrics(metrics_b)) + expect("metrics delta", delta, {"GET": 1, "LIST": 3}) + expect( + "gateway equal", + gateway_mismatch({"list": 3, "head": 1, "get": 0, "delete": 0}, delta), + False, + ) + expect( + "gateway differ", + gateway_mismatch({"list": 3, "head": 2, "get": 0, "delete": 0}, delta), + True, + ) + expect("pg stat", parse_pg_stat("1|2|3|4|5|6")["pg_sessions"], 6) + + # фоновая нагрузка, окна и отношения + reqs = [] + for second in range(30): + for kind, base in (("d", 10), ("w", 20), ("r", 5)): + duration = base * (3 if 10 <= second < 20 else 1) + reqs.append( + Request(kind, second * 1000 + 1, duration, OK_STATUS[kind]), + ) + reqs.append(Request("d", 15_000, 1, 503)) + console = "\n".join( + f"bg,{r.kind},{r.start_ms},{r.duration_ms},{r.status}" for r in reqs + ) + parsed = parse_background(console + "\nnoise\nbg,x,1,2,3\n") + expect("bg parsed", len(parsed), len(reqs)) + bounds = {"before": (0, 10), "pass": (10, 20), "after": (20, 30)} + rows, ratios_one = windows_of(parsed, bounds) + expect("window rows", len(rows), 12) + expect("r download", ratios_one["download"]["r"], 3.0) + expect("a download", ratios_one["download"]["a"], 1.0) + expect("5xx download", ratios_one["download"]["s5xx"], 1) + expect("percentile", percentile([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 95), 10.0) + + # окно CPU и память по отсчётам сэмплера (нс, usage_usec, …, memory) + points = [ + (int(t * 1e9), int(t * 250_000), 0, 0, 0, (100 + t) * MIB, 0) + for t in (0, 1, 2, 3, 4) + ] + expect("window cpu", window_cpu(points, 0.5, 3.5), 0.25) + # короткий проход после последнего отсчёта — по охватывающим отсчётам + expect("window cpu tail", window_cpu(points, 3.8, 4.3), 0.25) + expect("memory", memory_start_peak(points, 2.5), (102.0, 104.0)) + + # строка прохода и пометка count_mismatch + entry = { + "pass": "B-batch-r1", + "stage": "B", + "cell": "batch", + "repeat": 1, + "order": 1, + } + row = pass_row( + entry, + cell=CELLS["batch"], + expected=model(1000), + object_bytes=4096, + kept=kept, + exit_code=3, + gateway={"LIST": 3, "GET": 3}, + pg=None, + cpu={"cleaner": 0.25}, + memory=(90.0, 91.0), + cleaner_cpus="0.25", + rate=0, + image="checkout", + ) + expect("row flags", row["flags"], "count_mismatch") + expect( + "row us per object", + row["us_per_object"], + round(1_500_000 / 997, 2), + ) + expect("row fields", set(row) <= set(PASS_FIELDS), True) + + # вердикты и сводка на синтетических проходах + meta = { + "label": "selftest", + "profile": {"name": "reconcile_quick", "repeats": 1}, + "reconcile": { + "h1_stages": ["B", "C"], + "h2_stages": ["B"], + "h3_small_stage": "B", + "h3_large_stage": "A", + "s4_base_stage": "B", + "s4_candidates": [300], + "s4_max_changes": 100, + "cleaner_cpus": {"stand": "0.25", "fast": "1"}, + "object_bytes": {"A": MIB, "B": 4 * KIB, "C": 4 * KIB}, + "stages": [ + {"stage": "B", "objects_total": 10_000}, + {"stage": "C", "objects_total": 30_000}, + ], + }, + } + + def synthetic( + stage: str, + cell: str, + n: int, + us: float, + **extra: Any, + ) -> dict[str, Any]: + mdl = model(n) + base = dict.fromkeys(PASS_FIELDS) + base.update( + { + "pass": f"{stage}-{cell}-r1", + "stage": stage, + "cell": cell, + "load": cell in LOAD_CELLS, + "objects": mdl.objects, + "us_per_object": us, + "duration_ms": us * mdl.objects / 1000, + "s3_list": math.ceil(mdl.objects / 1000) + 1, + "s3_head": sum( + mdl.found[k] + for k in ( + "orphan_object", + "missing_object", + "size_mismatch", + ) + ), + "s3_get": 0, + "s3_delete": 0, + "db_sessions": 100, + "mem_start_mib": 97.0, + "mem_peak_mib": 97.0 + mdl.objects * 150 / MIB, + "mem_growth_bytes_per_object": 150.0, + "exit_code": 3, + "flags": "", + **{f"expected_{k}": mdl.found.get(k, 0) for k in CLASSES}, + }, + ) + base.update(extra) + return base + + passes = [ + synthetic("B", "batch", 10_000, 300), + synthetic("C", "batch", 30_000, 310), + synthetic("B", "head", 10_000, 5000, mem_peak_mib=98.0, s3_head=9950), + synthetic("B", "deep", 10_000, 2700, s3_get=9925), + synthetic("A", "deep", 1000, 10_500, cpu_cleaner=0.245, cpu_s3=0.19), + synthetic("A", "deep-fast", 1000, 4800), + synthetic( + "S4-300", + "before", + 10_000, + 0, + duration_ms=4500, + exit_code=3, + ), + synthetic("S4-300", "after", 10_000, 0, duration_ms=3200, s3_head=101), + ] + found = { + item.name: item.verdict + for item in verdicts(meta, passes, rows_with_cells(rows)) + } + expect("verdict H1", found["H1"], CONFIRMED) + expect("verdict H2", found["H2"], CONFIRMED) + expect("verdict H3", found["H3"], CONFIRMED) + expect("verdict S4", found["S4"], CONFIRMED) + expect("verdict H4 contrast", found["H4"], UNTESTED) + slow = [*passes[:1], synthetic("C", "batch", 30_000, 500), *passes[2:]] + found = {item.name: item.verdict for item in verdicts(meta, slow, [])} + expect("verdict H1 refuted", found["H1"], REFUTED) + summary = render_summary(meta, passes, rows_with_cells(rows)) + for needle in ("## Гипотезы", "### H1", "### S4", "| B | 9975 | batch"): + if needle not in summary: + failures.append(f"summary lacks {needle!r}") + svgs = render_plots(meta, passes, rows_with_cells(rows)) + expect( + "plots", + sorted(svgs), + [ + "background-p95.svg", + "cost-by-n.svg", + "requests-by-n.svg", + ], + ) + for name, text in svgs.items(): + if not text.startswith(" list[dict[str, Any]]: + """Самопроверка: строки окон одного прохода ячейки `fast-unlimited` + с окном «тихих» для `load_ratios`.""" + out = [] + for row in rows: + out.append( + {"pass": "D-fast-unlimited-r1", "cell": "fast-unlimited", **row}, + ) + return out + + +if __name__ == "__main__": + if sys.argv[1:] == ["--selftest"]: + sys.exit(selftest()) + print("usage: uv run python bench/reconcile.py --selftest", flush=True) + sys.exit(2) diff --git a/bench/run.py b/bench/run.py index 61835911..76e35694 100644 --- a/bench/run.py +++ b/bench/run.py @@ -32,12 +32,13 @@ import time import uuid from collections.abc import Callable from dataclasses import asdict, dataclass, replace -from datetime import UTC, datetime +from datetime import UTC, datetime, timedelta from pathlib import Path from typing import Any import failover import plots +import reconcile import resources import rollout import scaling @@ -75,6 +76,14 @@ S3_VOLUME = f"{PROJECT}_s3_data" # bench.compose.yml в рабочем каталоге метки VARIANT_COMPOSE = "variant.compose.yml" K6 = "mtusi-bench-k6" +# профиль сверки (design change track2-reconcile-cost, решения 3 и 8): +# загрузчик объектов на образе стенда, разовые проходы уборщика +# `<префикс><номер>`, override S3 с портом метрик шлюза и override образа +# уборщика «до» — в рабочем каталоге метки +FILL = "mtusi-bench-fill" +RECONCILE_PASS = "mtusi-bench-reconcile-" +S3_METRICS_COMPOSE = "s3-metrics.compose.yml" +BEFORE_CLEANER_COMPOSE = "cleaner-before.compose.yml" # сэмплер серий трека 1: образ PostgreSQL стенда, --cgroupns host # (решение 7 design change scaling-bench) SAMPLER = "mtusi-bench-sampler" @@ -352,6 +361,43 @@ class Profile: uploads_sample_interval_s: float = 0.2 s3_cpus: str = "1" s3_memory: str = "512m" + # уборщик (сервис cleaner): лимиты рабочего стенда без swap — у всех + # профилей (compose требует их при разборе), запускает его только + # профиль сверки (design change track2-reconcile-cost, решение 1) + cleaner_cpus: str = "0.25" + cleaner_memory: str = "256m" + # профиль сверки (design change track2-reconcile-cost, решения 1–3, + # 7–10): этапы — (имя, свежий стенд, объектов всего, размер объекта, + # ячейки bench/reconcile.py CELLS); отказ по пределу — commit образа + # «до», согласованных объектов, кандидатов по шагам и предел + # изменений; grace проходов и запас после последнего PUT; CPU уборщика + # управляемого опыта; фоновая нагрузка (сценарий → запросов в + # секунду), скачиваемых вложений, тихие окна; загрузчик объектов; + # интервал сэмплера; стадии гипотез для сводки + reconcile_stages: tuple[tuple[Any, ...], ...] = () + reconcile_before: str = "" + reconcile_s4_clean: int = 0 + reconcile_s4_candidates: tuple[int, ...] = () + reconcile_s4_max_changes: int = 100 + reconcile_grace_s: int = 30 + reconcile_fresh_wait_s: int = 2 + reconcile_fast_cpus: str = "1" + reconcile_default_rate: float = 2000 + reconcile_background: tuple[tuple[str, int], ...] = ( + ("download", 300), + ("write", 50), + ("read", 50), + ) + reconcile_downloads: int = 5000 + reconcile_quiet_s: int = 30 + reconcile_fill_processes: int = 3 + reconcile_fill_threads: int = 24 + reconcile_sample_interval_s: float = 0.5 + reconcile_metrics_port: int = 9327 + reconcile_h1_stages: tuple[str, ...] = () + reconcile_h2_stages: tuple[str, ...] = () + reconcile_h3_stages: tuple[str, ...] = () + reconcile_s4_base: str = "" # серии трека 1 (решения 1–6, 14 design change scaling-bench): имя # серии, конфигурации (реплик, CPU и память реплики, max_connections # PostgreSQL), чаты записи, смесь, фиксированные уровни, лестница и @@ -409,6 +455,10 @@ class Profile: def is_uploads(self) -> bool: return bool(self.uploads_variants) + @property + def is_reconcile(self) -> bool: + return bool(self.reconcile_stages) + PROFILES = { "full": Profile( @@ -621,6 +671,98 @@ PROFILES = { uploads_sizes=(("10MiB", 3409),), uploads_clients=(1, 10, 40), ), + # стоимость сверки bucket и БД (трек 2 «5» лабы 4): LB, две реплики, + # хранилища и S3 с лимитами рабочего стенда, разовые проходы уборщика. + # Этапы A (1 MiB), B → C → D (4 KiB, набор растёт), затем отказ по + # пределу S4 на образе 7f4e626 — последнего commit до change — и на + # checkout. Design change track2-reconcile-cost, решения 1–3, 7–10 + "reconcile": Profile( + name="reconcile", + 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, + reconcile_stages=( + ("A", True, 1_000, 1024 * 1024, ("batch", "deep", "deep-fast")), + ("B", True, 10_000, 4096, ("batch", "head", "deep")), + ("C", False, 30_000, 4096, ("batch", "head")), + ( + "D", + False, + 100_000, + 4096, + ( + "batch", + "stand", + "stand-unlimited", + "fast-unlimited", + "fast-limited", + ), + ), + ), + reconcile_before="7f4e626", + reconcile_s4_clean=10_000, + reconcile_s4_candidates=(1_000, 10_000), + reconcile_h1_stages=("B", "C", "D"), + reconcile_h2_stages=("B", "C"), + reconcile_h3_stages=("B", "A"), + reconcile_s4_base="B", + ), + "reconcile_quick": Profile( + name="reconcile_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, + reconcile_stages=( + ( + "Q", + True, + 2_000, + 4096, + ( + "batch", + "head", + "deep", + "stand", + "stand-unlimited", + "fast-unlimited", + "fast-limited", + ), + ), + ), + reconcile_before="7f4e626", + reconcile_s4_clean=2_000, + reconcile_s4_candidates=(300,), + reconcile_quiet_s=5, + reconcile_downloads=1_000, + reconcile_h1_stages=("Q",), + reconcile_h2_stages=("Q",), + reconcile_h3_stages=("Q", ""), + reconcile_s4_base="Q", + ), } @@ -1074,6 +1216,13 @@ def vm_warnings(profile: Profile) -> list[str]: elif profile.is_uploads: # профиль загрузок: S3 и сэмплер peak extra = (profile.s3_memory, profile.sampler_memory) + elif profile.is_reconcile: + # профиль сверки: S3, разовый уборщик и сэмплер scan + extra = ( + profile.s3_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 ( @@ -1325,6 +1474,8 @@ def compose_env(profile: Profile) -> dict[str, str]: "BENCH_DB_MAX_CONNECTIONS": str(profile.db_max_connections), "BENCH_S3_CPUS": profile.s3_cpus, "BENCH_S3_MEMORY": profile.s3_memory, + "BENCH_CLEANER_CPUS": profile.cleaner_cpus, + "BENCH_CLEANER_MEMORY": profile.cleaner_memory, } @@ -1345,7 +1496,7 @@ def leftovers() -> dict[str, list[str]]: "{{.Names}}", ).split() networks = sh("docker", "network", "ls", "--format", "{{.Name}}").split() - extra = [name for name in (K6, SAMPLER) if name in names] + extra = [name for name in (K6, SAMPLER, FILL) if name in names] return { "rm -f": containers + [n for n in extra if n not in containers], "volume rm": sh( @@ -1577,10 +1728,20 @@ class Stand: self.compose("run", "--rm", "migrate") say("migrations applied") if self.profile.is_uploads: - # S3 — только профиль загрузок (design change upload-memory, - # решение 10); прочие профили его не запускают + # S3 — только профили загрузок (design change upload-memory, + # решение 10) и сверки; прочие профили его не запускают self.start_s3() say("s3 healthy, bootstrap done") + if self.profile.is_reconcile: + # профиль сверки: аргументы S3 рабочего стенда и порт метрик + # шлюза на loopback контейнера (design change + # track2-reconcile-cost, решение 8) + self.extra_files = [self.s3_metrics_override()] + self.start_s3() + say( + f"s3 healthy with metrics port " + f"{self.profile.reconcile_metrics_port}, bootstrap done", + ) self.compose( "up", "-d", @@ -1639,6 +1800,224 @@ class Stand: "s3-bootstrap", ) + def s3_command(self) -> list[str]: + """Аргументы сервера S3 по `docker compose config` стенда без + override метрик: те же, что у рабочего стенда.""" + saved = self.extra_files + self.extra_files = [] + try: + config = json.loads(self.compose("config", "--format", "json")) + finally: + self.extra_files = saved + return list(config["services"]["s3"]["command"]) + + def s3_metrics_override(self) -> Path: + """`.work/s3-metrics.compose.yml`: `command` сервиса `s3` из + конфигурации стенда и `-metricsPort` (JSON — подмножество YAML). + Порт слушает `-metricsIp`, по умолчанию `-ip.bind` — loopback + контейнера (design change `track2-reconcile-cost`, решение 8).""" + command = [ + *self.s3_command(), + f"-metricsPort={self.profile.reconcile_metrics_port}", + ] + path = self.work_dir / S3_METRICS_COMPOSE + path.write_text( + json.dumps({"services": {"s3": {"command": command}}}) + "\n", + encoding="utf-8", + ) + return path + + def s3_metrics(self) -> dict[str, float]: + """`SeaweedFS_s3_request_total` по типам изнутри контейнера S3.""" + text = sh( + "docker", + "exec", + S3, + "wget", + "-qO-", + f"http://127.0.0.1:{self.profile.reconcile_metrics_port}/metrics", + ) + return reconcile.parse_metrics(text) + + def storage_names(self) -> tuple[str, str, str]: + """Bucket, имя базы (namespace ключей объектов) и адрес S3 в сети + стенда — из окружения реплик по конфигурации compose.""" + api_env = json.loads(self.compose("config", "--format", "json"))[ + "services" + ][APP_SERVICE]["environment"] + return ( + api_env["S3__BUCKET"], + api_env["DATABASE__NAME"], + f"http://{api_env['S3__HOST']}:{api_env['S3__PORT']}", + ) + + def copy_rows(self, rows: str) -> None: + """Метаданные набора профиля сверки — `\\copy attachments … FROM + STDIN` в базе стенда (данные стенда, схему не трогает; решение 3).""" + columns = ", ".join(reconcile.COPY_COLUMNS) + proc = subprocess.run( + [ + "docker", + "exec", + "-i", + DB, + "sh", + "-c", + 'exec psql -U "$POSTGRES_USER" -d "$POSTGRES_DB" -XAtq ' + f'-v ON_ERROR_STOP=1 -c "\\copy attachments ({columns}) ' + 'FROM STDIN WITH (FORMAT csv)"', + ], + input=rows, + capture_output=True, + text=True, + check=False, + ) + if proc.returncode != 0: + raise BenchError( + f"copy rows: exit {proc.returncode}\n{proc.stderr}", + ) + + def fill_objects( + self, + *, + seed: int, + start: int, + end: int, + size: int, + force: str | None, + ) -> str: + """Объекты набора прямым PUT в S3 стенда — `bench/fill_objects.py` + в контейнере `mtusi-bench-fill` на образе стенда, ключами + пользователя API из окружения (`-e <имя>` без значения в argv).""" + p = self.profile + env = { + **self.env, + "S3__ACCESS_KEY_ID": self.env["S3_API_ACCESS_KEY"], + "S3__SECRET_ACCESS_KEY": self.env["S3_API_SECRET_KEY"], + } + bucket, namespace, endpoint = self.storage_names() + proc = subprocess.run( + [ + "docker", + "run", + "--rm", + "--name", + FILL, + "--network", + NETWORK, + "-e", + "S3__ACCESS_KEY_ID", + "-e", + "S3__SECRET_ACCESS_KEY", + "-v", + f"{ROOT / 'bench'}:/bench:ro", + "--entrypoint", + "python", + APP_IMAGE, + "/bench/fill_objects.py", + "--endpoint", + endpoint, + "--bucket", + bucket, + "--namespace", + namespace, + "--seed", + str(seed), + "--start", + str(start), + "--end", + str(end), + "--size", + str(size), + *(["--force", force] if force else []), + "--processes", + str(p.reconcile_fill_processes), + "--threads", + str(p.reconcile_fill_threads), + ], + capture_output=True, + text=True, + env=env, + check=False, + ) + if proc.returncode != 0: + raise BenchError( + f"fill objects [{start}, {end}): exit {proc.returncode}\n" + f"{(proc.stdout + proc.stderr)[-1500:]}", + ) + return proc.stdout.strip().splitlines()[-1] + + def run_pass( + self, + name: str, + args: list[str], + *, + cpus: str, + before: Path | None, + grace_s: int, + timeout_s: float = 3600, + ) -> dict[str, Any]: + """Разовый проход уборщика `docker compose run -d --name + --no-deps cleaner …` с лимитом CPU `cpus`, затем `docker wait`, + журнал, состояние и лимиты контейнера; контейнер удаляется при + любом исходе. `before` — override образа «до».""" + saved_env, saved_files = self.env, self.extra_files + self.env = {**self.env, "BENCH_CLEANER_CPUS": cpus} + if before is not None: + self.extra_files = [*self.extra_files, before] + try: + self.compose( + "run", + "-d", + "--name", + name, + "--no-deps", + "-e", + f"CLEANER__PENDING_GRACE_SECONDS={grace_s}", + "cleaner", + *args, + ) + finally: + self.env, self.extra_files = saved_env, saved_files + try: + waited = subprocess.run( + ["docker", "wait", name], + capture_output=True, + text=True, + timeout=timeout_s, + check=False, + ) + code = int(waited.stdout.strip() or -1) + proc = subprocess.run( + ["docker", "logs", name], + capture_output=True, + text=True, + check=False, + ) + started, finished, ident, image = sh( + "docker", + "inspect", + "-f", + "{{.State.StartedAt}}|{{.State.FinishedAt}}|{{.Id}}|" + "{{.Config.Image}}", + name, + ).split("|") + return { + "exit_code": code, + "log": proc.stdout + proc.stderr, + "started_at": reconcile.timestamp(started), + "finished_at": reconcile.timestamp(finished), + "id": ident, + "image": image, + "limits": self.container_limits(name), + } + finally: + subprocess.run( + ["docker", "rm", "-f", name], + capture_output=True, + check=False, + ) + def recycle_uploads(self, image: str, env: dict[str, str]) -> None: """Перед прогоном профиля загрузок (решение 10): новый volume S3 с bootstrap и новый контейнер реплики на образе варианта `image` с @@ -1874,10 +2253,25 @@ class Stand: # -v — анонимные volume образа (у сэмплера — /var/lib/postgresql); # именованный volume восстановления удаляется ниже отдельно subprocess.run( - ["docker", "rm", "-f", "-v", K6, SAMPLER, RESTORE_DB], + ["docker", "rm", "-f", "-v", K6, SAMPLER, RESTORE_DB, FILL], capture_output=True, check=False, ) + # разовые проходы уборщика профиля сверки (`compose run`) + passes = sh( + "docker", + "ps", + "-aq", + "--filter", + f"name={RECONCILE_PASS}", + check=False, + ).split() + if passes: + subprocess.run( + ["docker", "rm", "-f", *passes], + capture_output=True, + check=False, + ) self.compose("down", "-v", "--remove-orphans", check=False) subprocess.run( ["docker", "volume", "rm", RESTORE_VOLUME], @@ -1976,7 +2370,7 @@ class Stand: """ replicas = self.replicas() roles = {APP_SERVICE: replicas[0], **CONTAINERS, "k6": K6} - if self.profile.is_uploads: + if self.profile.is_uploads or self.profile.is_reconcile: roles["s3"] = S3 limits: dict[str, Any] = {} for role, name in roles.items(): @@ -2104,6 +2498,13 @@ class Stand: p = self.profile image = sh("docker", "inspect", "-f", "{{.Config.Image}}", DB) (self.work_dir / "samples.log").unlink(missing_ok=True) + # проход сверки 10k длится ~3 с: интервала в 1 с мало (design + # change track2-reconcile-cost, решение 9) + interval = ( + p.reconcile_sample_interval_s + if p.is_reconcile + else p.sample_interval_s + ) proc = subprocess.run( [ "docker", @@ -2129,7 +2530,7 @@ class Stand: "bash", image, "/sampler.sh", - f"{p.sample_interval_s:g}", + f"{interval:g}", "scan", ], capture_output=True, @@ -2490,9 +2891,9 @@ class Stand: } extra: dict[str, Any] = {} - if self.profile.is_uploads: - # S3 — только у профиля загрузок; образ и аргументы — рабочего - # стенда + if self.profile.is_uploads or self.profile.is_reconcile: + # S3 — только у профилей загрузок и сверки; образ и аргументы — + # рабочего стенда (у сверки ещё порт метрик, meta.reconcile) extra["s3"] = image(S3) return { **extra, @@ -3203,6 +3604,17 @@ class Results: self.prefill.append(row) self.append("prefill.csv", PREFILL_FIELDS, row) + def add_pass(self, row: dict[str, Any]) -> None: + """Проход профиля сверки — строка `passes.csv`.""" + self.runs.append(row) + self.append("passes.csv", reconcile.PASS_FIELDS, row) + + def add_windows(self, rows: list[dict[str, Any]]) -> None: + """Окна фоновой нагрузки прохода — строки `windows.csv`.""" + for row in rows: + self.timeline.append(row) + self.append("windows.csv", reconcile.WINDOW_FIELDS, row) + def add_phase( self, row: dict[str, Any], @@ -3254,7 +3666,21 @@ class Results: (self.dir / "summary.md").write_text(text, encoding="utf-8") plots.render_series(self.dir) return - if self.meta["profile"].get("uploads_variants"): + if self.meta["profile"].get("reconcile_stages"): + # профиль сверки: сводка и графики (решение 13 design change + # track2-reconcile-cost) + text = reconcile.render_summary( + self.meta, + self.runs, + self.timeline, + ) + for name, svg in reconcile.render_plots( + self.meta, + self.runs, + self.timeline, + ).items(): + (self.dir / name).write_text(svg, encoding="utf-8") + elif self.meta["profile"].get("uploads_variants"): text = uploads.render_summary(self.meta, self.runs) elif self.meta["profile"].get("rollout_from"): text = rollout.render_summary( @@ -3513,6 +3939,23 @@ def build_summary( # ---------------------------------------------------------------- прогон +def reconcile_plan(profile: Profile) -> list[dict[str, Any]]: + """Проходы профиля сверки: у этапа — ячейки без нагрузки, затем блок + под нагрузкой; отказ по пределу — шагами числа кандидатов `S4-`. + Повторы — кругами внутри группы (решение 1).""" + groups: list[tuple[str, tuple[str, ...]]] = [] + for stage, _fresh, _n, _size, cells in profile.reconcile_stages: + quiet = tuple(c for c in cells if not reconcile.CELLS[c].get("load")) + loaded = tuple(c for c in cells if reconcile.CELLS[c].get("load")) + groups += [(stage, group) for group in (quiet, loaded) if group] + for count in profile.reconcile_s4_candidates: + groups.append((f"S4-{count}", ("before", "after"))) + plan = reconcile.plan_passes(groups, profile.repeats, profile.order_seed) + for entry in plan: + entry["load"] = bool(reconcile.CELLS[entry["cell"]].get("load")) + return plan + + class Bench: def __init__( self, @@ -3545,6 +3988,13 @@ class Bench: * len(profile.uploads_clients) * profile.repeats ) + if profile.is_reconcile: + # профиль сверки — проходы: этапы и S4, по повторам + self.runs_total = len(reconcile_plan(profile)) + # профиль сверки: длительности проходов для оценки остатка и + # фикстура стенда (читаемый чат и его владелец — чат набора) + self.pass_seconds: list[float] = [] + self.fixture: dict[str, Any] = {} self.runs_done = 0 # серии: ячейка и попытка текущей ступени, длительности ячеек, # номер ступени в метке (столбец run) @@ -3584,6 +4034,13 @@ class Bench: def eta(self) -> float: p = self.profile + if p.is_reconcile: + # проход: старт контейнера и сам проход (среднее снятых), тихие + # окна проходов под нагрузкой не считаются + per_pass = ( + statistics.mean(self.pass_seconds) if self.pass_seconds else 20 + ) + return (self.runs_total - self.runs_done) * per_pass if p.is_uploads: # прогон: смена S3 и реплики (~15 с), разгон, окно, остаток per_run = 20 + p.uploads_ramp_s + p.uploads_window_s @@ -3670,6 +4127,9 @@ class Bench: # --------------------------------------------------------- этапы def run(self) -> None: + if self.profile.is_reconcile: + self.run_reconcile() + return if self.profile.is_uploads: self.run_uploads() return @@ -5606,6 +6066,532 @@ class Bench: ) self.progress(last={"run": name, "flags": row["flags"]}) + # ------------------------------------------------ профиль сверки + + def run_reconcile(self) -> None: + """Профиль сверки (design change `track2-reconcile-cost`, решения + 1–3, 7–10): план в паспорт до первого прохода; этапы — свежий или + тот же стенд, наполнение мимо API, проходы без нагрузки, блок под + нагрузкой; затем отказ по пределу на свежем стенде.""" + p = self.profile + meta = self.results.meta + plan = reconcile_plan(p) + self.runs_total = len(plan) + commit = sh( + "git", + "-C", + str(ROOT), + "rev-parse", + "--short", + f"{p.reconcile_before}^{{commit}}", + ) + info: dict[str, Any] = meta.setdefault("reconcile", {}) + info.update( + { + "before_commit": commit, + "plan": plan, + "seed": p.seed, + "period": reconcile.PERIOD, + "classes": list(reconcile.CLASSES), + "stages": [ + { + "stage": stage, + "fresh": fresh, + "objects_total": n, + "object_bytes": size, + "cells": list(cells), + "model": asdict(reconcile.model(n)), + } + for stage, fresh, n, size, cells in p.reconcile_stages + ], + "object_bytes": { + stage: size for stage, _, _, size, _ in p.reconcile_stages + }, + "s4_clean": p.reconcile_s4_clean, + "s4_candidates": list(p.reconcile_s4_candidates), + "s4_max_changes": p.reconcile_s4_max_changes, + "s4_base_stage": p.reconcile_s4_base, + "h1_stages": list(p.reconcile_h1_stages), + "h2_stages": list(p.reconcile_h2_stages), + "h3_small_stage": p.reconcile_h3_stages[0], + "h3_large_stage": p.reconcile_h3_stages[1], + "cleaner_cpus": { + "stand": p.cleaner_cpus, + "fast": p.reconcile_fast_cpus, + }, + "grace_seconds": p.reconcile_grace_s, + "default_rate": p.reconcile_default_rate, + "background": { + **dict(p.reconcile_background), + "downloads": p.reconcile_downloads, + "quiet_s": p.reconcile_quiet_s, + }, + "metrics_port": p.reconcile_metrics_port, + "images": {"checkout": meta["app_image"]["id"]}, + }, + ) + self.results.write_meta() + self.say( + f"reconcile: {len(plan)} passes planned " + f"({len(p.reconcile_stages)} stages and " + f"{len(p.reconcile_s4_candidates)} limit steps × {p.repeats})", + ) + filled = 0 + for stage, fresh, n, size, _cells in p.reconcile_stages: + if fresh or not self.prepared: + self.reconcile_stand(stage) + filled = 0 + self.reconcile_fill(stage, filled, n, size, force=None) + filled = n + expected = reconcile.model(n) + entries = [e for e in plan if e["stage"] == stage] + for entry in (e for e in entries if not e["load"]): + result = self.reconcile_pass(entry, expected, size) + self.results.add_pass(result["row"]) + loaded = [e for e in entries if e["load"]] + if loaded: + self.reconcile_load(stage, loaded, expected, size, n) + if p.reconcile_s4_candidates: + self.reconcile_limit(plan) + + def reconcile_stand(self, stage: str) -> None: + """Свежий стенд этапа: прежний (если был) удаляется с volumes; + реплики за LB, S3 с портом метрик, пользователь и чат, сэмплер + `scan` на весь этап.""" + stand = self.stand + if self.prepared: + stand.stop_sampler() + stand.stop() + self.stage = f"{stage} start" + self.progress() + stand.start(lambda text: self.say(f"{stage}: {text}")) + meta = self.results.meta + if "limits" not in meta: + meta["limits"] = stand.limits() + meta["stand"] = stand.passport() + meta["reconcile"]["s3_command"] = stand.s3_command() + [ + f"-metricsPort={self.profile.reconcile_metrics_port}", + ] + self.results.write_meta() + stand.k6( + "prepare.js", + { + "MEMBERS": self.profile.members, + "BACKGROUND": "", + "WRITE_CHATS": 1, + }, + ) + self.fixture = stand.work_json("fixture.json") + stand.start_scan_sampler() + self.prepared = True + + def reconcile_fill( + self, + stage: str, + start: int, + end: int, + size: int, + *, + force: str | None, + objects: bool = True, + ) -> None: + """Наполнение мимо API: строки `\\copy`, объекты загрузчиком; затем + ожидание grace + запас после последнего PUT — объекты без строки + старше grace (решения 2 и 3).""" + p = self.profile + stand = self.stand + self.stage = f"{stage} fill" + self.progress() + _, namespace, _ = stand.storage_names() + created = (datetime.now(UTC) - timedelta(days=1)).isoformat() + started = time.monotonic() + rows = reconcile.rows_csv( + seed=p.seed, + start=start, + end=end, + size=size, + namespace=namespace, + chat_id=self.fixture["readChatId"], + owner_id=self.fixture["readerId"], + created_at=created, + force=force, + ) + stand.copy_rows(rows) + line = "no objects" + if objects: + line = stand.fill_objects( + seed=p.seed, + start=start, + end=end, + size=size, + force=force, + ) + self.say( + f"{stage}: rows [{start}, {end}) in " + f"{time.monotonic() - started:.1f} s, {line}", + ) + if objects: + time.sleep(p.reconcile_grace_s + p.reconcile_fresh_wait_s) + + def reconcile_args(self, cell: dict[str, Any]) -> list[str]: + """Аргументы разового прохода ячейки: «до» — только `--apply + --max-changes` (прежний CLI других не знает).""" + p = self.profile + args = ["reconcile"] + if cell.get("apply"): + args += [ + "--apply", + "--max-changes", + str(p.reconcile_s4_max_changes), + ] + if cell.get("before"): + return args + args += ["--strategy", cell["strategy"]] + if cell["deep"]: + args.append("--deep") + if cell["rate"] != "default": + args += ["--max-objects-per-second", f"{cell['rate']:g}"] + return args + + def reconcile_pass( + self, + entry: dict[str, Any], + expected: reconcile.Model, + size: int, + *, + found: dict[str, int] | None = None, + ) -> dict[str, Any]: + """Один проход: метрики шлюза и `pg_stat_database` до и после, + разовый уборщик, проверка найденного по модели (иначе — отказ + команды), CPU и память за окно по сэмплеру; строка `passes.csv` + (добавляет вызывающий: у проходов под нагрузкой — после окон).""" + p = self.profile + stand = self.stand + name = entry["pass"] + cell = reconcile.CELLS[entry["cell"]] + cpus = ( + p.cleaner_cpus if cell["cpu"] == "stand" else p.reconcile_fast_cpus + ) + self.stage = name + self.progress() + gw0 = stand.s3_metrics() + pg0 = reconcile.parse_pg_stat(stand.psql(reconcile.PG_STAT_SQL)) + before = ( + stand.work_dir / BEFORE_CLEANER_COMPOSE + if cell.get("before") + else None + ) + result = stand.run_pass( + f"{RECONCILE_PASS}{entry['order']}", + self.reconcile_args(cell), + cpus=cpus, + before=before, + grace_s=p.reconcile_grace_s, + ) + # последний отсчёт сэмплера после выхода контейнера + time.sleep(2 * p.reconcile_sample_interval_s) + gw1 = stand.s3_metrics() + pg1 = reconcile.parse_pg_stat(stand.psql(reconcile.PG_STAT_SQL)) + records = reconcile.parse_records(result["log"]) + kept = reconcile.kept_records(records) + (self.results.dir / "raw" / f"{name}-cleaner.json").write_text( + json.dumps( + {**kept, "exit_code": result["exit_code"]}, + ensure_ascii=False, + indent=2, + ) + + "\n", + encoding="utf-8", + ) + if result["exit_code"] not in (0, 3): + tail = "\n".join(result["log"].splitlines()[-10:]) + raise BenchError( + f"{name}: cleaner exit {result['exit_code']}\n{tail}", + ) + problems = reconcile.found_problems( + entry, + expected.found if found is None else found, + kept, + ) + finished = kept["finished"] or {} + for field, want in ( + ("listed_objects", expected.objects), + ("checked_rows", expected.ready_rows), + ): + if finished.get(field) != want: + problems.append( + f"{name}: {field} {finished.get(field)}, model {want}", + ) + if problems: + raise BenchError("; ".join(problems)) + t1 = reconcile.timestamp(finished["timestamp"]) + t0 = t1 - finished["duration_ms"] / 1000 + samples = scaling.parse_samples(stand.sampler_logs()[0]) + points = resources.points_by_id(samples) + + def cpu(*names: str) -> float | None: + values = [ + reconcile.window_cpu( + points.get(stand.full_id(n)[:12], []), + t0, + t1, + ) + for n in names + ] + if not values or None in values: + return None + return round(sum(v for v in values if v is not None), 4) + + cleaner_points = points.get(result["id"][:12], []) + limits = self.results.meta["limits"].setdefault("cleaner", {}) + limits.setdefault(cpus, result["limits"]) + row = reconcile.pass_row( + entry, + cell=cell, + expected=expected, + object_bytes=size, + kept=kept, + exit_code=result["exit_code"], + gateway=reconcile.metrics_delta(gw0, gw1), + pg={key: pg1[key] - pg0[key] for key in pg0}, + cpu={ + "cleaner": reconcile.window_cpu(cleaner_points, t0, t1), + "s3": cpu(S3), + "postgres": cpu(DB), + "api": cpu(*stand.replicas()), + "haproxy": cpu(LB), + }, + memory=reconcile.memory_start_peak(cleaner_points, t0), + cleaner_cpus=cpus, + rate=None if cell.get("before") else cell["rate"], + image="before" if cell.get("before") else "checkout", + ) + self.runs_done += 1 + self.pass_seconds.append(result["finished_at"] - result["started_at"]) + s3_total = sum( + int(row.get(f"s3_{op}") or 0) for op in reconcile.S3_OPS + ) + self.say( + f"{name} ({entry['order']}/{self.runs_total}): " + f"{finished['duration_ms'] / 1000:.2f} s, exit " + f"{result['exit_code']}, S3 {s3_total}, sessions " + f"{row['db_sessions']}, cleaner {row['cpu_cleaner']} cores, s3 " + f"{row['cpu_s3']}, memory {row['mem_start_mib']} → " + f"{row['mem_peak_mib']} MiB{' ' + row['flags'] if row['flags'] else ''}", + ) + self.progress(last={"pass": name, "flags": row["flags"]}) + return { + "row": row, + "started_at": result["started_at"], + "finished_at": result["finished_at"], + "t0": t0, + "t1": t1, + } + + def reconcile_load( + self, + stage: str, + entries: list[dict[str, Any]], + expected: reconcile.Model, + size: int, + n: int, + ) -> None: + """Блок H4 (решение 10): один k6 `background.js` на блок, тихие окна + до первого прохода и после каждого; окна прохода — по часам ВМ + (старт и выход контейнера, итог прохода). k6 останавливается + SIGINT, итог он пишет; число строк сверяется с итерациями.""" + p = self.profile + stand = self.stand + quiet = p.reconcile_quiet_s + ids = reconcile.downloads(p.seed, n, p.reconcile_downloads) + (stand.work_dir / "downloads.json").write_text( + json.dumps(ids), + encoding="utf-8", + ) + rates = dict(p.reconcile_background) + log_name = "background.log.k6" + load = stand.k6_console( + "background.js", + { + "DOWNLOAD_RATE": rates["download"], + "WRITE_RATE": rates["write"], + "READ_RATE": rates["read"], + "DURATION": "6h", + "NAME": "h4-k6", + }, + log_name, + ) + done: list[tuple[dict[str, Any], dict[str, Any]]] = [] + try: + self.say(f"{stage}: background load started, quiet {quiet} s") + # разгон k6 — вне первого тихого окна + time.sleep(quiet + 2) + for entry in entries: + done.append( + (entry, self.reconcile_pass(entry, expected, size)), + ) + time.sleep(quiet) + finally: + sh( + "docker", + "exec", + K6, + "pkill", + "-INT", + "-f", + "background.js", + check=False, + ) + try: + load.wait(timeout=60) + except subprocess.TimeoutExpired: + load.kill() + summary = self.results.dir / "raw" / "h4-k6.json" + if not summary.exists(): + tail = (stand.work_dir / f"{log_name}.out").read_text( + encoding="utf-8", + errors="replace", + )[-3000:] + raise BenchError( + f"{stage}: k6 background.js exit {load.returncode}, no " + f"summary:\n{tail}", + ) + requests = reconcile.parse_background( + (stand.work_dir / log_name).read_text( + encoding="utf-8", + errors="replace", + ), + ) + k6_data = json.loads(summary.read_text(encoding="utf-8")) + for kind, scenario in reconcile.SCENARIOS.items(): + iterations = ( + k6_data["metrics"] + .get(f"iterations{{scenario:{scenario}}}", {}) + .get("values", {}) + .get("count") + ) + lines = sum(1 for r in requests if r.kind == kind) + if iterations != lines: + raise BenchError( + f"{stage}: {lines} k6 lines of {scenario}, {iterations} " + "iterations", + ) + for entry, result in done: + bounds = { + "before": (result["started_at"] - quiet, result["started_at"]), + "pass": (result["t0"], result["t1"]), + "after": ( + result["finished_at"], + result["finished_at"] + quiet, + ), + } + list_ms = result["row"].get("phase_list_ms") + if list_ms is not None: + bounds["list"] = (result["t0"], result["t0"] + list_ms / 1000) + rows, ratios = reconcile.windows_of(requests, bounds) + self.results.add_windows( + [ + { + **{ + key: entry[key] + for key in ("pass", "stage", "cell", "repeat") + }, + **row, + } + for row in rows + ], + ) + pass_row = result["row"] + if any(value["s5xx"] for value in ratios.values()): + pass_row["flags"] = " ".join( + filter(None, [pass_row["flags"], "bg_5xx"]), + ) + self.results.add_pass(pass_row) + self.say( + f"{entry['pass']}: r " + + ", ".join( + f"{scenario} {value['r']}" + for scenario, value in ratios.items() + ) + + ", a " + + ", ".join( + f"{scenario} {value['a']}" + for scenario, value in ratios.items() + ), + ) + + def reconcile_limit(self, plan: list[dict[str, Any]]) -> None: + """Отказ по пределу (решение 7): свежий стенд, согласованные + объекты и строки, затем строки `ready` без объектов шагами числа + кандидатов; проходы «до» (образ commit методики, override образа + уборщика) и «после» (checkout).""" + p = self.profile + stand = self.stand + self.reconcile_stand("S4") + self.stage = "before image" + self.progress() + image = stand.build_from( + self.results.meta["reconcile"]["before_commit"], + ) + self.results.meta["reconcile"]["images"]["before"] = image + self.results.write_meta() + (stand.work_dir / BEFORE_CLEANER_COMPOSE).write_text( + json.dumps({"services": {"cleaner": {"image": FROM_IMAGE}}}) + + "\n", + encoding="utf-8", + ) + self.say(f"S4: image of {p.reconcile_before} built ({image[:19]}…)") + clean = p.reconcile_s4_clean + size = reconcile.S4_OBJECT_BYTES + # согласованные объекты: свежесть не важна, у каждого есть строка + stand.copy_rows( + reconcile.rows_csv( + seed=p.seed, + start=0, + end=clean, + size=size, + namespace=stand.storage_names()[1], + chat_id=self.fixture["readChatId"], + owner_id=self.fixture["readerId"], + created_at=(datetime.now(UTC) - timedelta(days=1)).isoformat(), + force=reconcile.FORCE_OK, + ), + ) + line = stand.fill_objects( + seed=p.seed, + start=0, + end=clean, + size=size, + force=reconcile.FORCE_OK, + ) + self.say(f"S4: {clean} consistent rows and objects, {line}") + added = 0 + for count in p.reconcile_s4_candidates: + self.reconcile_fill( + f"S4-{count}", + clean + added, + clean + count, + size, + force=reconcile.FORCE_MISSING, + objects=False, + ) + added = count + expected = reconcile.model(0, clean=clean, missing=count) + stage = f"S4-{count}" + for entry in (e for e in plan if e["stage"] == stage): + found = { + "missing_object": count + if entry["cell"] == "before" + else min(count, p.reconcile_s4_max_changes + 1), + } + result = self.reconcile_pass( + entry, + expected, + size, + found=found, + ) + self.results.add_pass(result["row"]) + def run_series(self) -> None: """Серия трека 1 (решения 4–5 design change `scaling-bench`): план ячеек кругами — в паспорт до первой ячейки; при продолжении @@ -6257,7 +7243,9 @@ def apply_overrides( raise SystemExit(f"--modes {args.modes}: failover profiles only") overrides["failover_modes"] = modes if args.rollout_from: - if profile.is_uploads: + if profile.is_reconcile: + overrides["reconcile_before"] = args.rollout_from + elif profile.is_uploads: overrides["uploads_before"] = args.rollout_from elif not profile.is_rollout: raise SystemExit( @@ -6312,6 +7300,17 @@ def main(argv: list[str]) -> int: if problem: print(problem, flush=True) return 2 + if profile.is_reconcile and profile.reconcile_s4_candidates: + # commit образа «до» отказа по пределу — до стенда (решение 7 + # design change track2-reconcile-cost) + problem = rollout_commit_problem( + profile.reconcile_before, + "reconcile_before", + "reconcile «before»", + ) + if problem: + print(problem, flush=True) + return 2 # профиль отказа реплик — доказательство уровня 4, рядом с прогонами # make test-failover (решение 7 design change graceful-failover) kind = "failover" if profile.is_failover else "bench" @@ -6323,6 +7322,10 @@ def main(argv: list[str]) -> int: # память загрузок — доказательство уровня 4 лабы 4 (design change # upload-memory, решение 10) kind = "uploads" + if profile.is_reconcile: + # стоимость сверки — рядом с evidence change track2-reconciler + # (решение 1 design change track2-reconcile-cost) + kind = "reconcile" label_dir = ROOT / "evidence" / kind / args.label relative = label_dir.relative_to(ROOT) if label_dir.exists() and not args.resume: diff --git a/config_example.toml b/config_example.toml index 32206039..3d85715b 100644 --- a/config_example.toml +++ b/config_example.toml @@ -117,3 +117,7 @@ page_size = 1000 # предел изменений за проход: больше — ни одного изменения и код 3; # разовый проход принимает больший аргументом --max-changes max_changes = 100 +# предел скорости прохода: объектов S3 в секунду (ключи страниц списка, +# HEAD, GET, DELETE) в среднем от начала прохода; 0 — без предела; +# разовый проход принимает другой аргументом --max-objects-per-second +max_objects_per_second = 2000 diff --git a/openspec/changes/track2-reconcile-cost/design.md b/openspec/changes/track2-reconcile-cost/design.md index 491f5aa2..f408ef22 100644 --- a/openspec/changes/track2-reconcile-cost/design.md +++ b/openspec/changes/track2-reconcile-cost/design.md @@ -785,6 +785,78 @@ change» → описано в нём. доказательств; - `PLAN.md`. +### Уточнения apply + +Решения, принятые в `/opsx:apply` без пользователя (он недоступен), — то +же в `PLAN.md`, `### track2-reconcile-cost`, «Решения apply». + +1. **Пауза предела — после вызова S3, а не перед следующим** (решение 6). + Перед вызовом остаётся проверка сигнала. Пауза «до следующего» не + ограничивала бы последний вызов прохода: проход из одной страницы + списка не ждал бы вовсе, и сценарий «Скорость прохода ограничена» + (длительность ≥ объектов / предел) не выполнялся бы. Средняя скорость + от начала прохода та же; DELETE шага уборки — `_pace` после + `remove_stale_pending`. +2. **`StoredObjectInfo.last_modified` и у `open` (GET)** (решения 4–5): + глубокая сверка `head` читает объект сразу, без HEAD, и свежесть + объекта проверяет по `LastModified` ответа GET. Поведение вызова не + меняется — в метаданных одно поле больше. +3. **`ReconcileFindingDTO.sha256`** — SHA-256 строки в находке: по нему + действие (`_fix`) сверяет заново прочитанный объект без лишней выборки + строки. В журнал не попадает (`_record` перечисляет поля сам). +4. **Глубокая сверка и свежесть** (решение 5): строка моложе grace — + `fresh_rows`, объект моложе grace — `fresh_objects`, ни тот, ни другой + не читается; объект исчез или изменил размер после списка — без + находки (следующий проход). Обе стратегии считают одинаково. +5. **Вернувшийся объект с другим SHA-256** — `lost_known` (пометка на + месте), а не находка: отчёт его вернувшимся не называет. +6. **Hook** (решение 14): предел изменений — первым позиционным + аргументом, флаги — по одному разу; иначе код 2. +7. **Тест предела скорости**: восемь загрузок (объектов хватает и на + свежем стенде, `-k rate_limit`), своя потеря оригинала — сравнение + своих находок; уборщик стенда стоит на время двух проходов, иначе + зависшая загрузка соседнего теста могла бы стать «старше grace» между + ними. +8. **Быстрый профиль — два свежих стенда**, а не один (решение 1): S4 на + стенде с внесёнными классами убрал бы зависшие загрузки первым же + `--apply`, и найденное у «до» и «после» разошлось бы с моделью. + Цена — ~40 с. +9. **Остановка k6 блока H4** — `docker exec mtusi-bench-k6 pkill -INT -f + background.js`: по SIGINT k6 завершает сценарии и пишет итог; строки + `bg,…` сверяются с итерациями так же, как у `failover`. Длительность — + с точностью 0,01 мс: p95 чтения истории — единицы миллисекунд, и целые + мс огрубляли `r` (быстрый профиль: `r` чтения 3,0 из 1 и 3 мс). +10. **Память в H1 и H2** (решение 12): выборка «в начале прохода» по + отсчётам 0,5 с ловит процесс до прогрева клиентов (быстрый профиль: + 44–89 МиБ, рост ~14 МиБ на 2 000 объектов — постоянная часть, не + множество). Поэтому H1 — наклон пика памяти `batch` между наименьшим и + наибольшим N (Б на ключ), H2 — рост пика `head` между N; прирост + прохода на объект остаётся столбцом `passes.csv`. Гипотезы в + `REPORT.md` записаны в этой форме до метки. +11. **Каждый проход сверяет с моделью** ещё `listed_objects` и + `checked_rows`, не только первый проход этапа; S4 — без ожидания grace: + у его объектов есть строки, свежесть на находки не влияет. +12. **Окно шага списка** (решение 10, справочно) — строка `list` в + `windows.csv`, в вердикт не входит. +13. **`driver.py reconcile-signal --pace`** кладёт 8 объектов пробы под + `<база>/attachments/pace-signal-*` (botocore в одноразовом контейнере + `api` его ключами): на пустом bucket временного стенда проход не + затронул бы ни одного объекта и не ждал бы. Объекты удаляются в + `finally`. Остановка меряется от события `kill` Docker до + `State.FinishedAt` (оба — часы ВМ); время `docker stop` (CLI и разбор + контейнера демоном) печатается рядом. +14. **Выход уборщика без финализации интерпретатора** (спек + `graceful-shutdown`, «docker stop во время паузы предела скорости»). + Проба на временном стенде: пауза прерывается за ~0,2 с после сигнала + («Stopped cleaner» через 0,18 с), но процесс выходил ещё через + 0,8–1,5 с — финализация модулей botocore и SQLAlchemy при 0,25 CPU (у + обычного прохода без сигнала — те же ~0,8 с). Итог — 1,16–1,5 с, больше + секунды спека. `src/cleaner/__main__.py` после `main()` сбрасывает + stdout и stderr и выходит `os._exit(code)`: engine и клиент S3 к этому + моменту закрыты, записи уже в stdout. После правки — 0,22 с от сигнала + до выхода. Ошибки argparse и непредвиденные исключения выходят как + раньше (до `os._exit` не доходят). + ## Risks / Trade-offs - **[Предел 2000/с удлиняет плановый проход вдвое]** → на 100k с ~30 до diff --git a/openspec/changes/track2-reconcile-cost/tasks.md b/openspec/changes/track2-reconcile-cost/tasks.md index 74b532d3..1668f00f 100644 --- a/openspec/changes/track2-reconcile-cost/tasks.md +++ b/openspec/changes/track2-reconcile-cost/tasks.md @@ -37,7 +37,7 @@ Evidence и метка — только с закоммиченного кода ## 1. Hook, тесты и красный прогон -- [ ] 1.1 `student-tests/fault_hook.py` (только stdlib, синтаксис 3.9), +- [x] 1.1 `student-tests/fault_hook.py` (только stdlib, синтаксис 3.9), действие `reconcile dry-run|apply [<предел>]` по решению 14: - необязательные `--strategy head`, `--deep` и `--max-objects-per-second R`; @@ -47,7 +47,7 @@ Evidence и метка — только с закоммиченного кода - docstring hook называет новые аргументы. Проверка: `make lint`; поведение — задача 1.3. -- [ ] 1.2 `student-tests/test_failures.py`, маркер `fault`, пять тестов по +- [x] 1.2 `student-tests/test_failures.py`, маркер `fault`, пять тестов по таблице решения 14 с `@pytest.mark.spec("storage-consistency", …)` на каждый новый сценарий: - `test_reconcile_head_strategy_same_findings`; @@ -60,7 +60,7 @@ Evidence и метка — только с закоммиченного кода записями того же прохода (`Reconcile.assert_code_matches`), как тесты `track2-reconciler`. Байты «другие того же размера» — свои для каждого теста, от зерна. Проверка: задача 1.3. -- [ ] 1.3 Красный прогон до кода групп 2–4 (дерево с 1.1–1.2, код +- [x] 1.3 Красный прогон до кода групп 2–4 (дерево с 1.1–1.2, код `7f4e626`): ``` @@ -74,7 +74,7 @@ Evidence и метка — только с закоммиченного кода ## 2. Настройки, enum и DTO -- [ ] 2.1 `src/config/settings.py`, класс `Reconciler`: +- [x] 2.1 `src/config/settings.py`, класс `Reconciler`: `max_objects_per_second: float = Field(default=2000, ge=0)` с комментарием о единице и 0 (решение 6, дельта `service-configuration`). Ещё строка в `config_example.toml`. @@ -84,7 +84,7 @@ Evidence и метка — только с закоммиченного кода - `RECONCILER__MAX_OBJECTS_PER_SECOND=-1 uv run python -m src.cleaner reconcile` — «Invalid cleaner settings» с `loc` поля и код 2 до обращения к хранилищам. -- [ ] 2.2 `src/schemas/enums/attachment.py`: +- [x] 2.2 `src/schemas/enums/attachment.py`: - `ReconcileFinding.CHECKSUM_MISMATCH = "checksum_mismatch"` с комментарием; - `ReconcileStrategy` (`batch`, `head`). @@ -98,7 +98,7 @@ Evidence и метка — только с закоммиченного кода ## 3. Счётчики клиента S3 -- [ ] 3.1 `src/infra/s3/client.py` по решению 8: +- [x] 3.1 `src/infra/s3/client.py` по решению 8: - `ObjectStorage` считает попытки вызовов по операциям (`list`, `head`, `get`, `delete`, `put`) в `_call`, ключи страниц — в `list_page`, прочитанные байты — в `_read_chunk`; @@ -112,7 +112,7 @@ Evidence и метка — только с закоммиченного кода ## 4. Сервис сверки и процесс уборщика -- [ ] 4.1 `AttachmentReconcileService.reconcile(…, strategy, deep, +- [x] 4.1 `AttachmentReconcileService.reconcile(…, strategy, deep, max_objects_per_second, …)` по решениям 6, 8 и 15: - темп перед каждым вызовом S3 рядом с `_check_stop`. Счёт затронутых объектов — дельта `storage.stats()` от начала прохода, ожидание — @@ -124,7 +124,7 @@ Evidence и метка — только с закоммиченного кода Проверка: тесты `…_rate_limit` и `…_head_strategy_same_findings` (поле `db_sessions`) зелёные в задаче 5.2. -- [ ] 4.2 Ранний отказ по пределу по решению 7: +- [x] 4.2 Ранний отказ по пределу по решению 7: - в `_recheck_all` при `apply`, как только подтверждённых классов под пределом (вместе с `checksum_mismatch`) больше `max_changes`, остальные кандидаты этих классов не перепроверяются и идут в @@ -134,7 +134,7 @@ Evidence и метка — только с закоммиченного кода Проверка: `…_limit_stops_rechecks` и прежние `test_reconcile_change_limit`, `…_limit_keeps_cleanup` — зелёные (5.2). -- [ ] 4.3 Глубокая сверка по решению 5: +- [x] 4.3 Глубокая сверка по решению 5: - с `--deep` — GET и SHA-256 потоком (`open_original`, блоки клиента) у строк `ready` без пометки, старше grace и того же размера; - класс `checksum_mismatch` — в `LIMITED_KINDS` (пометка под @@ -146,7 +146,7 @@ Evidence и метка — только с закоммиченного кода Проверка: `…_deep_checksum`, `…_restore_needs_same_bytes`, `test_reconcile_restored_original` — зелёные (5.2). -- [ ] 4.4 Стратегия `head` по решению 4: +- [x] 4.4 Стратегия `head` по решению 4: - шаг S3 → БД — выборка строки на объект (`get_attachments_for_objects` с одним элементом); строки с тем же ключом пропускаются; - шаг БД → S3 — HEAD на строку своей базы (с `--deep` — GET); @@ -155,7 +155,7 @@ Evidence и метка — только с закоммиченного кода Проверка: `…_head_strategy_same_findings` зелёный (5.2); на 10k в задаче 6.7 `found` равен внесённому. -- [ ] 4.5 `src/cleaner/main.py`: +- [x] 4.5 `src/cleaner/main.py`: - аргументы `reconcile` — `--strategy {batch,head}`, `--deep`, `--max-objects-per-second R` (≥ 0, иначе ошибка argparse, код 2); - плановая сверка — `batch`, без `--deep`, предел из настроек; @@ -168,7 +168,7 @@ Evidence и метка — только с закоммиченного кода ## 5. Спеки и проверки отказов -- [ ] 5.1 Sync дельт в основные спеки — все шесть capability, как в +- [x] 5.1 Sync дельт в основные спеки — все шесть capability, как в прежних changes. Purpose `storage-consistency` правится руками: «стоимость обхода и стратегии описывает change» → описаны в этом change. Проверка: @@ -177,21 +177,21 @@ Evidence и метка — только с закоммиченного кода покрытия без «unknown scenario»; - новые сценарии `storage-consistency` считаются покрытыми проверками отказов. -- [ ] 5.2 Полный `make failure_checks` на дереве после групп 2–4: все +- [x] 5.2 Полный `make failure_checks` на дереве после групп 2–4: все проверки зелёные (49 прежних и 5 новых), журнал PostgreSQL без признаков аварии, стенд отказов убран. Проверка: код 0, число и время в выводе (ожидаемо дольше на ~1,5–2 мин). ## 6. Профиль `reconcile` стенда `bench/` -- [ ] 6.1 `bench/bench.compose.yml`, сервис `cleaner`: лимиты +- [x] 6.1 `bench/bench.compose.yml`, сервис `cleaner`: лимиты `BENCH_CLEANER_CPUS` / `BENCH_CLEANER_MEMORY` в `deploy.resources.limits` и `memswap_limit` — без swap, как у остальных. `compose_env` в `run.py` их задаёт: `Profile.cleaner_cpus` 0,25 и `cleaner_memory` 256m — лимиты рабочего стенда. Проверка: в `docker compose config` стенда у `cleaner` 0,25 / 256 МиБ и swap = памяти; прежние профили не меняются (паспорт `stand.app_env` тот же). -- [ ] 6.2 `bench/reconcile.py` (только stdlib, без docker) по решениям +- [x] 6.2 `bench/reconcile.py` (только stdlib, без docker) по решениям 2, 10–13: - модель набора: `id`, содержимое и класс по номеру, строки CSV для `\copy`, ожидаемые числа по этапам; @@ -204,7 +204,7 @@ Evidence и метка — только с закоммиченного кода - `--selftest` на синтетических журналах, метриках и строках. Проверка: `uv run python bench/reconcile.py --selftest` — код 0. -- [ ] 6.3 `bench/fill_objects.py` по решению 3: +- [x] 6.3 `bench/fill_objects.py` по решению 3: - работает только в контейнере на образе стенда, botocore образа, `src` не импортирует; - генератор набора — из `reconcile.py` (`/bench` только на чтение); @@ -213,7 +213,7 @@ Evidence и метка — только с закоммиченного кода - печатает число объектов и PUT/с, ошибка PUT — код 1. Проверка: задача 6.7 — `listed_objects` равно модели. -- [ ] 6.4 `bench/k6/background.js` по решению 10: +- [x] 6.4 `bench/k6/background.js` по решению 10: - три сценария `constant-arrival-rate` (скачивания из `/work/downloads.json`, запись в чат записи, чтение его первой страницы); @@ -223,7 +223,7 @@ Evidence и метка — только с закоммиченного кода Проверка: задача 6.7 — число строк равно итерациям итога k6, ответов 5xx нет. -- [ ] 6.5 `bench/run.py`, профили `reconcile` и `reconcile_quick` (поля +- [x] 6.5 `bench/run.py`, профили `reconcile` и `reconcile_quick` (поля `Profile.reconcile_*` — целиком в `meta.json`) и `Bench.run_reconcile` по решениям 1–3, 7–10, 13: - S3 запускается у профилей загрузок и сверки; @@ -247,13 +247,13 @@ Evidence и метка — только с закоммиченного кода - строка хода на каждый проход. Проверка — задача 6.7. -- [ ] 6.6 `Makefile`: цели `bench_reconcile [RECONCILE_LABEL=…]` и +- [x] 6.6 `Makefile`: цели `bench_reconcile [RECONCILE_LABEL=…]` и `bench_reconcile_quick` под `$(KEEP_AWAKE)`, с комментариями о длительности (~50 и ~6 мин). `.gitignore` — `evidence/reconcile/quick-reconcile-*`. Проверка: `make -n bench_reconcile` и `make -n bench_reconcile_quick` печатают команды `run.py`. -- [ ] 6.7 `make bench_reconcile_quick` на дереве (шумный хост допустим). +- [x] 6.7 `make bench_reconcile_quick` на дереве (шумный хост допустим). Проверка: - код 0, все виды проходов; - `found` равен внесённому; @@ -264,14 +264,14 @@ Evidence и метка — только с закоммиченного кода `mtusi-messenger:bench*`, которые профиль снимает сам). Записать время и итог в `PLAN.md` (решения apply). -- [ ] 6.8 Регресс `bench/` после правок старта стенда: `make +- [x] 6.8 Регресс `bench/` после правок старта стенда: `make bench_uploads_quick` и `make bench_quick` — код 0. `--selftest` `uploads.py`, `resources.py`, `scaling.py`, `failover.py` — код 0. Проверка: коды и строки хода без ошибок. ## 7. Драйвер скилла -- [ ] 7.1 `driver.py reconcile-signal --pace` (stdlib, Python 3.9) по +- [x] 7.1 `driver.py reconcile-signal --pace` (stdlib, Python 3.9) по решению 14: - вместо `pause s3` — разовый `reconcile --max-objects-per-second 1`; - `docker stop` через 2 с после «Started cleaner»; @@ -284,7 +284,7 @@ Evidence и метка — только с закоммиченного кода ## 8. Правила и документы -- [ ] 8.1 Правила: +- [x] 8.1 Правила: - `bench.md` — раздел «Профиль сверки (`reconcile`)» и строка таблицы инструментов. Исключения границы: наполнение данных стенда `\copy`, загрузчик в контейнере, метрики шлюза на loopback, разовые проходы @@ -300,7 +300,7 @@ Evidence и метка — только с закоммиченного кода - `dto.md` — enum и поля DTO. Проверка: правила не противоречат design и дельтам. -- [ ] 8.2 AGENTS.md: +- [x] 8.2 AGENTS.md: - абзац о лабе — change `track2-reconcile-cost`; - таблица команд: `bench_reconcile`, `bench_reconcile_quick`, аргументы `make reconcile`, `reconcile-signal --pace`; @@ -311,10 +311,10 @@ Evidence и метка — только с закоммиченного кода ранний отказ. Проверка: все пути в AGENTS.md существуют. -- [ ] 8.3 `PLAN.md`, раздел `### track2-reconcile-cost` — решения apply +- [x] 8.3 `PLAN.md`, раздел `### track2-reconcile-cost` — решения apply («Решения») и вопросы, если появятся. Проверка: раздел есть, ссылки на design. -- [ ] 8.4 `make lint`, `make check`, `make validate +- [x] 8.4 `make lint`, `make check`, `make validate PYTHON=.venv/bin/python`, `openspec validate track2-reconcile-cost --strict`. Проверка: все — код 0. diff --git a/openspec/specs/graceful-shutdown/spec.md b/openspec/specs/graceful-shutdown/spec.md index a20696d7..75bc0827 100644 --- a/openspec/specs/graceful-shutdown/spec.md +++ b/openspec/specs/graceful-shutdown/spec.md @@ -203,8 +203,10 @@ SIGTERM и SIGINT, пришедшие процессу сервиса во вр Так же — во время сверки bucket и БД. Текущий вызов S3 или шаг с PostgreSQL доводится до конца или до отката. Новые страницы списка и -новые действия не начинаются. Сверку, прерванную сигналом, доводит -следующий проход, как прерванную отказом. +новые действия не начинаются. Ожидание из-за предела скорости сверки +(capability `storage-consistency`, «Скорость сверки») сигнал прерывает +сразу: остановка не ждёт конца паузы. Сверку, прерванную сигналом, +доводит следующий проход, как прерванную отказом. Затем сервис уборщика SHALL выйти с кодом 0 раньше срока остановки контейнера (10 с), а не по SIGKILL. Разовый проход сверки, прерванный @@ -227,3 +229,11 @@ PostgreSQL доводится до конца или до отката. Новы - **THEN** команда завершается быстрее 10 с, код выхода контейнера 0, а в журнале — итог сверки с причиной прерывания «остановка» и запись об остановке уборщика + +#### Scenario: docker stop во время паузы предела скорости + +- **WHEN** `docker stop` выполняется для разового прохода сверки, пока + тот ждёт из-за предела скорости +- **THEN** контейнер останавливается не позже чем через секунду после + сигнала, код выхода 1, а в журнале — итог сверки с причиной прерывания + «остановка» и запись об остановке уборщика diff --git a/openspec/specs/load-benchmark/spec.md b/openspec/specs/load-benchmark/spec.md index 3d6ce9c4..ac92876e 100644 --- a/openspec/specs/load-benchmark/spec.md +++ b/openspec/specs/load-benchmark/spec.md @@ -68,13 +68,14 @@ run_dev` / `make run_docker`). После завершения, в том чис ### Requirement: Фиксированный стенд Стенд SHALL состоять из балансировщика (LB), реплик приложения, -PostgreSQL и Valkey. В профиле загрузок к ним SHALL добавляться S3 с -его bootstrap. Число реплик SHALL задаваться методикой, по умолчанию +PostgreSQL и Valkey. В профилях загрузок и сверки к ним SHALL +добавляться S3 с его bootstrap, а в профиле сверки — ещё разовые проходы +процесса уборщика. Число реплик SHALL задаваться методикой, по умолчанию одна. Приложение SHALL запускаться в контейнерах из образа, собранного из текущего checkout тем же `Dockerfile`. Исключения — профиль -поочерёдной замены и вариант «до» профиля загрузок. Они берут образ -commit, заданного методикой: образ собирается тем же `Dockerfile` из -файлов этого commit без изменения рабочего дерева. Профиль замены +поочерёдной замены и варианты «до» профилей загрузок и сверки. Они берут +образ commit, заданного методикой: образ собирается тем же `Dockerfile` +из файлов этого commit без изменения рабочего дерева. Профиль замены заканчивается на образе текущего checkout. LB SHALL запускаться из того же образа и с той же конфигурацией, что у рабочего стенда. PostgreSQL и Valkey SHALL запускаться из тех же образов, что у @@ -82,18 +83,22 @@ commit, заданного методикой: образ собирается получает те же настройки образа плюс модуль записи планов, выключенный вне снятия плана. S3 SHALL запускаться из того же образа и с теми же аргументами сервера, что у рабочего стенда, а bucket и пользователей -создаёт тот же bootstrap. В сериях трека 1 предел соединений PostgreSQL -(`max_connections`) — параметр конфигурации серии, по умолчанию 100, как -у образа. Схема БД SHALL применяться миграциями до наполнения. +создаёт тот же bootstrap. В профиле сверки к аргументам S3 добавляется +порт метрик шлюза: он слушает только loopback контейнера S3, и по нему +оркестратор считает запросы к S3. В сериях трека 1 предел соединений +PostgreSQL (`max_connections`) — параметр конфигурации серии, по +умолчанию 100, как у образа. Схема БД SHALL применяться миграциями до +наполнения. Лимиты SHALL быть одинаковыми во всех прогонах профиля, а в серии трека 1 — во всех прогонах одной конфигурации: - у каждой реплики приложения — лимит CPU и памяти без swap, заданный методикой (в профилях лабы 2 — 1 CPU и 2 ГБ, в серии трека 1 — по конфигурации); -- у LB, PostgreSQL, Valkey и S3 — свои лимиты CPU и памяти без swap, - заданные методикой; в серии трека 1 они одинаковы во всех - конфигурациях; +- у LB, PostgreSQL, Valkey, S3 и уборщика — свои лимиты CPU и памяти без + swap, заданные методикой; в серии трека 1 они одинаковы во всех + конфигурациях; у уборщика в управляемом опыте профиля сверки — другой + лимит CPU, тоже заданный методикой; - у генератора нагрузки в профилях трека 1 — лимит CPU и памяти без swap, заданный методикой; в остальных профилях генератор без лимита. @@ -166,6 +171,14 @@ docker-сети и обращаться к приложению через LB п и лимитами, bootstrap завершился успешно, а образ и лимиты S3 и ограничение буфера приёма реплики записаны в паспорт +#### Scenario: S3 и уборщик в профиле сверки + +- **WHEN** запускается профиль сверки +- **THEN** S3 стенда запущен из образа рабочего стенда с его аргументами + и портом метрик только на loopback своего контейнера, bootstrap + завершился успешно, а аргументы S3, образы и лимиты S3 и уборщика + записаны в паспорт + ### Requirement: Сценарии нагрузки Стенд SHALL поддерживать два сценария с синтетическими данными @@ -1946,3 +1959,160 @@ bootstrap между прогонами. К bucket и объектам он не - **WHEN** проверяющий открывает раздел загрузок в `REPORT.md` - **THEN** у каждой гипотезы есть вывод со ссылкой на ячейки сводки метки, а числа совпадают со сводкой + +### Requirement: Профиль сверки + +Команда `make bench_reconcile` (метка `RECONCILE_LABEL`, по умолчанию +`baseline`) SHALL на свежем стенде мерить стоимость прохода сверки +bucket и БД (capability `storage-consistency`). Команда `make +bench_reconcile_quick` — то же на малом наборе и одним повтором, метка +`quick-reconcile-…`, в git не идёт. Результаты SHALL сохраняться в +`evidence/reconcile/<метка>/`. Занятая метка SHALL давать отказ до +запуска стенда. + +Стенд — LB, две реплики, PostgreSQL, Valkey и S3 с лимитами рабочего +стенда (требование «Фиксированный стенд»). Проход сверки — разовый +процесс уборщика из образа приложения с лимитами рабочего стенда +(0,25 CPU, 256 МБ без swap), в управляемом опыте — с 1 CPU. Grace +проходов — короткий, заданный методикой, но больше границы живой +загрузки (capability `service-configuration`, «Параметры уборщика»). + +Данные — синтетические вложения одного чата: +- 10 000, 30 000 и 100 000 объектов по 4 KiB — один набор, который + растёт между этапами; +- 1 000 объектов по 1 MiB — на отдельном стенде, для цены чтения байтов. + +Расхождения SHALL вноситься при наполнении, по 0,25 % от числа объектов +каждого класса: объект без метаданных, метаданные без объекта, другой +размер, зависшая загрузка. Класс объекта SHALL определяться его номером, +а содержимое — номером и зерном методики. + +Граница чёрного ящика: +- пользователи и чат создаются через API; +- метаданные вложений оркестратор пишет в PostgreSQL стенда, объекты — + прямой записью в S3 стенда ключами пользователя API; +- проход сверки — процесс уборщика из образа приложения, его результат — + журнал этого процесса; +- фоновая нагрузка — генератор по HTTP через LB; +- сверх этого оркестратор читает счётчики cgroup контейнеров, метрики + шлюза S3 на loopback его контейнера и счётчики PostgreSQL. + +Приложение оркестратор не импортирует. + +Проходы: +- без фоновой нагрузки и без предела скорости: + - стратегия по умолчанию на всех размерах набора; + - стратегия HEAD на 10 000 и 30 000 объектов; + - глубокая сверка на 10 000 объектов по 4 KiB и на объектах по 1 MiB; + - глубокая сверка с уборщиком 1 CPU на объектах по 1 MiB; +- с фоновой нагрузкой, на 100 000 объектов, стратегия по умолчанию: + - лимит CPU рабочего стенда с пределом скорости по умолчанию и без + предела; + - 1 CPU без предела и с пределом по умолчанию. + + Фоновая нагрузка идёт с постоянной интенсивностью, заданной методикой: + скачивания вложений набора, запись сообщений и чтение истории. До и + после каждого прохода — окна без прохода; +- отказ по пределу: `--apply` с пределом изменений 100, когда + кандидатов 1 000 и 10 000, — на образе до change и на образе текущего + checkout. + +Каждый проход повторяется три раза, повторы одной ячейки не идут подряд. +Варианты сравниваются внутри одной метки, на одних данных и в одной +сессии хоста. Шум — разброс повторов ячейки, а у проходов с фоновой +нагрузкой ещё отношение p95 окон до и после прохода (A/A). + +Для каждого прохода SHALL сохраняться: +- итог прохода из журнала уборщика — длительность и длительность шагов, + просмотренные объекты и строки, найденные расхождения по классам, + затронутые объекты S3, запросы к S3 по операциям, прочитанные байты, + сеансы с PostgreSQL, неперепроверенные кандидаты, код выхода; +- запросы к S3 по метрикам шлюза и счётчики PostgreSQL за проход; +- CPU уборщика, S3 и PostgreSQL за проход; +- память уборщика в начале прохода и её пик; +- у проходов с фоновой нагрузкой — по каждому сценарию в окне прохода и + в окнах до и после: число ответов, ошибки, p50, p95 и p99. + +Достоверность: +- найденные расхождения SHALL по каждому классу совпадать с внесёнными. + Иначе команда завершается ненулевым кодом: замер на неверных данных — + не результат; +- в проходах без фоновой нагрузки запросы к S3 по счётчикам сверки SHALL + совпадать с метриками шлюза, иначе проход помечается; +- ответ 5xx фоновой нагрузки — пометка прохода. + +В паспорте метки SHALL быть: +- лимиты и образы, в том числе commit варианта «до»; +- аргументы S3; +- размеры набора, размеры объектов, доли расхождений и зерно; +- grace проходов и предел скорости по умолчанию; +- фоновая нагрузка; +- версия ядра ВМ; +- состояние хоста и посторонние контейнеры. + +Сводка SHALL давать по каждой ячейке медиану и разброс повторов, вывод +по каждой гипотезе (требование «Стоимость сверки в отчёте») и графики: +длительность и запросы прохода от размера набора по стратегиям, p95 +фоновой нагрузки по вариантам. + +#### Scenario: Полный профиль сверки + +- **WHEN** выполнен `make bench_reconcile` +- **THEN** в `evidence/reconcile/<метка>/` есть паспорт, таблица проходов + со всеми ячейками по три повтора, таблица окон фоновой нагрузки, + сводка с выводами по гипотезам и графики, код выхода 0 + +#### Scenario: Быстрый профиль сверки + +- **WHEN** выполнен `make bench_reconcile_quick` +- **THEN** за несколько минут проходят все виды проходов на малом наборе + по одному повтору, код выхода 0, каталог метки в git не попадает + +#### Scenario: Найдено не то, что внесено + +- **WHEN** проход нашёл в каком-то классе не столько расхождений, + сколько внесено +- **THEN** команда завершается ненулевым кодом, называет класс, ячейку и + оба числа и удаляет стенд + +#### Scenario: Счётчики сверки и метрики S3 + +- **WHEN** завершён проход без фоновой нагрузки +- **THEN** в строке прохода запросы к S3 по счётчикам сверки равны + запросам по метрикам шлюза, а при различии строка помечена + +### Requirement: Стоимость сверки в отчёте + +`REPORT.md` SHALL содержать по профилю сверки: +- гипотезы и ожидание, записанные и зафиксированные commit до первого + прохода метки: + - о линейности прохода; + - о цене стратегии HEAD; + - о цене глубокой сверки; + - о влиянии на фоновую нагрузку с порогом p95; + - ожидаемую цену отказа по пределу; +- методику: стенд, лимиты, данные и граница наполнения, ячейки, фоновую + нагрузку, повторы и A/A; +- таблицы результатов метки по ячейкам: + - длительность и цена на объект; + - запросы к S3 и PostgreSQL, байты, CPU и память; + - p95 фоновой нагрузки по вариантам; + - цена отказа по пределу до и после change; +- выводы по каждой гипотезе, обоснование предела скорости по умолчанию + и рекомендации для стратегии HEAD и глубокой сверки; +- ограничения: один хост, ВМ Docker Desktop, генератор на том же хосте, + одна нода S3, синтетические объекты двух размеров. + +Числа в отчёт SHALL переноситься из сводки метки, а не пересчитываться +вручную. + +#### Scenario: Гипотезы сверки до прогонов + +- **WHEN** проверяющий смотрит историю `REPORT.md` и каталога метки +- **THEN** commit с гипотезами раньше commit с результатами метки + +#### Scenario: Выводы по метке сверки + +- **WHEN** проверяющий открывает раздел стоимости сверки в `REPORT.md` +- **THEN** у каждой гипотезы есть вывод со ссылкой на ячейки сводки + метки, а числа совпадают со сводкой diff --git a/openspec/specs/service-configuration/spec.md b/openspec/specs/service-configuration/spec.md index 06f27092..dfdc4abf 100644 --- a/openspec/specs/service-configuration/spec.md +++ b/openspec/specs/service-configuration/spec.md @@ -473,30 +473,36 @@ grace SHALL быть описаны в `REPORT.md`. - `page_size` — сколько ключей сверка берёт одной страницей списка S3 и сколько строк одним запросом к PostgreSQL, по умолчанию 1000, не больше 1000; -- `max_changes` — предел изменений за проход, по умолчанию 100. +- `max_changes` — предел изменений за проход, по умолчанию 100; +- `max_objects_per_second` — предел скорости прохода: сколько объектов + S3 он затрагивает в секунду (capability `storage-consistency`, + «Скорость сверки»), по умолчанию 2000; 0 — без ограничения. -`interval_seconds` SHALL быть неотрицательным числом, `page_size` и -`max_changes` — целыми не меньше 1. Иначе уборщик MUST NOT стартовать -(требование «Некорректное значение останавливает запуск»). +`interval_seconds` и `max_objects_per_second` SHALL быть +неотрицательными числами, `page_size` и `max_changes` — целыми не меньше +1. Иначе уборщик MUST NOT стартовать (требование «Некорректное значение +останавливает запуск»). Отдельного grace у сверки нет: она берёт `[cleaner] pending_grace_seconds` и его проверку границы живой загрузки (требование «Параметры уборщика»). Разовая подмена SHALL работать через окружение `RECONCILER__*` без правки файлов. Разовый проход SHALL -принимать предел изменений и аргументом команды. Значения по умолчанию -и их обоснование SHALL быть описаны в `REPORT.md`. Реплики API секцию -`[reconciler]` не используют. +принимать предел изменений и предел скорости и аргументами команды. +Значения по умолчанию и их обоснование SHALL быть описаны в +`REPORT.md`. Реплики API секцию `[reconciler]` не используют. #### Scenario: Параметры сверки по умолчанию - **WHEN** уборщик запущен без секции `[reconciler]` и без переменных `RECONCILER__*` - **THEN** запись о его старте называет интервал сверки 3600 с, - страницу 1000 и предел изменений 100 + страницу 1000, предел изменений 100 и предел скорости 2000 объектов в + секунду #### Scenario: Неверный параметр сверки - **WHEN** уборщик запускается с `RECONCILER__PAGE_SIZE=5000`, - `RECONCILER__MAX_CHANGES=0` или `RECONCILER__INTERVAL_SECONDS=-1` + `RECONCILER__MAX_CHANGES=0`, `RECONCILER__INTERVAL_SECONDS=-1` или + `RECONCILER__MAX_OBJECTS_PER_SECOND=-1` - **THEN** уборщик не стартует, в журнале — ошибка проверки настроек с именем поля diff --git a/openspec/specs/service-logging/spec.md b/openspec/specs/service-logging/spec.md index 89e81836..6a26ce0b 100644 --- a/openspec/specs/service-logging/spec.md +++ b/openspec/specs/service-logging/spec.md @@ -180,16 +180,24 @@ traceback и `request_id` запроса. журнал процесса уборщика JSON-записи в формате этой capability, в каждой — `instance_id` процесса. Записи: - запись о старте уборщика дополнительно называет интервал сверки, - размер страницы и предел изменений; + размер страницы, предел изменений и предел скорости, а у разового + прохода — ещё стратегию обхода и глубину; - каждое найденное расхождение — класс, ключ объекта, `id` вложения, если он известен, возраст, размеры объекта и метаданных, если они разные. Уровень `warning`, если расхождение осталось, и `info`, если проход с `--apply` его исправил, с названием действия; -- итог прохода — режим, сколько объектов и строк просмотрено, сколько - найдено и исправлено по классам, сколько свежих и уже помеченных, - длительность и причина прерывания. Уровень `info`, если расхождений не - осталось, иначе `warning`; -- превышение предела изменений — `error` с числом изменений и пределом; +- итог прохода — режим, стратегия, глубина, предел скорости, сколько + объектов и строк просмотрено, сколько найдено и исправлено по классам, + сколько свежих и уже помеченных, сколько кандидатов не перепроверено, + длительность и причина прерывания. Ещё итог называет стоимость + прохода: сколько объектов S3 он затронул, запросы к S3 по операциям + (список, запрос метаданных, чтение, удаление), сколько байтов объектов + прочитано, сколько было сеансов с PostgreSQL и длительность каждого + шага прохода. Уровень `info`, если расхождений не осталось, иначе + `warning`; +- превышение предела изменений — `error` с пределом, числом + подтверждённых изменений и числом кандидатов, которых проход не + перепроверял; - отказ S3 или PostgreSQL — `warning`, непредвиденная ошибка — `error` с traceback. @@ -198,7 +206,8 @@ traceback и `request_id` запроса. записи. Скачивание потерянного оригинала реплика API SHALL писать записью уровня `info` с `id` вложения и ключом объекта, а не `error`. Записи сверки MUST NOT содержать ключи доступа и секреты S3, ключ -подписи, подписи запросов, `filename` вложений и байты объектов. +подписи, подписи запросов, `filename` вложений, байты объектов и их +SHA-256. #### Scenario: Журнал разового прохода @@ -214,5 +223,14 @@ traceback и `request_id` запроса. #### Scenario: Предел изменений в журнале - **WHEN** сверка с `--apply` отказывается исправлять из-за предела -- **THEN** в журнале запись `error` с числом изменений и пределом, а - итог прохода — `warning` +- **THEN** в журнале запись `error` с пределом, числом подтверждённых + изменений и числом неперепроверенных кандидатов, а итог прохода — + `warning` + +#### Scenario: Стоимость прохода в итоге + +- **WHEN** выполняется разовая сверка с `--strategy head` и `--deep` +- **THEN** итог называет эту стратегию, глубину и предел скорости, + затронутые объекты S3, запросы к S3 по операциям, прочитанные байты, + сеансы с PostgreSQL и длительность каждого шага, а секретов S3, + `filename` и SHA-256 объектов в журнале нет diff --git a/openspec/specs/storage-consistency/spec.md b/openspec/specs/storage-consistency/spec.md index c2f1bbbe..ae6cdae5 100644 --- a/openspec/specs/storage-consistency/spec.md +++ b/openspec/specs/storage-consistency/spec.md @@ -9,10 +9,10 @@ - поведение уборщика при отказах хранилищ; - сверка bucket и БД (трек 2, change `track2-reconciler`): классы расхождений, разовый и плановый проход, правила безопасности, предел - изменений, потерянный оригинал и отказы хранилищ во время сверки. - -Стоимость обхода и стратегии сверки описывает change -`track2-reconcile-cost`. + изменений, потерянный оригинал и отказы хранилищ во время сверки; +- стоимость обхода (change `track2-reconcile-cost`): стратегии обхода, + глубокая сверка и класс «другой SHA-256», предел скорости, отказ по + пределу без лишних перепроверок и стоимость прохода в его итоге. ## Requirements @@ -168,7 +168,7 @@ S3 выполнил удаление уже после срока вызова. Сверка SHALL сравнивать объекты вложений в bucket — ключи с префиксом `<имя базы>/attachments/` — с метаданными вложений той же базы в -PostgreSQL и находить расхождения шести классов: +PostgreSQL и находить расхождения семи классов: - **объект без метаданных** — объект с ключом вида `<база>/attachments//original`, на который не ссылается ни одна строка и для `id` которого строки нет; @@ -176,12 +176,15 @@ PostgreSQL и находить расхождения шести классов: метаданных в bucket нет; - **другой размер** — вложение `ready`, размер объекта не равен `size_bytes`; +- **другой SHA-256** — вложение `ready`, размер объекта равен + `size_bytes`, а SHA-256 его содержимого не равен SHA-256 из + метаданных. Этот класс ищет только глубокая сверка; - **зависшая загрузка** — вложение в статусе «загружается» старше grace, то же, что убирает уборщик (требование «Уборщик незавершённых загрузок»); - **оригинал вернулся** — оригинал вложения помечен потерянным (требование «Потерянный оригинал»), а объект снова есть с тем же - размером; + размером и тем же SHA-256; - **чужой объект** — то, что сверка не меняет и оставляет оператору: - объект под префиксом вложений, ключа такого вида API не пишет; - объект с ключом вида `/original`, у строки которого другой ключ @@ -194,8 +197,8 @@ PostgreSQL и находить расхождения шести классов: плановым (требование «Плановая сверка»). Разовый проход по умолчанию SHALL ничего не менять (dry-run). С `--apply` он SHALL исправлять: - объект без метаданных — удалить объект; -- метаданные без объекта и другой размер — пометить оригинал вложения - потерянным; +- метаданные без объекта, другой размер и другой SHA-256 — пометить + оригинал вложения потерянным; - зависшую загрузку — убрать тем же порядком, что уборщик; - вернувшийся оригинал — снять пометку. @@ -203,12 +206,38 @@ SHALL ничего не менять (dry-run). С `--apply` он SHALL испр ведут к нему, — помечать или убирать: чужой объект попадает только в отчёт. +Разовый проход SHALL принимать стратегию обхода: +- по умолчанию — страницы списка объектов и одно обращение к PostgreSQL + на страницу. Ключи списка сверка запоминает, а строки `ready` + сравнивает с ними; +- `--strategy head` — для каждого объекта списка отдельное обращение к + PostgreSQL, для каждой строки `ready` — запрос метаданных её объекта в + S3. Ключей списка сверка не запоминает. + +Обе стратегии SHALL находить на одних данных одни и те же расхождения +тех же классов и подчиняться одним правилам безопасности (требование +«Безопасность сверки»). + +По умолчанию сверка поверхностная: наличие и размер объекта, байты она +не читает. С `--deep` разовый проход SHALL ещё читать каждый объект +вложения `ready` того же размера, которому больше grace, и сравнивать +SHA-256 его содержимого с метаданными. Плановая сверка глубокой не +бывает (требование «Плановая сверка»). + Отчёт SHALL называть по каждому расхождению класс, ключ объекта, `id` -вложения, если он известен, и возраст. Итог прохода SHALL называть: +вложения, если он известен, и возраст. Исключение — кандидаты, которых +проход с `--apply` не перепроверял после отказа по пределу (требование +«Безопасность сверки»): итог называет их число. Итог прохода SHALL +называть: +- стратегию, глубину и предел скорости (требование «Скорость сверки»); - сколько объектов и строк просмотрено; - сколько расхождений найдено и исправлено по классам; - сколько объектов и строк пропущено как свежие; -- сколько вложений уже помечены потерянными. +- сколько вложений уже помечены потерянными; +- сколько кандидатов не перепроверено; +- стоимость прохода: сколько объектов S3 он затронул, запросы к S3 по + операциям, сколько байтов объектов прочитано, сколько было сеансов с + PostgreSQL и сколько длился каждый шаг прохода. После успешного исправления повторный проход SHALL не находить ни одного исправимого расхождения. @@ -249,6 +278,27 @@ SHALL ничего не менять (dry-run). С `--apply` он SHALL испр - **THEN** ни одного из этих расхождений в отчёте нет, а код выхода соответствует отчёту: 0, если расхождений в нём нет +#### Scenario: Стратегия HEAD находит то же + +- **WHEN** в стенде те же расхождения, что в сценарии «Расхождения с + обеих сторон найдены», и выполняются сверка без `--apply` со + стратегией по умолчанию и с `--strategy head` +- **THEN** оба отчёта называют одни и те же расхождения тех же классов с + теми же ключами, коды выхода равны, а итог стратегии HEAD называет + больше запросов к S3 и сеансов с PostgreSQL + +#### Scenario: Другой SHA-256 находит глубокая сверка + +- **WHEN** объект готового вложения перезаписан мимо API байтами того же + размера, вложению и объекту больше grace, и выполняется сверка без + `--apply` — сначала без `--deep`, затем с `--deep` +- **THEN** поверхностная сверка это вложение расхождением не считает, а + глубокая называет его классом «другой SHA-256», и её итог называет + прочитанные байты; код выхода 3, а в PostgreSQL и в bucket ничего не + изменилось +- **AND** сверка с `--deep --apply` помечает оригинал потерянным: + скачивание — 404, метаданные — 200 + ### Requirement: Безопасность сверки Сверка MUST NOT удалять: @@ -274,7 +324,10 @@ Grace — тот же, что у уборщика (capability `service-configura нет, объект на месте и старше grace; - метаданные без объекта и другой размер — вложение по-прежнему `ready` с тем же ключом, а объекта по ключу нет или его размер другой; -- вернувшийся оригинал — пометка на месте, объект того же размера. +- другой SHA-256 — вложение по-прежнему `ready` с тем же ключом, объект + того же размера, а SHA-256 заново прочитанного содержимого другой; +- вернувшийся оригинал — пометка на месте, объект того же размера и + того же SHA-256 заново прочитанного содержимого. Не подтвердилось — действие не выполняется. Отсутствие объекта MUST NOT считаться подтверждённым, пока не проверено, что bucket на месте. Иначе @@ -283,9 +336,15 @@ Grace — тот же, что у уборщика (capability `service-configura Предел изменений: если за проход нужно удалить объекты, пометить оригиналы или снять пометки больше чем у `[reconciler] max_changes` вложений, сверка с `--apply` MUST NOT выполнять ни одно из этих -изменений. Она пишет ошибку с числом изменений и пределом и завершается -кодом 3. Разовый проход SHALL принимать больший предел аргументом. -Уборка зависших загрузок пределом не ограничена. +изменений. Как только подтверждённых таких изменений больше предела, она +SHALL перестать перепроверять остальных кандидатов этих классов: отказ +уже решён, а каждая перепроверка — обращения к PostgreSQL и S3, пока +уборка зависших загрузок ждёт. Она пишет ошибку с пределом и числом +подтверждённых изменений, которое больше предела, и завершается кодом +3. Итог называет, сколько кандидатов не перепроверено. Сверка без +`--apply` перепроверяет каждого кандидата. Разовый проход SHALL +принимать больший предел аргументом. Уборка зависших загрузок пределом +не ограничена. Сверка, уборщик и две сверки одновременно SHALL не мешать друг другу: - каждое действие безопасно повторять; @@ -326,9 +385,19 @@ NOT читать и менять. Вложение, в метаданных ко - **WHEN** расхождений, которые сверка исправила бы, больше предела, и выполняется сверка с `--apply` - **THEN** ни один объект не удалён, ни одно вложение не помечено, - ошибка называет число изменений и предел, код выхода 3 + ошибка называет предел и число подтверждённых изменений больше него, + код выхода 3 - **AND** с пределом не меньше их числа повтор исправляет все +#### Scenario: Отказ по пределу без лишних перепроверок + +- **WHEN** расхождений, которые сверка исправила бы, вдвое больше + предела, и выполняется сверка с `--apply` +- **THEN** ошибка называет предел и число подтверждённых изменений — на + одно больше предела, итог называет остальных кандидатов + неперепроверенными, ни одно вложение не помечено, код выхода 3 +- **AND** сверка без `--apply` называет каждое из этих расхождений + #### Scenario: Предел не останавливает уборку зависших - **WHEN** загрузка оборвалась между записью объекта и фиксацией `ready` @@ -371,16 +440,20 @@ NOT читать и менять. Вложение, в метаданных ко ### Requirement: Потерянный оригинал -Если сверка подтвердила, что объекта готового вложения нет или его -размер другой, она SHALL пометить оригинал вложения потерянным и -записать время пометки в метаданные. Сверка не удаляет ни метаданные, ни -ссылки сообщений, ни объект другого размера. Байты сверка не +Если сверка подтвердила, что объекта готового вложения нет, его размер +другой или — у глубокой сверки — SHA-256 его содержимого другой, она +SHALL пометить оригинал вложения потерянным и записать время пометки в +метаданные. Сверка не удаляет ни метаданные, ни ссылки сообщений, ни +объект другого размера или другого содержимого. Байты сверка не восстанавливает: их нет нигде. Что видит API для помеченного вложения — capability `attachments`, «Скачивание оригинала». Пометка MUST NOT менять поля вложения в ответах API, в том числе `status` и `updated_at`. Пометку SHALL снимать сверка с `--apply`, когда -объект по ключу вложения снова есть и его размер равен `size_bytes`. +объект по ключу вложения снова есть, его размер равен `size_bytes`, а +SHA-256 содержимого — SHA-256 из метаданных. Чтобы это проверить, сверка +читает такой объект и без `--deep`. Объект того же размера с другим +содержимым пометку MUST NOT снимать. #### Scenario: Оригинал вернулся @@ -389,6 +462,16 @@ capability `attachments`, «Скачивание оригинала». - **THEN** пометка снята, байты вложения скачиваются — 200 с тем же SHA-256, а следующий проход не находит расхождений по этому вложению +#### Scenario: Вернулся другой объект того же размера + +- **WHEN** оригинал вложения помечен потерянным, затем под его ключом + записаны другие байты того же размера, и выполняется сверка с + `--apply` +- **THEN** пометка на месте, скачивание — 404, а отчёт не называет это + вложение вернувшимся +- **AND** после записи тех же байтов, что были загружены, сверка с + `--apply` снимает пометку + ### Requirement: Сверка при отказах хранилищ Если S3 недоступен, не ответил за срок вызова, отказал в доступе или @@ -423,14 +506,17 @@ bucket нет, либо недоступна PostgreSQL, проход сверк разового прохода: - при старте; - затем не реже чем раз в `[reconciler] interval_seconds`; -- с пределом изменений из настроек. +- с пределом изменений и пределом скорости из настроек; +- стратегией по умолчанию и без глубокой сверки. Значение 0 выключает плановую сверку. Плановая и разовая сверки — один и тот же проход с теми же правилами безопасности. Ограничение называется в `REPORT.md`. Пока идёт проход сверки, уборка зависших загрузок ждёт его конца. Объект без метаданных на стенде живёт -не дольше суммы grace, интервала сверки и прохода. +не дольше суммы grace, интервала сверки и прохода. С пределом скорости +по умолчанию проход длится не меньше секунды на каждые 2000 затронутых +объектов S3 (требование «Скорость сверки»). #### Scenario: Плановая сверка без команды @@ -438,3 +524,36 @@ bucket нет, либо недоступна PostgreSQL, проход сверк работает с коротким интервалом сверки - **THEN** не позже интервала с запасом вложение помечено потерянным без разового прохода, а в журнале уборщика есть итог сверки + +### Requirement: Скорость сверки + +Проход сверки SHALL в среднем от своего начала затрагивать не больше +`[reconciler] max_objects_per_second` объектов S3 в секунду. Одним +объектом считаются каждый ключ страницы списка, запрос метаданных +объекта, чтение и удаление объекта. Обгоняя предел, проход ждёт, и +ожидание MUST NOT задерживать остановку по сигналу (capability +`graceful-shutdown`, «Остановка уборщика»). Значение 0 — без +ограничения. + +Разовый проход SHALL принимать предел аргументом, плановая сверка берёт +его из настроек. Обращения к PostgreSQL предел не ограничивает. +Найденные расхождения, исправления, правила безопасности и код выхода +от предела MUST NOT зависеть. + +Как выбран предел по умолчанию и какой предел нужен стратегии HEAD и +глубокой сверке, SHALL быть описано в `REPORT.md` по замеру профиля +сверки (capability `load-benchmark`, «Профиль сверки»). + +#### Scenario: Скорость прохода ограничена + +- **WHEN** выполняется сверка без `--apply` с пределом скорости, при + котором проход затрагивает объектов S3 на несколько секунд +- **THEN** проход длится не меньше, чем число затронутых объектов S3 из + итога, делённое на предел, а отчёт называет те же расхождения и код + выхода тот же, что у прохода без предела + +#### Scenario: Без ограничения скорости + +- **WHEN** тот же проход выполняется с пределом 0 +- **THEN** он не ждёт: проход короче, чем с пределом, а итог называет + предел 0 diff --git a/openspec/specs/student-tests/spec.md b/openspec/specs/student-tests/spec.md index 5913e7d0..fca57f9e 100644 --- a/openspec/specs/student-tests/spec.md +++ b/openspec/specs/student-tests/spec.md @@ -418,7 +418,8 @@ Hook стенда отказов SHALL уметь: - удалить метаданные вложения, изменить в них размер и сдвинуть их время в прошлое; - выполнить разовую сверку — без изменений или с `--apply`, с заданным - пределом изменений — и вернуть её записи и код выхода; + пределом изменений, стратегией обхода, глубиной и пределом скорости — + и вернуть её записи и код выхода; - остановить и запустить уборщика стенда, а также запустить отдельного уборщика с коротким интервалом плановой сверки на заданное время и вернуть его журнал. diff --git a/src/cleaner/__main__.py b/src/cleaner/__main__.py index 8c0ff711..45b57121 100644 --- a/src/cleaner/__main__.py +++ b/src/cleaner/__main__.py @@ -30,4 +30,14 @@ if __name__ == "__main__": ) sys.exit(2) - sys.exit(main()) + code = main() + # engine и клиент S3 закрыты, «Stopped cleaner» записан: выход без + # финализации интерпретатора. При 0,25 CPU она длится 0,8–1,5 с (модули + # botocore, SQLAlchemy), и остановка по сигналу во время паузы предела + # скорости не укладывалась бы в секунду (design change + # track2-reconcile-cost, «Уточнения apply», п. 14) + import os + + sys.stdout.flush() + sys.stderr.flush() + os._exit(code) diff --git a/src/cleaner/main.py b/src/cleaner/main.py index a887d03d..adee821f 100644 --- a/src/cleaner/main.py +++ b/src/cleaner/main.py @@ -1,8 +1,10 @@ """Уборщик незавершённых загрузок и сверка bucket и БД. `python -m src.cleaner [--once]` — сервис уборки; `python -m src.cleaner -reconcile [--apply] [--max-changes N]` — разовая сверка, по умолчанию -dry-run (design change `track2-reconciler`, решение 1). +reconcile [--apply] [--max-changes N] [--strategy batch|head] [--deep] +[--max-objects-per-second R]` — разовая сверка, по умолчанию dry-run +(design change `track2-reconciler`, решение 1; стратегия, глубина и +предел скорости — design change `track2-reconcile-cost`, решения 4–6). Отдельный процесс стенда, а не задача реплик API (design change `upload-consistency`, решения 2, 4, 5). Свои engine (пул из @@ -23,6 +25,7 @@ dry-run (design change `track2-reconciler`, решение 1). import argparse import asyncio +import math import signal from contextlib import AbstractAsyncContextManager, suppress from datetime import timedelta @@ -42,6 +45,7 @@ from src.infra.db.scope import session_scope from src.infra.logger import AbstractLogger, get_logger from src.infra.s3 import create_object_storage from src.schemas import dataclasses +from src.schemas.enums import ReconcileStrategy from src.utils.utc import utcnow logger: AbstractLogger = get_logger().bind(module="cleaner") @@ -77,6 +81,16 @@ def _positive_int(value: str) -> int: return number +def _non_negative_float(value: str) -> float: + try: + number = float(value) + except ValueError: + raise argparse.ArgumentTypeError("must be a number") from None + if not math.isfinite(number) or number < 0: + raise argparse.ArgumentTypeError("must be a non-negative number") + return number + + def _parse_args(argv: list[str] | None) -> argparse.Namespace: parser = argparse.ArgumentParser( prog="python -m src.cleaner", @@ -105,6 +119,25 @@ def _parse_args(argv: list[str] | None) -> argparse.Namespace: default=None, help="change limit of the pass (default: [reconciler] max_changes)", ) + reconcile.add_argument( + "--strategy", + choices=[item.value for item in ReconcileStrategy], + default=ReconcileStrategy.BATCH.value, + help="batch: list pages and one database query per page; head: a " + "database query per object and HEAD per ready row", + ) + reconcile.add_argument( + "--deep", + action="store_true", + help="read objects and compare their SHA-256 with the metadata", + ) + reconcile.add_argument( + "--max-objects-per-second", + type=_non_negative_float, + default=None, + help="S3 objects per second, 0 - no limit " + "(default: [reconciler] max_objects_per_second)", + ) return parser.parse_args(argv) @@ -115,11 +148,10 @@ def main(argv: list[str] | None = None) -> int: run( mode=MODE_RECONCILE, apply=args.apply, - max_changes=( - settings.reconciler.max_changes - if args.max_changes is None - else args.max_changes - ), + max_changes=args.max_changes, + strategy=ReconcileStrategy(args.strategy), + deep=args.deep, + max_objects_per_second=args.max_objects_per_second, ), ) return asyncio.run(run(mode=MODE_ONCE if args.once else MODE_SERVICE)) @@ -130,12 +162,24 @@ async def run( mode: str, apply: bool = True, max_changes: int | None = None, + strategy: ReconcileStrategy = ReconcileStrategy.BATCH, + deep: bool = False, + max_objects_per_second: float | None = None, ) -> int: """Проверка grace, затем проходы уборки до сигнала (или один с - `--once`) с плановой сверкой — или одна разовая сверка.""" + `--once`) с плановой сверкой — или одна разовая сверка. Стратегия и + глубина — только у разовой сверки; плановая — `batch`, поверхностная, + предел скорости из настроек (design change `track2-reconcile-cost`, + решения 4–6).""" cleaner = settings.cleaner reconciler = settings.reconciler limit = reconciler.max_changes if max_changes is None else max_changes + rate = ( + reconciler.max_objects_per_second + if max_objects_per_second is None + else max_objects_per_second + ) + once_pass = mode == MODE_RECONCILE bound = live_upload_bound_seconds(settings) if cleaner.pending_grace_seconds <= bound: # до engine и клиента S3: ни одного обращения к хранилищам @@ -193,7 +237,10 @@ async def run( reconcile_interval_seconds=reconciler.interval_seconds, reconcile_page_size=reconciler.page_size, reconcile_max_changes=limit, - reconcile_apply=apply if mode == MODE_RECONCILE else None, + reconcile_max_objects_per_second=rate, + reconcile_apply=apply if once_pass else None, + reconcile_strategy=strategy.value if once_pass else None, + reconcile_deep=deep if once_pass else None, database_host=settings.database.host, database_port=settings.database.port, database_name=settings.database.name, @@ -207,6 +254,9 @@ async def run( reconcile, apply=apply, max_changes=limit, + strategy=strategy, + deep=deep, + max_objects_per_second=rate, stop=stop, ) exit_code = _reconcile_exit_code(result) @@ -255,10 +305,17 @@ async def _serve( pause = cleaner.interval_seconds if next_reconcile is not None and not stop.is_set(): if loop.time() >= next_reconcile: + # плановая — стратегия по умолчанию, поверхностная, пределы + # из настроек await _reconcile_once( reconcile, apply=True, max_changes=settings.reconciler.max_changes, + strategy=ReconcileStrategy.BATCH, + deep=False, + max_objects_per_second=( + settings.reconciler.max_objects_per_second + ), stop=stop, ) next_reconcile = loop.time() + interval @@ -296,6 +353,9 @@ async def _reconcile_once( *, apply: bool, max_changes: int, + strategy: ReconcileStrategy, + deep: bool, + max_objects_per_second: float, stop: asyncio.Event, ) -> dataclasses.ReconcilePassDTO | None: """Проход сверки; `None` — непредвиденная ошибка: `error` с @@ -310,6 +370,9 @@ async def _reconcile_once( max_changes=max_changes, page_size=settings.reconciler.page_size, batch_size=settings.cleaner.batch_size, + strategy=strategy, + deep=deep, + max_objects_per_second=max_objects_per_second, stop_requested=stop.is_set, ) except Exception as e: diff --git a/src/config/settings.py b/src/config/settings.py index 672c538a..0be6b427 100644 --- a/src/config/settings.py +++ b/src/config/settings.py @@ -280,6 +280,10 @@ class Reconciler(BaseModel): page_size: int = Field(default=1000, ge=1, le=1000) # предел изменений за проход: больше — ни одного изменения и код 3 max_changes: int = Field(default=100, ge=1) + # предел скорости прохода: объектов S3 в секунду в среднем от начала + # прохода (ключи страниц списка, HEAD, GET, DELETE); 0 — без предела + # (design change `track2-reconcile-cost`, решение 6) + max_objects_per_second: float = Field(default=2000.0, ge=0) class Settings(BaseSettings): diff --git a/src/core/services/attachment_reconcile.py b/src/core/services/attachment_reconcile.py index 92ee3c27..0773c5fe 100644 --- a/src/core/services/attachment_reconcile.py +++ b/src/core/services/attachment_reconcile.py @@ -1,21 +1,32 @@ """Сверка bucket и БД (design change `track2-reconciler`, решения 3, 4, 7 -и 8). +и 8; стоимость, стратегии и глубина — design change +`track2-reconcile-cost`, решения 4–8). Сервис процесса уборщика (`src/cleaner/`), а не реплик API. Проход: -1. S3 → БД: страницы списка объектов под `<база>/attachments/`, на - страницу — одно выражение к БД по `id` из стандартных ключей и по - тексту нестандартных; каждый ключ — в множество `seen`; -2. БД → S3: keyset строк `ready` по `id`, ключа нет в `seen` — кандидат - «метаданные без объекта»; +1. S3 → БД: страницы списка объектов под `<база>/attachments/`. Стратегия + `batch` — на страницу одно выражение к БД по `id` из стандартных ключей + и по тексту нестандартных, каждый ключ — в множество `seen`; стратегия + `head` — своя выборка строки на объект, множества нет, объект строки с + тем же ключом проверяет шаг 2; +2. БД → S3: keyset строк `ready` по `id`. `batch` — ключа нет в `seen`, + кандидат «метаданные без объекта»; `head` — HEAD объекта каждой строки + своей базы; 3. зависшие загрузки — кандидаты уборщика (`get_stale_pending`); -4. перепроверка каждого кандидата в БД и HEAD перед решением, в обоих +4. перепроверка каждого кандидата в БД и S3 перед решением, в обоих режимах; отсутствие объекта — только после проверки, что bucket на - месте; + месте. С `apply`, как только подтверждённых изменений под пределом + больше `max_changes`, остальные кандидаты этих классов не + перепроверяются: отказ уже решён (`unchecked`); 5. предел изменений, затем, с `apply`, действия по порядку: зависшие загрузки (процедурой уборщика) → объекты без метаданных → пометки потерянных → снятия пометок. Каждое действие перед собой ещё раз перепроверяет своё условие. +Глубокая сверка (`deep`) читает объект строки `ready` того же размера и +сравнивает SHA-256 содержимого с метаданными: класс «другой SHA-256». +«Оригинал вернулся» подтверждается тем же SHA-256 в любом режиме: +перепроверка и действие читают объект. + Удаляется только объект без строки и зависшая загрузка; строки `ready`, объекты, на которые ссылается строка, и чужие ключи — никогда. Строка с ключом вне префикса вложений своей базы — чужой объект: её объект сверка @@ -23,16 +34,28 @@ прерывает проход без единого изменения, на шаге 5 — после текущего действия; каждое действие безопасно повторять. Сигнал проверяется перед каждым вызовом хранилища: остановка ждёт не больше одного вызова. + +Предел скорости (`max_objects_per_second`, 0 — без него): после каждого +вызова S3 проход ждёт, пока затронутых объектов (ключи страниц списка, +HEAD, GET, DELETE — по счётчикам клиента S3) не станет не больше предела, +умноженного на время с начала прохода. Ждёт кусками с проверкой сигнала. +Итог называет стоимость прохода: затронутые объекты, вызовы S3 по +операциям, прочитанные байты, сеансы с PostgreSQL и длительность шагов. """ +import asyncio +import hashlib import time from collections import Counter -from collections.abc import Callable -from dataclasses import replace +from collections.abc import Callable, Iterator +from contextlib import AbstractAsyncContextManager, contextmanager +from dataclasses import dataclass, replace from datetime import datetime from types import MappingProxyType from uuid import UUID +from sqlalchemy.ext.asyncio import AsyncSession + from src.core import exceptions from src.core.repos import attachment as attachment_repo from src.core.repos import attachment_object as attachment_object_repo @@ -44,14 +67,23 @@ from src.core.services.attachment_cleanup import ( AttachmentCleanupService, ) from src.infra.logger import AbstractLogger, get_logger -from src.infra.s3 import ObjectStorage, StoredObjectInfo +from src.infra.s3 import ( + ObjectStorage, + StorageStats, + StoredObjectInfo, + StoredObjectPage, +) from src.schemas import dataclasses from src.schemas.enums import ( AttachmentStatus, ReconcileAction, ReconcileFinding, + ReconcileStrategy, +) +from src.utils.constants import ( + RECONCILE_FINDINGS_LOGGED_MAX, + RECONCILE_PACE_STEP_SECONDS, ) -from src.utils.constants import RECONCILE_FINDINGS_LOGGED_MAX from src.utils.utc import utcnow logger: AbstractLogger = get_logger().bind( @@ -64,6 +96,7 @@ LIMITED_KINDS = frozenset( ReconcileFinding.ORPHAN_OBJECT, ReconcileFinding.MISSING_OBJECT, ReconcileFinding.SIZE_MISMATCH, + ReconcileFinding.CHECKSUM_MISMATCH, ReconcileFinding.RESTORED_OBJECT, }, ) @@ -73,12 +106,25 @@ ACTION_ORDER = ( ReconcileFinding.ORPHAN_OBJECT, ReconcileFinding.MISSING_OBJECT, ReconcileFinding.SIZE_MISMATCH, + ReconcileFinding.CHECKSUM_MISMATCH, ReconcileFinding.RESTORED_OBJECT, ) -# классы, у которых отсутствие объекта подтверждается: сначала — bucket +# классы, у которых отсутствие объекта подтверждается: сначала — bucket; +# у «другого SHA-256» объект есть NEEDS_BUCKET = frozenset( {ReconcileFinding.MISSING_OBJECT, ReconcileFinding.SIZE_MISMATCH}, ) +# классы, которые подтверждает прочитанный объект, а не HEAD +NEEDS_READ = frozenset( + {ReconcileFinding.CHECKSUM_MISMATCH, ReconcileFinding.RESTORED_OBJECT}, +) +# шаги прохода в `phase_ms` итога — постоянные ключи +PHASES = ("list", "rows", "stale", "recheck", "act") +# операции S3 в `s3_requests` итога — постоянные ключи +S3_OPERATIONS = ("list", "head", "get", "delete") +# операции, у которых каждый вызов затрагивает один объект; у списка — +# каждый ключ страницы +OBJECT_OPERATIONS = ("head", "get", "delete") def _never() -> bool: @@ -90,20 +136,49 @@ def _age_seconds(moment: datetime, *, now: datetime) -> int: class _Stopped(Exception): - """Сигнал остановки между страницами или действиями.""" + """Сигнал остановки между вызовами хранилища или во время паузы.""" + + +@dataclass(frozen=True, slots=True) +class _ReadObject: + """Прочитанный объект: метаданные GET и SHA-256 содержимого; `sha256` + — `None`, если тело не читалось (другой размер или свежий объект).""" + + info: StoredObjectInfo + sha256: bytes | None class _Pass: - """Счётчики и находки одного прохода.""" + """Параметры, счётчики и находки одного прохода.""" - def __init__(self, *, apply: bool, now: datetime) -> None: + def __init__( + self, + *, + apply: bool, + strategy: ReconcileStrategy, + deep: bool, + max_objects_per_second: float, + older_than: datetime, + stop_requested: Callable[[], bool], + stats: StorageStats, + db_sessions: int, + ) -> None: self.apply = apply - self.now = now + self.strategy = strategy + self.deep = deep + self.rate = max_objects_per_second + self.older_than = older_than + self.stop_requested = stop_requested + self.now = utcnow() + self.started = time.monotonic() + self.stats_start = stats + self.db_sessions_start = db_sessions self.listed_objects = 0 self.checked_rows = 0 self.fresh_objects = 0 self.fresh_rows = 0 self.lost_known = 0 + self.unchecked = 0 self.seen: set[str] = set() self.candidates: list[dataclasses.ReconcileFindingDTO] = [] self.confirmed: list[dataclasses.ReconcileFindingDTO] = [] @@ -113,10 +188,25 @@ class _Pass: self.refused = False self.logged = 0 self.unlogged = 0 + self.phase_ms: dict[str, int] = dict.fromkeys(PHASES, 0) def age(self, moment: datetime) -> int: return _age_seconds(moment, now=self.now) + def check_stop(self) -> None: + """Перед вызовом хранилища: сигнал пришёл — проход + останавливается, и остановка ждёт не больше одного вызова.""" + if self.stop_requested(): + raise _Stopped + + @contextmanager + def phase(self, name: str) -> Iterator[None]: + started = time.monotonic() + try: + yield + finally: + self.phase_ms[name] += round((time.monotonic() - started) * 1000) + class AttachmentReconcileService: """Сверка объектов вложений своей базы с их метаданными. @@ -124,17 +214,24 @@ class AttachmentReconcileService: `db_scope` — фабрика короткой сессии процесса уборщика, `storage` — клиент S3 с ключами пользователя уборщика (список — только по префиксу вложений своей базы). Зависшие загрузки убирает - `AttachmentCleanupService` тем же шагом, что сервис уборки. + `AttachmentCleanupService` тем же шагом, что сервис уборки; его сеансы + с PostgreSQL входят в счёт прохода (`db_sessions`). """ def __init__(self, db_scope: DbScope, storage: ObjectStorage) -> None: - self.db_scope = db_scope + self._db_scope = db_scope self.storage = storage + self._db_sessions = 0 self.cleanup = AttachmentCleanupService( - db_scope=db_scope, + db_scope=self.db_scope, storage=storage, ) + def db_scope(self) -> AbstractAsyncContextManager[AsyncSession]: + """Сессия на шаг со счётом сеансов прохода.""" + self._db_sessions += 1 + return self._db_scope() + async def reconcile( self, *, @@ -143,53 +240,50 @@ class AttachmentReconcileService: max_changes: int, page_size: int, batch_size: int, + strategy: ReconcileStrategy = ReconcileStrategy.BATCH, + deep: bool = False, + max_objects_per_second: float = 0, stop_requested: Callable[[], bool] = _never, ) -> dataclasses.ReconcilePassDTO: """Один проход сверки; `older_than` — порог grace прохода. Без `apply` ничего не меняет. Отказ S3 или PostgreSQL прерывает проход (`interrupted_by`); сигнал (`stop_requested()`) - проверяется перед каждым вызовом S3 и шагом с БД, текущий вызов - доводится до конца: остановка ждёт не больше одного вызова (S3 — - `[s3] timeout_seconds`, шаг с БД — его срок). Отказ, пришедший уже - после сигнала, считается остановкой. + проверяется перед каждым вызовом S3 и шагом с БД и во время паузы + предела скорости, текущий вызов доводится до конца: остановка ждёт + не больше одного вызова (S3 — `[s3] timeout_seconds`, шаг с БД — + его срок). Отказ, пришедший уже после сигнала, считается + остановкой. """ - started = time.monotonic() - log = logger.bind(method="reconcile", apply=apply) - state = _Pass(apply=apply, now=utcnow()) + log = logger.bind( + method="reconcile", + apply=apply, + strategy=strategy.value, + deep=deep, + ) + state = _Pass( + apply=apply, + strategy=strategy, + deep=deep, + max_objects_per_second=max_objects_per_second, + older_than=older_than, + stop_requested=stop_requested, + stats=self.storage.stats(), + db_sessions=self._db_sessions, + ) interrupted_by: str | None = None try: - await self._list_objects( - state, - older_than=older_than, - page_size=page_size, - stop_requested=stop_requested, - ) - await self._check_rows( - state, - older_than=older_than, - page_size=page_size, - stop_requested=stop_requested, - ) - await self._stale_pending( - state, - older_than=older_than, - batch_size=batch_size, - stop_requested=stop_requested, - ) - await self._recheck_all( - state, - older_than=older_than, - stop_requested=stop_requested, - ) + with state.phase("list"): + await self._list_objects(state, page_size=page_size) + with state.phase("rows"): + await self._check_rows(state, page_size=page_size) + with state.phase("stale"): + await self._stale_pending(state, batch_size=batch_size) + with state.phase("recheck"): + await self._recheck_all(state, max_changes=max_changes) if apply: - await self._act( - state, - older_than=older_than, - max_changes=max_changes, - stop_requested=stop_requested, - log=log, - ) + with state.phase("act"): + await self._act(state, max_changes=max_changes, log=log) except _Stopped: interrupted_by = INTERRUPTED_BY_STOP except exceptions.ObjectStorageUnavailable: @@ -206,32 +300,111 @@ class AttachmentReconcileService: if stop_requested() else INTERRUPTED_BY_DATABASE ) - return self._finish( - state, - interrupted_by=interrupted_by, - duration_ms=round((time.monotonic() - started) * 1000), - log=log, + return self._finish(state, interrupted_by=interrupted_by, log=log) + + # ------------------------------------------------------------ вызовы S3 + + def _touched(self, state: _Pass) -> int: + """Объекты S3, которые проход затронул: ключи страниц списка и + вызовы над объектом — разность счётчиков клиента с начала.""" + stats = self.storage.stats() + start = state.stats_start + return (stats.listed_keys - start.listed_keys) + sum( + stats.calls[name] - start.calls[name] for name in OBJECT_OPERATIONS ) - # --------------------------------------------------------- классификация + async def _pace(self, state: _Pass) -> None: + """После вызова S3: затронуто больше, чем предел × время с начала + прохода, — ждать кусками с проверкой сигнала (решение 6).""" + if state.rate <= 0: + return + while True: + due = state.started + self._touched(state) / state.rate + wait = due - time.monotonic() + if wait <= 0: + return + await asyncio.sleep(min(wait, RECONCILE_PACE_STEP_SECONDS)) + state.check_stop() - async def _list_objects( + async def _list_page( self, state: _Pass, *, - older_than: datetime, + token: str | None, page_size: int, - stop_requested: Callable[[], bool], - ) -> None: - """Шаг 1, S3 → БД: страницы списка и строки страницы одним - выражением; классификация без новых вызовов S3.""" + ) -> StoredObjectPage: + state.check_stop() + page = await attachment_object_repo.list_originals( + self.storage, + token=token, + max_keys=page_size, + ) + await self._pace(state) + return page + + async def _probe(self, state: _Pass) -> None: + state.check_stop() + await attachment_object_repo.probe_originals(self.storage) + await self._pace(state) + + async def _head(self, state: _Pass, key: str) -> StoredObjectInfo | None: + state.check_stop() + stored = await attachment_object_repo.head_original( + self.storage, + key=key, + ) + await self._pace(state) + return stored + + async def _read( + self, + state: _Pass, + key: str, + *, + size: int | None, + fresh_before: datetime | None = None, + ) -> _ReadObject | None: + """GET объекта и SHA-256 содержимого потоком (память — один блок); + `None` — объекта нет. Тело читается, только если размер равен + `size` и объект не моложе `fresh_before` (если он задан).""" + state.check_stop() + try: + async with attachment_object_repo.open_original( + self.storage, + key=key, + ) as stored: + info = stored.info + if info.size != size or ( + fresh_before is not None + and _is_fresh(info, older_than=fresh_before) + ): + result = _ReadObject(info=info, sha256=None) + else: + digest = hashlib.sha256() + async for chunk in stored.iter_chunks(): + digest.update(chunk) + result = _ReadObject(info=info, sha256=digest.digest()) + except exceptions.StoredObjectMissing: + result = None + await self._pace(state) + return result + + async def _delete(self, state: _Pass, key: str) -> None: + state.check_stop() + await attachment_object_repo.delete_original(self.storage, key=key) + await self._pace(state) + + # --------------------------------------------------------- классификация + + async def _list_objects(self, state: _Pass, *, page_size: int) -> None: + """Шаг 1, S3 → БД: страницы списка; строки — одним выражением на + страницу (`batch`) или выборкой на объект (`head`).""" token: str | None = None while True: - _check_stop(stop_requested) - page = await attachment_object_repo.list_originals( - self.storage, + page = await self._list_page( + state, token=token, - max_keys=page_size, + page_size=page_size, ) state.listed_objects += len(page.objects) parsed = { @@ -241,72 +414,138 @@ class AttachmentReconcileService: ) for item in page.objects } - ids = {value for value in parsed.values() if value is not None} - keys = {key for key, value in parsed.items() if value is None} - rows: list[dataclasses.AttachmentFullDTO] = [] - if parsed: - # страница списка уже могла ждать S3 до срока - _check_stop(stop_requested) - async with self.db_scope() as db_session: - rows = await attachment_repo.get_attachments_for_objects( - db_session=db_session, - attachment_ids=ids, - object_keys=keys, - ) - by_id = {row.id: row for row in rows} - by_key = {row.object_key: row for row in rows} - for item in page.objects: - state.seen.add(item.key) - attachment_id = parsed[item.key] - row = ( - by_id.get(attachment_id) - if attachment_id is not None - else by_key.get(item.key) - ) - if row is not None and row.object_key == item.key: - self._row_with_object( + if state.strategy == ReconcileStrategy.HEAD: + for item in page.objects: + row = await self._row_for_object( state, - row=row, - stored=item, - older_than=older_than, + key=item.key, + attachment_id=parsed[item.key], ) - continue - if _is_fresh(item, older_than=older_than): - state.fresh_objects += 1 - continue - # нет строки — объект без метаданных; строка этого id с - # другим ключом или ключ, которого API не пишет, — чужой - kind = ( - ReconcileFinding.ORPHAN_OBJECT - if attachment_id is not None and row is None - else ReconcileFinding.UNKNOWN_OBJECT - ) - state.candidates.append( - dataclasses.ReconcileFindingDTO( - kind=kind, - object_key=item.key, - attachment_id=attachment_id, - age_seconds=_object_age(state, item), - ), - ) + await self._classify_object( + state, + item, + attachment_id=parsed[item.key], + row=row, + ) + else: + await self._classify_page(state, page.objects, parsed) token = page.next_token if token is None: return - def _row_with_object( + async def _classify_page( + self, + state: _Pass, + objects: tuple[StoredObjectInfo, ...], + parsed: dict[str, UUID | None], + ) -> None: + """`batch`: строки страницы одним выражением, ключи — в `seen`.""" + ids = {value for value in parsed.values() if value is not None} + keys = {key for key, value in parsed.items() if value is None} + rows: list[dataclasses.AttachmentFullDTO] = [] + if parsed: + # страница списка уже могла ждать S3 до срока + state.check_stop() + async with self.db_scope() as db_session: + rows = await attachment_repo.get_attachments_for_objects( + db_session=db_session, + attachment_ids=ids, + object_keys=keys, + ) + by_id = {row.id: row for row in rows} + by_key = {row.object_key: row for row in rows} + for item in objects: + state.seen.add(item.key) + attachment_id = parsed[item.key] + row = ( + by_id.get(attachment_id) + if attachment_id is not None + else by_key.get(item.key) + ) + await self._classify_object( + state, + item, + attachment_id=attachment_id, + row=row, + ) + + async def _row_for_object( + self, + state: _Pass, + *, + key: str, + attachment_id: UUID | None, + ) -> dataclasses.AttachmentFullDTO | None: + """`head`: строка объекта отдельной выборкой — по `id` стандартного + ключа или по тексту нестандартного, как выражение страницы.""" + state.check_stop() + async with self.db_scope() as db_session: + rows = await attachment_repo.get_attachments_for_objects( + db_session=db_session, + attachment_ids=set() + if attachment_id is None + else { + attachment_id, + }, + object_keys={key} if attachment_id is None else set(), + ) + for row in rows: + if (attachment_id is not None and row.id == attachment_id) or ( + attachment_id is None and row.object_key == key + ): + return row + return None + + async def _classify_object( + self, + state: _Pass, + item: StoredObjectInfo, + *, + attachment_id: UUID | None, + row: dataclasses.AttachmentFullDTO | None, + ) -> None: + """Объект списка и его строка: объект без строки, чужой, свежий — + или пара «строка — объект» (у `head` её проверит шаг строк).""" + if row is not None and row.object_key == item.key: + if state.strategy == ReconcileStrategy.BATCH: + await self._row_with_object(state, row=row, stored=item) + return + if _is_fresh(item, older_than=state.older_than): + state.fresh_objects += 1 + return + # нет строки — объект без метаданных; строка этого id с другим + # ключом или ключ, которого API не пишет, — чужой + kind = ( + ReconcileFinding.ORPHAN_OBJECT + if attachment_id is not None and row is None + else ReconcileFinding.UNKNOWN_OBJECT + ) + state.candidates.append( + dataclasses.ReconcileFindingDTO( + kind=kind, + object_key=item.key, + attachment_id=attachment_id, + age_seconds=_object_age(state, item), + ), + ) + + async def _row_with_object( self, state: _Pass, *, row: dataclasses.AttachmentFullDTO, stored: StoredObjectInfo, - older_than: datetime, + sha256: bytes | None = None, ) -> None: + """Строка и её объект: размер, пометка и, с `deep`, SHA-256. + `sha256` — уже прочитанное содержимое (`head` с `deep`).""" if row.status != AttachmentStatus.READY: # строка pending: объект её загрузки — дело уборщика return same_size = stored.size == row.size_bytes if row.lost_at is not None: if same_size: + # вернулся ли тот же оригинал, решает SHA-256 перепроверки state.candidates.append( _finding( ReconcileFinding.RESTORED_OBJECT, @@ -318,34 +557,55 @@ class AttachmentReconcileService: else: state.lost_known += 1 return - if same_size: + if not same_size: + if row.updated_at >= state.older_than: + state.fresh_rows += 1 + return + state.candidates.append( + _finding( + ReconcileFinding.SIZE_MISMATCH, + row, + state, + stored_size=stored.size, + ), + ) return - if row.updated_at >= older_than: + if not state.deep: + return + if row.updated_at >= state.older_than: state.fresh_rows += 1 return - state.candidates.append( - _finding( - ReconcileFinding.SIZE_MISMATCH, - row, + if _is_fresh(stored, older_than=state.older_than): + state.fresh_objects += 1 + return + if sha256 is None: + read = await self._read( state, - stored_size=stored.size, - ), - ) + row.object_key, + size=row.size_bytes, + fresh_before=state.older_than, + ) + if read is None or read.sha256 is None: + # объект исчез или изменился после списка — следующий проход + return + sha256 = read.sha256 + if sha256 != row.sha256: + state.candidates.append( + _finding( + ReconcileFinding.CHECKSUM_MISMATCH, + row, + state, + stored_size=stored.size, + ), + ) - async def _check_rows( - self, - state: _Pass, - *, - older_than: datetime, - page_size: int, - stop_requested: Callable[[], bool], - ) -> None: - """Шаг 2, БД → S3: строки `ready`, ключей которых нет в списке. - Ключ строки вне префикса вложений своей базы список не видит и - сверка не читает: чужой объект, а не метаданные без объекта.""" + async def _check_rows(self, state: _Pass, *, page_size: int) -> None: + """Шаг 2, БД → S3: строки `ready`. Ключ строки вне префикса + вложений своей базы список не видит и сверка не читает: чужой + объект, а не метаданные без объекта.""" after: UUID | None = None while True: - _check_stop(stop_requested) + state.check_stop() async with self.db_scope() as db_session: rows = await attachment_repo.get_ready_page( db_session=db_session, @@ -354,42 +614,79 @@ class AttachmentReconcileService: ) for row in rows: state.checked_rows += 1 - if row.object_key in state.seen: - continue - if row.lost_at is not None: - state.lost_known += 1 - elif row.updated_at >= older_than: - state.fresh_rows += 1 - else: - kind = ( - ReconcileFinding.MISSING_OBJECT - if self._own_key(row.object_key) - else ReconcileFinding.UNKNOWN_OBJECT - ) - state.candidates.append(_finding(kind, row, state)) + if state.strategy == ReconcileStrategy.HEAD: + await self._check_row_object(state, row) + elif row.object_key not in state.seen: + self._row_without_object(state, row) if len(rows) < page_size: return after = rows[-1].id - async def _stale_pending( + async def _check_row_object( self, state: _Pass, - *, - older_than: datetime, - batch_size: int, - stop_requested: Callable[[], bool], + row: dataclasses.AttachmentFullDTO, ) -> None: + """`head`: HEAD объекта строки своей базы; с `deep` у строки без + пометки старше grace — сразу GET.""" + if not self._own_key(row.object_key): + self._row_without_object(state, row) + return + sha256: bytes | None = None + if ( + state.deep + and row.lost_at is None + and row.updated_at < state.older_than + ): + read = await self._read( + state, + row.object_key, + size=row.size_bytes, + fresh_before=state.older_than, + ) + stored = None if read is None else read.info + sha256 = None if read is None else read.sha256 + else: + stored = await self._head(state, row.object_key) + if stored is None: + self._row_without_object(state, row) + return + await self._row_with_object( + state, + row=row, + stored=stored, + sha256=sha256, + ) + + def _row_without_object( + self, + state: _Pass, + row: dataclasses.AttachmentFullDTO, + ) -> None: + if row.lost_at is not None: + state.lost_known += 1 + elif row.updated_at >= state.older_than: + state.fresh_rows += 1 + else: + kind = ( + ReconcileFinding.MISSING_OBJECT + if self._own_key(row.object_key) + else ReconcileFinding.UNKNOWN_OBJECT + ) + state.candidates.append(_finding(kind, row, state)) + + async def _stale_pending(self, state: _Pass, *, batch_size: int) -> None: """Шаг 3: зависшие загрузки — те же кандидаты, что у уборщика. Зависшая загрузка с ключом вне префикса вложений своей базы — чужой объект: сверка её не убирает (уборка удалила бы объект по этому ключу).""" after: tuple[datetime, UUID] | None = None while True: - _check_stop(stop_requested) + state.check_stop() async with self.db_scope() as db_session: rows = await attachment_repo.get_stale_pending( db_session=db_session, - older_than=older_than, + older_than=state.older_than, after=after, limit=batch_size, ) @@ -412,36 +709,35 @@ class AttachmentReconcileService: # ---------------------------------------------------------- перепроверка - async def _recheck_all( - self, - state: _Pass, - *, - older_than: datetime, - stop_requested: Callable[[], bool], - ) -> None: + async def _recheck_all(self, state: _Pass, *, max_changes: int) -> None: """Шаг 4: каждый кандидат подтверждается в БД и S3 до решения; - не подтвердился — выбывает без записи.""" + не подтвердился — выбывает без записи. С `apply`, как только + подтверждённых изменений под пределом больше `max_changes`, + остальные кандидаты этих классов не перепроверяются (решение 7).""" if any(item.kind in NEEDS_BUCKET for item in state.candidates): - _check_stop(stop_requested) - await attachment_object_repo.probe_originals(self.storage) + await self._probe(state) + limited = 0 for candidate in state.candidates: - _check_stop(stop_requested) - confirmed = await self._recheck( - candidate, - older_than=older_than, - state=state, - stop_requested=stop_requested, - ) - if confirmed is not None: - state.confirmed.append(confirmed) + if ( + state.apply + and limited > max_changes + and candidate.kind in LIMITED_KINDS + ): + state.unchecked += 1 + continue + state.check_stop() + confirmed = await self._recheck(candidate, state=state) + if confirmed is None: + continue + state.confirmed.append(confirmed) + if confirmed.kind in LIMITED_KINDS: + limited += 1 async def _recheck( self, candidate: dataclasses.ReconcileFindingDTO, *, - older_than: datetime, state: _Pass, - stop_requested: Callable[[], bool], ) -> dataclasses.ReconcileFindingDTO | None: kind = candidate.kind if kind in ( @@ -455,24 +751,13 @@ class AttachmentReconcileService: # объект вне префикса вложений своей базы не читается return None if kind == ReconcileFinding.ORPHAN_OBJECT: - return await self._recheck_orphan( - candidate, - older_than=older_than, - state=state, - stop_requested=stop_requested, - ) - row = await self._get_row(candidate) + return await self._recheck_orphan(candidate, state=state) + row = await self._get_row(candidate, state=state) if row is None or row.status != AttachmentStatus.READY: return None - _check_stop(stop_requested) - stored = await attachment_object_repo.head_original( - self.storage, - key=candidate.object_key, - ) - if kind == ReconcileFinding.RESTORED_OBJECT: - if row.lost_at is None or stored is None: - return None - return candidate if stored.size == row.size_bytes else None + if kind in NEEDS_READ: + return await self._recheck_read(candidate, row=row, state=state) + stored = await self._head(state, candidate.object_key) if row.lost_at is not None: return None if stored is None: @@ -486,17 +771,61 @@ class AttachmentReconcileService: ) return None + async def _recheck_read( + self, + candidate: dataclasses.ReconcileFindingDTO, + *, + row: dataclasses.AttachmentFullDTO, + state: _Pass, + ) -> dataclasses.ReconcileFindingDTO | None: + """«Другой SHA-256» и «оригинал вернулся»: объект читается заново + и сравнивается с размером и SHA-256 строки.""" + read = await self._read( + state, + candidate.object_key, + size=row.size_bytes, + ) + if read is None or read.sha256 is None: + # объекта нет или размер другой: это уже другой класс, его + # найдёт следующий проход + if ( + candidate.kind == ReconcileFinding.RESTORED_OBJECT + and row.lost_at is not None + ): + state.lost_known += 1 + return None + same = read.sha256 == row.sha256 + if candidate.kind == ReconcileFinding.RESTORED_OBJECT: + if row.lost_at is None: + return None + if not same: + # тот же размер, другие байты: пометка остаётся + state.lost_known += 1 + return None + return _finding( + ReconcileFinding.RESTORED_OBJECT, + row, + state, + stored_size=read.info.size, + ) + if row.lost_at is not None or same: + return None + return _finding( + ReconcileFinding.CHECKSUM_MISMATCH, + row, + state, + stored_size=read.info.size, + ) + async def _recheck_orphan( self, candidate: dataclasses.ReconcileFindingDTO, *, - older_than: datetime, state: _Pass, - stop_requested: Callable[[], bool], ) -> dataclasses.ReconcileFindingDTO | None: """Строки с этим `id` или ключом нет, объект на месте и старше порога. Строка другого `id` ссылается на ключ — чужой объект.""" - references = await self._references(candidate) + references = await self._references(candidate, state=state) if any( row.object_key == candidate.object_key and row.id != candidate.attachment_id @@ -505,21 +834,20 @@ class AttachmentReconcileService: return replace(candidate, kind=ReconcileFinding.UNKNOWN_OBJECT) if references: return None - _check_stop(stop_requested) - stored = await attachment_object_repo.head_original( - self.storage, - key=candidate.object_key, - ) - if stored is None or _is_fresh(stored, older_than=older_than): + stored = await self._head(state, candidate.object_key) + if stored is None or _is_fresh(stored, older_than=state.older_than): return None return replace(candidate, age_seconds=_object_age(state, stored)) async def _get_row( self, candidate: dataclasses.ReconcileFindingDTO, + *, + state: _Pass, ) -> dataclasses.AttachmentFullDTO | None: if candidate.attachment_id is None: return None + state.check_stop() async with self.db_scope() as db_session: row = await attachment_repo.get_attachment( db_session=db_session, @@ -535,9 +863,12 @@ class AttachmentReconcileService: async def _references( self, candidate: dataclasses.ReconcileFindingDTO, + *, + state: _Pass, ) -> list[dataclasses.AttachmentFullDTO]: if candidate.attachment_id is None: return [] + state.check_stop() async with self.db_scope() as db_session: return await attachment_repo.find_attachment_reference( db_session=db_session, @@ -551,9 +882,7 @@ class AttachmentReconcileService: self, state: _Pass, *, - older_than: datetime, max_changes: int, - stop_requested: Callable[[], bool], log: AbstractLogger, ) -> None: """Шаг 5: предел изменений, затем действия по порядку решения 7.""" @@ -564,6 +893,7 @@ class AttachmentReconcileService: "Reconcile changes exceed limit", changes=changes, max_changes=max_changes, + unchecked=state.unchecked, ) bucket_probed = False for kind in ACTION_ORDER: @@ -572,17 +902,12 @@ class AttachmentReconcileService: for index, finding in enumerate(state.confirmed): if finding.kind != kind: continue - _check_stop(stop_requested) + state.check_stop() if kind in NEEDS_BUCKET and not bucket_probed: # отсутствие объекта — снова только при живом bucket - await attachment_object_repo.probe_originals(self.storage) + await self._probe(state) bucket_probed = True - _check_stop(stop_requested) - action = await self._fix( - finding, - older_than=older_than, - stop_requested=stop_requested, - ) + action = await self._fix(finding, state=state) if action is None: state.dropped.add(index) continue @@ -593,8 +918,7 @@ class AttachmentReconcileService: self, finding: dataclasses.ReconcileFindingDTO, *, - older_than: datetime, - stop_requested: Callable[[], bool], + state: _Pass, ) -> ReconcileAction | None: """Одно действие с перепроверкой непосредственно перед ним; `None` — условие уже не выполняется, ничего не изменено.""" @@ -602,45 +926,56 @@ class AttachmentReconcileService: if kind == ReconcileFinding.STALE_PENDING: removed = await self.cleanup.remove_stale_pending( attachment_id=finding.attachment_id, - older_than=older_than, - stop_requested=stop_requested, + older_than=state.older_than, + stop_requested=state.stop_requested, log=logger.bind(method="reconcile"), ) + # DELETE объекта уборки — тоже под пределом скорости + await self._pace(state) return ReconcileAction.REMOVED_PENDING if removed else None if not self._own_key(finding.object_key): # объект вне префикса вложений своей базы не читается и не # меняется; классификация такого не подтверждает return None if kind == ReconcileFinding.ORPHAN_OBJECT: - if await self._references(finding): + if await self._references(finding, state=state): return None - _check_stop(stop_requested) - await attachment_object_repo.delete_original( - self.storage, - key=finding.object_key, - ) + await self._delete(state, finding.object_key) return ReconcileAction.DELETED_OBJECT - stored = await attachment_object_repo.head_original( - self.storage, - key=finding.object_key, - ) - # HEAD мог ждать S3 до срока: шаг с БД — только без сигнала - _check_stop(stop_requested) - if kind == ReconcileFinding.RESTORED_OBJECT: - if stored is None or stored.size != finding.size_bytes: + if kind in NEEDS_READ: + read = await self._read( + state, + finding.object_key, + size=finding.size_bytes, + ) + same = ( + read is not None + and read.sha256 is not None + and read.sha256 == finding.sha256 + ) + # чтение могло ждать S3 до срока: шаг с БД — только без сигнала + state.check_stop() + if kind == ReconcileFinding.RESTORED_OBJECT: + if not same: + return None + return await self._clear_lost(finding) + # другой SHA-256: объект того же размера с другим содержимым + if read is None or read.sha256 is None or same: return None - async with self.db_scope() as db_session: - cleared = await attachment_repo.clear_lost( - db_session=db_session, - attachment_id=finding.attachment_id, - object_key=finding.object_key, - ) - await db_session.commit() - return ReconcileAction.CLEARED_LOST if cleared else None + return await self._mark_lost(finding) + stored = await self._head(state, finding.object_key) + # HEAD мог ждать S3 до срока: шаг с БД — только без сигнала + state.check_stop() # метаданные без объекта или другой размер: объекта по-прежнему нет # или размер по-прежнему другой if stored is not None and stored.size == finding.size_bytes: return None + return await self._mark_lost(finding) + + async def _mark_lost( + self, + finding: dataclasses.ReconcileFindingDTO, + ) -> ReconcileAction | None: async with self.db_scope() as db_session: marked = await attachment_repo.mark_lost( db_session=db_session, @@ -651,6 +986,19 @@ class AttachmentReconcileService: await db_session.commit() return ReconcileAction.MARKED_LOST if marked else None + async def _clear_lost( + self, + finding: dataclasses.ReconcileFindingDTO, + ) -> ReconcileAction | None: + async with self.db_scope() as db_session: + cleared = await attachment_repo.clear_lost( + db_session=db_session, + attachment_id=finding.attachment_id, + object_key=finding.object_key, + ) + await db_session.commit() + return ReconcileAction.CLEARED_LOST if cleared else None + # ------------------------------------------------------------------ итог def _record( @@ -663,7 +1011,8 @@ class AttachmentReconcileService: ) -> None: """Запись о расхождении: `info` с действием — исправлено, `warning` — осталось. Не больше `RECONCILE_FINDINGS_LOGGED_MAX` - записей за проход, остальные — числом в итоге.""" + записей за проход, остальные — числом в итоге. SHA-256 в записи + нет.""" if state.logged >= RECONCILE_FINDINGS_LOGGED_MAX: state.unlogged += 1 return @@ -694,9 +1043,9 @@ class AttachmentReconcileService: state: _Pass, *, interrupted_by: str | None, - duration_ms: int, log: AbstractLogger, ) -> dataclasses.ReconcilePassDTO: + duration_ms = round((time.monotonic() - state.started) * 1000) remaining = [ finding for index, finding in enumerate(state.confirmed) @@ -710,6 +1059,12 @@ class AttachmentReconcileService: if index not in state.dropped ) fixed = Counter(state.confirmed[index].kind for index in state.fixed) + stats = self.storage.stats() + start = state.stats_start + s3_requests = { + name: stats.calls[name] - start.calls[name] + for name in S3_OPERATIONS + } result = dataclasses.ReconcilePassDTO( apply=state.apply, listed_objects=state.listed_objects, @@ -724,6 +1079,15 @@ class AttachmentReconcileService: unlogged=state.unlogged, interrupted_by=interrupted_by, duration_ms=duration_ms, + strategy=state.strategy, + deep=state.deep, + max_objects_per_second=state.rate, + storage_objects=self._touched(state), + s3_requests=MappingProxyType(s3_requests), + read_bytes=stats.read_bytes - start.read_bytes, + db_sessions=self._db_sessions - state.db_sessions_start, + unchecked=state.unchecked, + phase_ms=MappingProxyType(dict(state.phase_ms)), ) fields = { "listed_objects": result.listed_objects, @@ -736,8 +1100,15 @@ class AttachmentReconcileService: "lost_known": result.lost_known, "refused": result.refused, "unlogged": result.unlogged, + "unchecked": result.unchecked, "interrupted_by": result.interrupted_by, "duration_ms": result.duration_ms, + "max_objects_per_second": result.max_objects_per_second, + "storage_objects": result.storage_objects, + "s3_requests": dict(result.s3_requests), + "read_bytes": result.read_bytes, + "db_sessions": result.db_sessions, + "phase_ms": dict(result.phase_ms), } if result.remaining or result.refused or interrupted_by is not None: log.warning("Finished reconcile pass", **fields) @@ -746,13 +1117,6 @@ class AttachmentReconcileService: return result -def _check_stop(stop_requested: Callable[[], bool]) -> None: - """Перед вызовом хранилища: сигнал пришёл — проход останавливается, и - остановка ждёт не больше одного вызова.""" - if stop_requested(): - raise _Stopped - - def _is_fresh(stored: StoredObjectInfo, *, older_than: datetime) -> bool: """Объект записан или изменён не раньше порога; без времени — свежий: удалять без доказанного возраста нельзя.""" @@ -780,4 +1144,5 @@ def _finding( age_seconds=state.age(row.updated_at), size_bytes=row.size_bytes, stored_size=stored_size, + sha256=row.sha256, ) diff --git a/src/infra/s3/__init__.py b/src/infra/s3/__init__.py index 911ed8c5..7dc571f6 100644 --- a/src/infra/s3/__init__.py +++ b/src/infra/s3/__init__.py @@ -1,5 +1,6 @@ from src.infra.s3.client import ( ObjectStorage, + StorageStats, StoredObject, StoredObjectInfo, StoredObjectPage, @@ -8,6 +9,7 @@ from src.infra.s3.client import ( __all__ = [ "ObjectStorage", + "StorageStats", "StoredObject", "StoredObjectInfo", "StoredObjectPage", diff --git a/src/infra/s3/client.py b/src/infra/s3/client.py index 0a0a9327..aa5d90c6 100644 --- a/src/infra/s3/client.py +++ b/src/infra/s3/client.py @@ -26,6 +26,13 @@ bucket и БД процессом уборщика (design change `track2-reconc решение 3): страница — один вызов со сроком, нет bucket — ошибка, а не пустая страница. +Счётчики клиента (design change `track2-reconcile-cost`, решение 8): +попытки вызовов по операциям (`list`, `head`, `get`, `delete`, `put` — +считаются до вызова, в том числе неудачные), ключи страниц списка и +прочитанные байты объектов. `stats()` отдаёт неизменяемый снимок +`StorageStats`; стоимость прохода сверка считает разностью снимков. +Поведение вызовов, сроки и перевод ошибок от счётчиков не зависят. + В журнал — адрес, bucket, ключ объекта, размер, длительность и класс ошибки; ключей доступа, секрета и подписи там нет. Логгеры botocore, aiobotocore и aiohttp стоят на WARNING (`src/infra/logger.py`): на DEBUG @@ -34,10 +41,12 @@ botocore пишет заголовки с подписью. import asyncio import time -from collections.abc import AsyncIterator +from collections import Counter +from collections.abc import AsyncIterator, Mapping from contextlib import AsyncExitStack, asynccontextmanager from dataclasses import dataclass from datetime import datetime +from types import MappingProxyType from typing import Any, BinaryIO import aiohttp @@ -88,12 +97,33 @@ TRANSLATED_ERRORS: tuple[type[Exception], ...] = ( ) # размер блока чтения объекта по умолчанию DEFAULT_CHUNK_BYTES = 64 * 1024 +# имя операции botocore → имя в счётчиках клиента +OPERATION_NAMES = MappingProxyType( + { + "list_objects_v2": "list", + "head_object": "head", + "get_object": "get", + "delete_object": "delete", + "put_object": "put", + }, +) + + +@dataclass(frozen=True, slots=True) +class StorageStats: + """Снимок счётчиков клиента с его создания: `calls` — попытки вызовов + по операциям (`list`, `head`, `get`, `delete`, `put`), `listed_keys` — + ключи страниц списка, `read_bytes` — прочитанные байты объектов.""" + + calls: Mapping[str, int] + listed_keys: int + read_bytes: int @dataclass(frozen=True, slots=True) class StoredObjectInfo: """Метаданные объекта в bucket. `last_modified` — время записи по часам - S3 (точность — секунда), из списка и HEAD; у `open` его нет.""" + S3 (точность — секунда), из списка, HEAD и GET.""" key: str size: int @@ -176,6 +206,19 @@ class ObjectStorage: self._client: Any = None self._exit_stack: AsyncExitStack | None = None self._lock = asyncio.Lock() + self._calls: Counter[str] = Counter() + self._listed_keys = 0 + self._read_bytes = 0 + + def stats(self) -> StorageStats: + """Неизменяемый снимок счётчиков клиента с его создания.""" + return StorageStats( + calls=MappingProxyType( + {name: self._calls[name] for name in OPERATION_NAMES.values()}, + ), + listed_keys=self._listed_keys, + read_bytes=self._read_bytes, + ) async def start(self) -> None: """Создать клиент заранее, при старте процесса.""" @@ -244,6 +287,7 @@ class ObjectStorage: if token is not None: params["ContinuationToken"] = token response = await self._call("list_objects_v2", None, **params) + self._listed_keys += len(response.get("Contents", ())) objects = tuple( StoredObjectInfo( key=item["Key"], @@ -273,6 +317,7 @@ class ObjectStorage: key=key, size=response["ContentLength"], content_type=response.get("ContentType"), + last_modified=response.get("LastModified"), ) try: yield StoredObject(info, body, self) @@ -342,6 +387,7 @@ class ObjectStorage: """Вызов клиента со сроком и переводом ошибок. `key=None` — вызов над bucket без ключа (список), в журнал тогда — `prefix`.""" client = await self._get_client() + self._calls[OPERATION_NAMES.get(operation, operation)] += 1 started = time.monotonic() if key is not None: params["Key"] = key @@ -383,7 +429,7 @@ class ObjectStorage: started = time.monotonic() try: async with asyncio.timeout(self._timeout_seconds): - return await body.read(chunk_bytes) + chunk = await body.read(chunk_bytes) except TRANSLATED_ERRORS as e: failure = self._failure( e, @@ -394,6 +440,8 @@ class ObjectStorage: if failure is None: raise raise failure from e + self._read_bytes += len(chunk) + return chunk def _failure( self, diff --git a/src/schemas/dataclasses/attachment.py b/src/schemas/dataclasses/attachment.py index 6f799f25..8dd8b470 100644 --- a/src/schemas/dataclasses/attachment.py +++ b/src/schemas/dataclasses/attachment.py @@ -1,9 +1,19 @@ from collections.abc import AsyncIterator, Awaitable, Callable, Mapping -from dataclasses import dataclass +from dataclasses import dataclass, field from datetime import datetime +from types import MappingProxyType from uuid import UUID -from src.schemas.enums import AttachmentStatus, ImageType, ReconcileFinding +from src.schemas.enums import ( + AttachmentStatus, + ImageType, + ReconcileFinding, + ReconcileStrategy, +) + + +def _empty_mapping() -> Mapping[str, int]: + return MappingProxyType({}) @dataclass(frozen=True, slots=True) @@ -65,7 +75,9 @@ class ReconcileFindingDTO: `attachment_id` — если известен (из ключа или строки), `age_seconds` — возраст объекта (`LastModified`) или строки (`updated_at` у ready, `created_at` у pending). `size_bytes` и `stored_size` — размеры строки и - объекта, если известны оба. + объекта, если известны оба. `sha256` — SHA-256 оригинала из строки: + по нему перепроверка и действие сверяют прочитанный объект (design + change `track2-reconcile-cost`, решение 5); в журнал не попадает. """ kind: ReconcileFinding @@ -74,6 +86,7 @@ class ReconcileFindingDTO: age_seconds: int size_bytes: int | None = None stored_size: int | None = None + sha256: bytes | None = None @dataclass(frozen=True, slots=True) @@ -86,6 +99,14 @@ class ReconcilePassDTO: сколько расхождений не записано отдельными записями, `interrupted_by` — причина прерывания (`object_storage`, `database`, `stop`) или `None`. + + Стоимость прохода (design change `track2-reconcile-cost`, решения 8 и + 15): `strategy`, `deep` и `max_objects_per_second` (0 — без предела); + `storage_objects` — затронутые объекты S3 (ключи страниц списка, HEAD, + GET, DELETE), `s3_requests` — вызовы S3 по операциям, `read_bytes` — + прочитанные байты объектов, `db_sessions` — сеансы с PostgreSQL, + `unchecked` — кандидаты, которых `--apply` не перепроверял после + решённого отказа по пределу, `phase_ms` — длительность шагов прохода. """ apply: bool @@ -101,6 +122,15 @@ class ReconcilePassDTO: unlogged: int interrupted_by: str | None duration_ms: int + strategy: ReconcileStrategy = ReconcileStrategy.BATCH + deep: bool = False + max_objects_per_second: float = 0 + storage_objects: int = 0 + s3_requests: Mapping[str, int] = field(default_factory=_empty_mapping) + read_bytes: int = 0 + db_sessions: int = 0 + unchecked: int = 0 + phase_ms: Mapping[str, int] = field(default_factory=_empty_mapping) @dataclass(frozen=True, slots=True) diff --git a/src/schemas/enums/__init__.py b/src/schemas/enums/__init__.py index b15f410f..57479844 100644 --- a/src/schemas/enums/__init__.py +++ b/src/schemas/enums/__init__.py @@ -3,6 +3,7 @@ from .attachment import ( ImageType, ReconcileAction, ReconcileFinding, + ReconcileStrategy, ) from .settings import RunModeEnum @@ -11,5 +12,6 @@ __all__ = [ "ImageType", "ReconcileAction", "ReconcileFinding", + "ReconcileStrategy", "RunModeEnum", ] diff --git a/src/schemas/enums/attachment.py b/src/schemas/enums/attachment.py index 260edc0c..47796d31 100644 --- a/src/schemas/enums/attachment.py +++ b/src/schemas/enums/attachment.py @@ -38,6 +38,21 @@ class ReconcileFinding(StrEnum): # ключ под префиксом вложений, которого API не пишет, или ключ строки # другого вида UNKNOWN_OBJECT = "unknown_object" + # строка ready, объект того же размера, а SHA-256 содержимого другой; + # ищет только глубокая сверка (design change `track2-reconcile-cost`, + # решение 5) + CHECKSUM_MISMATCH = "checksum_mismatch" + + +class ReconcileStrategy(StrEnum): + """Стратегия обхода сверки (design change `track2-reconcile-cost`, + решение 4). `batch` — страница списка и одно выражение к БД на + страницу, ключи списка в множестве; `head` — выборка строки на объект + списка и HEAD на строку `ready`, без множества. Плановая сверка — только + `batch`.""" + + BATCH = "batch" + HEAD = "head" class ReconcileAction(StrEnum): diff --git a/src/utils/constants.py b/src/utils/constants.py index d55c3bea..b2112f0a 100644 --- a/src/utils/constants.py +++ b/src/utils/constants.py @@ -83,6 +83,10 @@ ATTACHMENT_ORIGINAL_SUFFIX = "original" # записями журнала; остальные — только числом в итоге (design change # `track2-reconciler`, решение 8) RECONCILE_FINDINGS_LOGGED_MAX = 1000 +# пауза предела скорости сверки — кусками не дольше этого, с проверкой +# сигнала между ними: остановка не ждёт конца паузы (design change +# `track2-reconcile-cost`, решение 6) +RECONCILE_PACE_STEP_SECONDS = 0.2 # секунды в Retry-After ответа 429, когда места загрузки процесса заняты: # за секунду реплика доводит несколько загрузок (7–8,5 по 10 MiB), а повтор # через LB уходит на следующую реплику (design change `upload-memory`, diff --git a/student-tests/fault_hook.py b/student-tests/fault_hook.py index acd85c2c..7d7c57f1 100755 --- a/student-tests/fault_hook.py +++ b/student-tests/fault_hook.py @@ -82,11 +82,18 @@ `attachments/`, символы [A-Za-z0-9._/-] lost-ids `id` вложений с потерянным оригиналом (lost_at задан) - reconcile dry-run|apply [<предел>] + reconcile dry-run|apply [<предел>] [--strategy batch|head] [--deep] + [--max-objects-per-second R] разовая сверка (`docker compose run --rm --no-deps -T cleaner reconcile [--apply] - [--max-changes N]`): записи процесса и - строка `exit_code=`; код hook — 0 + [--max-changes N] …`): стратегия обхода, + глубокая сверка и предел скорости (R — + неотрицательное число, 0 — без предела) + проверяются по списку и передаются команде + как есть (design change + `track2-reconcile-cost`, решение 14); + записи процесса и строка `exit_code=`; + код hook — 0 stop|start cleaner сервис уборщика стенда run-cleaner <секунд> отдельный уборщик `-cleaner-scheduled` с @@ -421,6 +428,10 @@ client.put_object(Bucket=s3.bucket, Key=sys.argv[1], Body=body) # символы ключа объекта, который hook пишет или удаляет мимо API OBJECT_KEY_RE = re.compile(r"^[A-Za-z0-9._/-]+$") RECONCILE_MODES = {"dry-run": (), "apply": ("--apply",)} +# стратегии обхода и предел скорости сверки (change track2-reconcile-cost): +# неотрицательное число, целое или с дробной частью +RECONCILE_STRATEGIES = ("batch", "head") +RATE_PATTERN = re.compile(r"[0-9]+(\.[0-9]+)?") # плановая сверка отдельного уборщика: раз в секунду SCHEDULED_CLEANER_ENV = "RECONCILER__INTERVAL_SECONDS=1" SCHEDULED_CLEANER_MAX_S = 60 @@ -817,12 +828,47 @@ def row_change(project: str, sql: str, attachment_id: str, value: str) -> str: return "" +def reconcile_options(args: list[str]) -> list[str]: + """Аргументы сверки после режима: необязательный предел изменений + первым, затем `--strategy batch|head`, `--deep`, + `--max-objects-per-second R`. Каждый — по списку разрешённых, иначе + код 2 hook.""" + usage = ( + "reconcile dry-run|apply [] [--strategy batch|head] " + "[--deep] [--max-objects-per-second R]" + ) + options: list[str] = [] + rest = list(args) + if rest and not rest[0].startswith("--"): + if not rest[0].isdigit() or int(rest[0]) < 1: + raise HookError(usage) + options += ["--max-changes", str(int(rest.pop(0)))] + seen: set[str] = set() + while rest: + name = rest.pop(0) + if name in seen: + raise HookError(usage) + seen.add(name) + if name == "--deep": + options.append(name) + elif name == "--strategy" and rest and rest[0] in RECONCILE_STRATEGIES: + options += [name, rest.pop(0)] + elif name == "--max-objects-per-second" and rest: + value = rest.pop(0) + if not RATE_PATTERN.fullmatch(value): + raise HookError(usage) + options += [name, value] + else: + raise HookError(usage) + return options + + def reconcile(project: str, mode: str, args: list[str]) -> str: """Разовая сверка в одноразовом контейнере уборщика стенда: записи процесса и строка `exit_code=`.""" - if mode not in RECONCILE_MODES or len(args) > 1: - raise HookError("reconcile dry-run|apply []") - limit = ("--max-changes", str(int(args[0]))) if args else () + if mode not in RECONCILE_MODES: + raise HookError("reconcile dry-run|apply [] [options]") + options = reconcile_options(args) result = compose_run( project, "run", @@ -832,7 +878,7 @@ def reconcile(project: str, mode: str, args: list[str]) -> str: "cleaner", "reconcile", *RECONCILE_MODES[mode], - *limit, + *options, ) lines = [*result.stdout.splitlines(), *result.stderr.splitlines()] return "\n".join([*lines, f"exit_code={result.returncode}"]) diff --git a/student-tests/test_failures.py b/student-tests/test_failures.py index c6a93ed6..8559e9ec 100644 --- a/student-tests/test_failures.py +++ b/student-tests/test_failures.py @@ -20,12 +20,14 @@ change `fix-upload-put-flake`. import hashlib import json +import math import os +import random import statistics import threading import time import uuid -from collections.abc import Callable, Collection, Iterator +from collections.abc import Callable, Collection, Iterator, Sequence from concurrent.futures import ThreadPoolExecutor from contextlib import contextmanager from dataclasses import dataclass @@ -1670,10 +1672,14 @@ def run_reconcile( stand: Stand, mode: str, limit: int | None = None, + *, + options: Sequence[str] = (), ) -> Reconcile: - """Разовая сверка hook: `dry-run` или `apply`, с пределом изменений.""" + """Разовая сверка hook: `dry-run` или `apply`, с пределом изменений; + `options` — стратегия, глубина и предел скорости (change + `track2-reconcile-cost`) как аргументы команды.""" args = [mode] if limit is None else [mode, str(limit)] - lines = stand("reconcile", *args).splitlines() + lines = stand("reconcile", *args, *options).splitlines() assert lines and lines[-1].startswith("exit_code="), lines[-5:] records = [] for line in lines[:-1]: @@ -2292,3 +2298,282 @@ def test_scheduled_reconcile( assert passes, log[-2000:] assert any(item["apply"] for item in passes), passes assert scheduled["id"] in lost_ids(stand) + + +# --------------------------------------------------------------------------- +# Стоимость сверки (change track2-reconcile-cost, design, решение 14): +# стратегия HEAD, глубокая сверка и класс «другой SHA-256», снятие пометки +# только при том же SHA-256, предел скорости, отказ по пределу без лишних +# перепроверок. Аргументы сверки hook передаёт команде как есть +# --------------------------------------------------------------------------- + +HEAD_STRATEGY = ("--strategy", "head") +DEEP = ("--deep",) +NO_RATE_LIMIT = ("--max-objects-per-second", "0") +# сколько вложений загружает тест предела скорости: объектов в bucket +# заведомо хватает на несколько секунд прохода +RATE_UPLOADS = 8 +# во сколько раз проход с пределом длиннее числа объектов на предел +# (допуск на округление `duration_ms`) +RATE_SLACK = 0.95 + + +def same_size_bytes(data: bytes, *, seed: int) -> bytes: + """Другие байты того же размера, от зерна теста.""" + other = random.Random(seed).randbytes(len(data)) + assert other != data + return other + + +def findings(run: Reconcile) -> set[tuple[str, str]]: + """Все расхождения прохода: класс и ключ объекта.""" + return {(item["kind"], item["object_key"]) for item in run.events(FOUND)} + + +@pytest.mark.spec("storage-consistency", "Стратегия HEAD находит то же") +def test_reconcile_head_strategy_same_findings( + api: Api, + stand: Stand, + alice: Actor, + chat: dict[str, Any], +) -> None: + """Те же расхождения, что в `test_reconcile_finds_and_fixes`: dry-run + стратегией по умолчанию и `--strategy head` называют одно и то же, а + HEAD-проход дороже по запросам к S3 и сеансам PostgreSQL.""" + data = images.sample_png() + # уборщик стенда стоит: зависшую загрузку P не уберут между проходами + with outage(stand, "stop", "cleaner"): + a, b, c = (api.upload(alice, chat["id"], data) for _ in range(3)) + api.send_message(alice, chat["id"], "", attachment_ids=[a["id"]]) + orphan = str(uuid.uuid4()) + keys = {"o": object_key(orphan), "b": object_key(b["id"])} + put_object(stand, keys["o"], data) + stand("delete-object", object_key(a["id"])) + stand("delete-row", b["id"]) + stand("set-size", c["id"], str(len(data) + 1)) + filename = fault_filename() + before = attachment_rows(stand) + stand("fail-attachments", "commit", filename) + try: + resp = upload_raw(api, alice, chat, data, filename=filename) + assert_error(resp, 503) + finally: + stand("clear-fail-attachments") + (pending,) = new_ids(before, attachment_rows(stand)) + time.sleep(OBJECT_AGE_WAIT_S) + ids = {a["id"], c["id"], pending} + expected = { + keys["o"]: "orphan_object", + keys["b"]: "orphan_object", + a["id"]: "missing_object", + c["id"]: "size_mismatch", + pending: "stale_pending", + } + snapshot = (attachment_rows(stand), stored_ids(stand), lost_ids(stand)) + + batch = run_reconcile(stand, "dry-run") + head = run_reconcile(stand, "dry-run", options=HEAD_STRATEGY) + assert batch.kinds(FOUND, ids=ids, keys=keys.values()) == expected + assert head.kinds(FOUND, ids=ids, keys=keys.values()) == expected + # не только свои: весь отчёт и итог по классам одинаковы + assert findings(head) == findings(batch) + for field in ("found", "listed_objects", "checked_rows"): + assert head.finished[field] == batch.finished[field], field + assert head.exit_code == batch.exit_code == 3 + assert (batch.finished["strategy"], head.finished["strategy"]) == ( + "batch", + "head", + ) + assert ( + head.finished["s3_requests"]["head"] + > batch.finished["s3_requests"]["head"] + ), (head.finished, batch.finished) + assert head.finished["db_sessions"] > batch.finished["db_sessions"] + after = (attachment_rows(stand), stored_ids(stand), lost_ids(stand)) + assert after == snapshot + + # стенд — без внесённых расхождений для следующих тестов + fixed = run_reconcile(stand, "apply") + assert set(fixed.kinds(FIXED, ids=ids, keys=keys.values())) == set( + expected, + ) + + +@pytest.mark.spec( + "storage-consistency", + "Другой SHA-256 находит глубокая сверка", +) +def test_reconcile_deep_checksum( + api: Api, + stand: Stand, + alice: Actor, + chat: dict[str, Any], +) -> None: + data = images.png_noise(64, 48, seed=11) + a = api.upload(alice, chat["id"], data) + api.send_message(alice, chat["id"], "", attachment_ids=[a["id"]]) + other = same_size_bytes(data, seed=11) + # объект перезаписан мимо API байтами того же размера + put_object(stand, object_key(a["id"]), other) + stand("age-row", a["id"], str(AGED_S)) + time.sleep(OBJECT_AGE_WAIT_S) + snapshot = (attachment_rows(stand), stored_ids(stand), lost_ids(stand)) + + shallow = run_reconcile(stand, "dry-run") + assert not shallow.about(FOUND, ids={a["id"]}) + assert shallow.finished["deep"] is False + deep = run_reconcile(stand, "dry-run", options=DEEP) + assert deep.kinds(FOUND, ids={a["id"]}) == {a["id"]: "checksum_mismatch"} + assert deep.finished["deep"] is True + assert deep.finished["read_bytes"] >= len(data), deep.finished + assert deep.finished["s3_requests"]["get"] >= 1, deep.finished + assert deep.exit_code == 3 + after = (attachment_rows(stand), stored_ids(stand), lost_ids(stand)) + assert after == snapshot + # SHA-256 объектов в журнале нет + journal = json.dumps(deep.records) + for body in (data, other): + assert hashlib.sha256(body).hexdigest() not in journal + + applied = run_reconcile(stand, "apply", options=DEEP) + (record,) = applied.about(FIXED, ids={a["id"]}) + assert (record["kind"], record["action"]) == ( + "checksum_mismatch", + "marked_lost", + ) + assert a["id"] in lost_ids(stand) + assert_lost_content(api, alice, a, aged=True) + + +@pytest.mark.spec( + "storage-consistency", + "Вернулся другой объект того же размера", +) +@pytest.mark.spec("storage-consistency", "Оригинал вернулся") +def test_reconcile_restore_needs_same_bytes( + api: Api, + stand: Stand, + alice: Actor, + chat: dict[str, Any], +) -> None: + data = images.png_noise(64, 48, seed=13) + restored = api.upload(alice, chat["id"], data) + ids = {restored["id"]} + lose_original(stand, restored) + marked = run_reconcile(stand, "apply") + assert marked.kinds(FIXED, ids=ids) == {restored["id"]: "missing_object"} + assert restored["id"] in lost_ids(stand) + + # под ключом — другие байты того же размера: пометка остаётся + put_object( + stand, + object_key(restored["id"]), + same_size_bytes(data, seed=13), + ) + time.sleep(OBJECT_AGE_WAIT_S) + wrong = run_reconcile(stand, "apply") + assert not wrong.about(FIXED, ids=ids) + assert all( + record["kind"] != "restored_object" + for record in wrong.about(FOUND, ids=ids) + ) + assert restored["id"] in lost_ids(stand) + assert_lost_content(api, alice, restored, aged=True) + + # те же байты, что были загружены: пометка снята + put_object(stand, object_key(restored["id"]), data) + time.sleep(OBJECT_AGE_WAIT_S) + cleared = run_reconcile(stand, "apply") + (record,) = cleared.about(FIXED, ids=ids) + assert (record["kind"], record["action"]) == ( + "restored_object", + "cleared_lost", + ) + assert restored["id"] not in lost_ids(stand) + assert_content( + api.attachment_content(alice, restored["id"]), + data, + "image/png", + ) + again = run_reconcile(stand, "dry-run") + assert not again.about(FOUND, ids=ids) + + +@pytest.mark.spec("storage-consistency", "Скорость прохода ограничена") +@pytest.mark.spec("storage-consistency", "Без ограничения скорости") +def test_reconcile_rate_limit( + api: Api, + stand: Stand, + alice: Actor, + chat: dict[str, Any], +) -> None: + """Предел на четверть объектов прохода: проход длится не меньше + объектов на предел, находки и код — как без предела.""" + data = images.sample_png() + for _ in range(RATE_UPLOADS): + api.upload(alice, chat["id"], data) + lost = api.upload(alice, chat["id"], data) + ids = {lost["id"]} + lose_original(stand, lost) + # уборщик стенда стоит: между проходами стенд не меняется + with outage(stand, "stop", "cleaner"): + free = run_reconcile(stand, "dry-run", options=NO_RATE_LIMIT) + rate = max(5, math.ceil(free.finished["storage_objects"] / 4)) + limited = run_reconcile( + stand, + "dry-run", + options=("--max-objects-per-second", str(rate)), + ) + assert free.finished["max_objects_per_second"] == 0 + assert limited.finished["max_objects_per_second"] == rate + objects = limited.finished["storage_objects"] + assert objects >= RATE_UPLOADS, limited.finished + assert ( + limited.finished["duration_ms"] >= 1000 * objects / rate * RATE_SLACK + ), limited.finished + assert free.finished["duration_ms"] < limited.finished["duration_ms"] + expected = {lost["id"]: "missing_object"} + assert free.kinds(FOUND, ids=ids) == expected + assert limited.kinds(FOUND, ids=ids) == expected + assert free.exit_code == limited.exit_code == 3 + # стенд — без внесённой потери + applied = run_reconcile(stand, "apply") + assert applied.kinds(FIXED, ids=ids) == expected + + +@pytest.mark.spec( + "storage-consistency", + "Отказ по пределу без лишних перепроверок", +) +def test_reconcile_limit_stops_rechecks( + api: Api, + stand: Stand, + alice: Actor, + chat: dict[str, Any], +) -> None: + limit = 2 + batch = [ + api.upload(alice, chat["id"], images.sample_png()) for _ in range(6) + ] + ids = {item["id"] for item in batch} + for item in batch: + lose_original(stand, item) + refused = run_reconcile(stand, "apply", limit) + assert refused.exit_code == 3 + (error,) = refused.events(LIMIT_EXCEEDED) + assert error["level"] == "error" + # отказ решён на третьем подтверждённом: остальные не перепроверены + assert error["changes"] == limit + 1, error + assert error["max_changes"] == limit + assert error["unchecked"] >= len(batch) - (limit + 1), error + assert refused.finished["unchecked"] == error["unchecked"] + assert refused.finished["refused"] is True + assert not refused.about(FIXED, ids=ids) + assert not ids & lost_ids(stand) + # dry-run перепроверяет каждого и называет все шесть + dry = run_reconcile(stand, "dry-run") + assert dry.kinds(FOUND, ids=ids) == dict.fromkeys(ids, "missing_object") + assert dry.finished["unchecked"] == 0 + applied = run_reconcile(stand, "apply", 100) + assert set(applied.kinds(FIXED, ids=ids)) == ids + assert ids <= lost_ids(stand)