From ca0c4b2f7136564d7c5da66e016937c2dc6ae0bc Mon Sep 17 00:00:00 2001 From: roman Date: Fri, 23 Oct 2026 20:03:00 +0300 Subject: [PATCH] fix: address track2-reconcile-cost verify findings Co-Authored-By: Claude Opus 5.5 --- .claude/rules/bench.md | 20 +- .claude/rules/service-layer.md | 18 +- .claude/rules/settings.md | 4 +- .claude/rules/student-tests.md | 19 +- .claude/skills/run-mtusi-messenger/SKILL.md | 3 +- .claude/skills/run-mtusi-messenger/driver.py | 163 +++++++-- AGENTS.md | 12 +- KNOWN_ISSUES.md | 22 ++ Makefile | 2 +- PLAN.md | 29 ++ REPORT.md | 58 +++- bench/reconcile.py | 309 ++++++++++++++++-- bench/run.py | 12 +- .../changes/track2-reconcile-cost/design.md | 71 +++- .../specs/load-benchmark/spec.md | 9 +- .../specs/service-configuration/spec.md | 10 +- .../specs/storage-consistency/spec.md | 33 +- .../changes/track2-reconcile-cost/tasks.md | 75 +++++ openspec/specs/load-benchmark/spec.md | 9 +- openspec/specs/service-configuration/spec.md | 10 +- openspec/specs/storage-consistency/spec.md | 33 +- src/config/settings.py | 9 +- src/core/services/attachment_reconcile.py | 98 +++++- student-tests/test_failures.py | 149 +++++++++ 24 files changed, 1052 insertions(+), 125 deletions(-) diff --git a/.claude/rules/bench.md b/.claude/rules/bench.md index 4f8b0f7a..d6a53656 100644 --- a/.claude/rules/bench.md +++ b/.claude/rules/bench.md @@ -417,7 +417,9 @@ design change `track2-reconcile-cost`, решения 1–3, 7–13. Метод 1 000, затем 10 000 строк `ready` без объектов, `before` и `after` (`--apply --max-changes 100`, у `after` — без предела скорости). Три повтора кругами внутри группы (`reconcile.plan_passes`), план — в - `meta.json` до первого прохода. Ячейки без нагрузки — dry-run без + `meta.json` до первого прохода. У группы из одной ячейки (D без + нагрузки — только `batch`) повторы идут подряд: остальные проходы + набора — блок под нагрузкой (спек `load-benchmark`, verify S8). Ячейки без нагрузки — dry-run без предела скорости. `reconcile_quick` — один стенд 2 000 × 4 KiB, все виды по одному проходу, окна 5 с, S4 с 300 кандидатами на своём свежем стенде. @@ -463,24 +465,32 @@ design change `track2-reconcile-cost`, решения 1–3, 7–13. Метод (`reconcile.line_problems`): строк `bg,…` сценария не меньше итераций сценария и не меньше счётчика k6 `bg_lines_<сценарий>` (его увеличивает тот же код перед строкой; меньше — «lines lost», отказ), а - лишних против каждого — не больше VU сценария (`reconcile_bg_max_vus`). + лишних против каждого — не больше VU сценария (`reconcile_bg_max_vus`) + и не больше VU, созданных k6 за прогон (`vus_max` итога, verify S4). Лишние — итерации, прерванные SIGINT уже после строки: k6 их в `iterations` не считает, а их отсчёт счётчика может не принять (метка `aaf3fa3` упала на 264 071 строке download против 264 070 итераций, `a42dd27` — на 43 997 строках write против 43 996 и итераций, и отсчётов). Число прерванных — в `meta.reconcile.bg_interrupted`. Точного равенства нет ни с одним счётом. `r` = p95 прохода - / p95 тихих, `a` = p95 до / p95 после; 5xx — пометка `bg_5xx`. + / p95 тихих, `a` = p95 до / p95 после; 5xx окон прохода — пометка + `bg_5xx`, неуспешные запросы (`http_req_failed`) и недосланные итерации + (`dropped_iterations`) по всему итогу k6 — пометки `bg_failed` и + `bg_dropped` всех проходов блока (`meta.reconcile.bg_errors`, verify + S9); с любой из трёх H4 не подтверждается. - **Сравнение:** все варианты — внутри одной метки; второй метки 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` + (строка на проход, новые столбцы — в конец; с verify S6 — + `fixed_total` и `fixed_records`, неизменность данных S4; у метки + `baseline` их нет), `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 мин. Замер для отчёта — +- **Время:** полная метка ~50 мин (45 мин у `baseline`), быстрая ~4 мин + (3,7 мин на шумном хосте). Замер для отчёта — `make bench_reconcile` на тихом хосте, рабочий стенд остановлен (`make stop`), гипотезы H1–H4 закоммичены раньше метки. diff --git a/.claude/rules/service-layer.md b/.claude/rules/service-layer.md index f5d8e008..20987702 100644 --- a/.claude/rules/service-layer.md +++ b/.claude/rules/service-layer.md @@ -194,7 +194,12 @@ paths: HEAD на строку своей базы (с `deep` у непомеченной строки старше grace — сразу GET). Множества `seen` нет. Классификация пары — общая `_row_with_object`, строки без объекта — `_row_without_object`: - расхождения те же, что у `batch`; + расхождения те же, что у `batch`. Каждая строка сравнивается с + объектом по своему ключу: у `batch` шаг списка сравнивает объект + стандартного ключа со строкой своего `id`, нестандартного — с + каждой строкой этого ключа, а строку с ключом `/original` + другого вложения — шаг строк HEAD (`_key_of_other_id`; verify W2, + design, «Правки по verify», п. 2); - `deep` — GET и SHA-256 потоком (`open_original`, блоки клиента, `hashlib`) у строки `ready` без пометки, старше grace, с объектом того же размера, не моложе grace; класс `checksum_mismatch` — в @@ -203,7 +208,11 @@ paths: действие подтверждают заново прочитанным объектом: размер и SHA-256 строки (`ReconcileFindingDTO.sha256`). Без `deep` вернувшийся объект тоже читается — пометку снимает только тот же SHA-256; другой — - `lost_known`; + `lost_known`. Объект моложе grace — свежий и в перепроверке: «другой + SHA-256» читается с `fresh_before` (`_fresh_before`), объект другого + размера свежим не подтверждается ни в классификации, ни в + перепроверке, ни перед пометкой; вернувшийся читается без порога + (verify S1); - предел скорости — после каждого вызова S3 (`_pace`): затронуто (`_touched` — ключи страниц и HEAD/GET/DELETE, разность `storage.stats()` с начала) больше `R × время с начала прохода` — @@ -211,7 +220,10 @@ paths: проверкой сигнала. Пауза после вызова, а не перед следующим: тогда и последний вызов прохода не обгоняет предел (design, «Уточнения apply»). DELETE шага уборки зависшей — тоже: `_pace` после - `remove_stale_pending`; + `remove_stale_pending`. Сигнал прекращает ожидание, но `_pace` не + бросает `_Stopped`: итог вызова перед паузой (страница, удаление) + доходит до записи «Fixed» и счёта, а проход останавливает + `check_stop()` перед следующим вызовом (verify W1); - ранний отказ: с `apply` в `_recheck_all`, как только подтверждённых классов `LIMITED_KINDS` больше `max_changes`, остальные кандидаты этих классов не перепроверяются, а считаются в `unchecked`; `_act` diff --git a/.claude/rules/settings.md b/.claude/rules/settings.md index 539e8be9..55a768e3 100644 --- a/.claude/rules/settings.md +++ b/.claude/rules/settings.md @@ -242,7 +242,9 @@ pending_grace_seconds` и его проверка при старте (одна `bench/` — `RECONCILER__INTERVAL_SECONDS: "0"`. С change `track2-reconcile-cost` (решение 6) ещё `max_objects_per_second` -(float, `ge=0`, 2000; 0 — без предела) — предел скорости прохода: +(float, `ge=0`, `allow_inf_nan=False`, 2000; 0 — без предела; `inf` — +ошибка: «Started cleaner» было бы не JSON, verify S2; у прочих полей +`float` тот же дефект — `KNOWN_ISSUES.md`) — предел скорости прохода: объектов S3 в секунду в среднем от начала прохода (ключи страниц списка, HEAD, GET, DELETE). Разовая подмена — `RECONCILER__MAX_OBJECTS_PER_SECOND`, у разового прохода — `--max-objects-per-second R` (`make reconcile diff --git a/.claude/rules/student-tests.md b/.claude/rules/student-tests.md index 171ffae9..713a1e74 100644 --- a/.claude/rules/student-tests.md +++ b/.claude/rules/student-tests.md @@ -315,11 +315,28 @@ paths: код 3, `changes` = 3, `unchecked` ≥ 3, ни одной пометки; dry-run называет все шесть, `unchecked` 0; apply 100 — помечены). Байты «того же размера» — `same_size_bytes(data, seed=…)` от зерна теста; + по замечаниям verify — `test_reconcile_row_with_other_id_key` (W2: Y1 + и Y2 ссылаются на `/original` другого размера и `/original` + тех же размера с другими байтами; dry-run `--deep` обеими стратегиями + — Y1 `size_mismatch`, Y2 `checksum_mismatch`, четыре объекта чужие, + без `--deep` — только Y1; `--deep --apply` — обе помечены, объекты на + месте; записи сравниваются тройкой «класс, ключ, `id`», + `own_findings`) и `test_reconcile_fresh_overwrite_untouched` (S1: + объекты двух состаренных вложений перезаписаны только что — другим + размером и другими байтами; `--deep --apply` и `--deep --strategy + head` в пределах grace — ни находок, ни пометок, `fresh_objects` ≥ 2; + после G + 1 — `size_mismatch` и `checksum_mismatch`; исходные байты + возвращаются в `finally`); - красный прогон на `7f4e626` (тесты и hook из рабочего дерева): упали все пять — новые аргументы — ошибка argparse (код 2; у `head` пустой отчёт, у предела скорости нет итога), у глубокой нет поля `deep`, пометку снимал другой объект того же размера, `changes` 7 вместо 3 - (`evidence/tests/failure-checks.md`); + (`evidence/tests/failure-checks.md`). Тесты verify — на `16f2cde`: + `…_row_with_other_id_key` красный (`batch` не назвал Y1 и Y2), + `…_fresh_overwrite_untouched` красный (объект другого размера, + перезаписанный только что, помечен); W1 тестом отказов не + проверяется — hook не шлёт сигнал посреди прохода, это `driver.py + reconcile-signal --pace --apply`; - исключения сверки: «Принявшая реплика остановлена» — `driver.py attachment-failover` → `evidence/attachments/failover.md`; «Байты не в БД и не на диске API» — `driver.py attachment-storage` → diff --git a/.claude/skills/run-mtusi-messenger/SKILL.md b/.claude/skills/run-mtusi-messenger/SKILL.md index a94e0903..c8a79f64 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 с. `--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` | +| `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 с, `listed_objects` итога — 8 (ключи страницы перед паузой, verify W1); объекты пробы удаляются в `finally`. `--pace --apply` (verify W1, ~45 с): объекты пробы — `<база>/attachments//original` без строки, через 19 с (grace прохода 18 с, `-e CLEANER__PENDING_GRACE_SECONDS=18`) `reconcile --apply --max-objects-per-second 1`, `docker stop` через 19,5 с после «Started cleaner» — посреди удалений, в паузе после DELETE; перед уборкой — сколько объектов пробы осталось (HEAD); ожидание — то же и «Fixed» = `fixed.orphan_object` = удалённых > 0. Нужен ещё сервис `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` | @@ -185,6 +185,7 @@ python3 $D --port 8080 reconcile-cycle # расхождения с обеи 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 с +COMPOSE_PROJECT_NAME=<временный> python3 $D reconcile-signal --pace --apply # то же посреди удалений: каждое удалённое — «Fixed» 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 7e7ccef2..d50d8d01 100644 --- a/.claude/skills/run-mtusi-messenger/driver.py +++ b/.claude/skills/run-mtusi-messenger/driver.py @@ -123,8 +123,12 @@ вместо pause s3 — объекты пробы мимо API (botocore в одноразовом контейнере api его ключами), reconcile --max-objects-per-second 1, docker stop через 2 с после «Started cleaner» во время паузы - предела скорости — остановка не дольше секунды; объекты - удаляются в finally + предела скорости — остановка не дольше секунды, listed_objects + итога — ключи страницы; объекты удаляются в finally. + --pace --apply (verify W1): объекты пробы без строки + (/original), через grace 18 с + 1 — reconcile --apply с тем + же пределом, docker stop во время паузы после DELETE: удалённых + объектов столько же, сколько записей «Fixed» и fixed итога s3-idle [--rounds 3] [--downloads 10] [--puts 12] [--size-mib 4] [--pause-ms 0.5] только стенд с LB: спеки object-storage «Вызов после простоя» и attachments «Загрузка после простоя @@ -3658,13 +3662,23 @@ RS_PACE_RATE = "1" RS_PACE_AFTER_START_S = 2.0 # остановка во время паузы — не позже секунды после сигнала RS_PACE_STOP_LIMIT_S = 1.0 +# режим --pace --apply (verify W1 change track2-reconcile-cost): объекты +# пробы — без строки (/original), и сверка с --apply их удаляет. Grace +# прохода — наименьший, который примет уборщик (граница живой загрузки +# 17 с), объекты старше него через секунду. При пределе 1 объект/с: список +# — 8 с, перепроверка — HEAD на объект (ещё 8 с), затем DELETE раз в +# секунду, и после каждого — пауза ~1 с. docker stop — посреди удалений +RS_PACE_APPLY_GRACE_S = 18 +RS_PACE_APPLY_AFTER_START_S = 19.5 # объекты пробы — botocore в одноразовом контейнере сервиса api его # ключами из окружения (как put-object hook стенда отказов); в argv и -# вывод ключи не попадают +# вывод ключи доступа не попадают. argv: действие (put, delete, count) и +# хвосты ключей под <база>/attachments/ RS_PACE_OBJECTS_PY = r""" import os, sys import botocore.session from botocore.config import Config +from botocore.exceptions import ClientError s3 = botocore.session.get_session().create_client( "s3", @@ -3675,14 +3689,22 @@ s3 = botocore.session.get_session().create_client( 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": +prefix = os.environ["DATABASE__NAME"] + "/attachments/" +action, tails = sys.argv[1], sys.argv[2:] +present = 0 +for tail in tails: + key = prefix + tail + if action == "put": s3.put_object(Bucket=bucket, Key=key, Body=b"pace", ContentType="image/png") - else: + elif action == "delete": s3.delete_object(Bucket=bucket, Key=key) -print(f"{sys.argv[1]} {sys.argv[2]} objects") + else: + try: + s3.head_object(Bucket=bucket, Key=key) + present += 1 + except ClientError: + pass +print(f"present {present}" if action == "count" else f"{action} {len(tails)} objects") """ @@ -3696,9 +3718,10 @@ def rfc3339_ns(text: str) -> int: return seconds * 10**9 + int((digits + "0" * 9)[:9]) -def rs_pace_objects(action: str) -> None: - """`put` или `delete` объектов пробы режима `--pace`.""" - compose( +def rs_pace_objects(action: str, tails: list[str]) -> str: + """`put`, `delete` или `count` объектов пробы режима `--pace`; вывод + скрипта (у `count` — `present N`).""" + return compose( "run", "--rm", "--no-deps", @@ -3708,12 +3731,12 @@ def rs_pace_objects(action: str) -> None: "api", "-", action, - str(RS_PACE_OBJECTS), + *tails, stdin=RS_PACE_OBJECTS_PY, ) -def cmd_reconcile_signal(*, pace: bool = False) -> int: +def cmd_reconcile_signal(*, pace: bool = False, apply: bool = False) -> int: """Спек `graceful-shutdown`, разовый проход сверки, прерванный сигналом, — код 1: на стенде проекта compose из окружения (`COMPOSE_PROJECT_NAME` и др., рабочий `mtusi-lab4` — отказ, код 2) `docker compose pause s3`, @@ -3721,9 +3744,15 @@ def cmd_reconcile_signal(*, pace: bool = False) -> int: «Started cleaner» — `docker stop`; S3 размораживается в `finally`. `pace` — вместо замороженного S3 пауза предела скорости: объекты пробы, `reconcile --max-objects-per-second 1` (dry-run), `docker stop` через - 2 с после «Started cleaner», остановка не дольше секунды; объекты - удаляются в `finally`. Таблица и записи процесса без секретов; код 1 - при расхождении.""" + 2 с после «Started cleaner», остановка не дольше секунды, итог называет + ключи страницы (`listed_objects`); объекты удаляются в `finally`. + `pace` и `apply` (verify W1) — объекты пробы без строки, через grace + `reconcile --apply` с тем же пределом и `docker stop` посреди удалений: + каждое удалённое — запись «Fixed» и счёт `fixed`. Таблица и записи + процесса без секретов; код 1 при расхождении.""" + if apply and not pace: + print("reconcile-signal: --apply is a variant of --pace") + return 2 try: config = json.loads(compose("config", "--format", "json")) except (RuntimeError, ValueError) as e: @@ -3750,12 +3779,29 @@ def cmd_reconcile_signal(*, pace: bool = False) -> int: after_signal = -1.0 exit_code = "" logs = "" + left = -1 + tails: list[str] = [] + run_env: list[str] = [] if pace: - rs_pace_objects("put") + if apply: + tails = [ + f"{uuid.uuid4()}/original" for _ in range(RS_PACE_OBJECTS) + ] + else: + tails = [f"pace-signal-{i}" for i in range(RS_PACE_OBJECTS)] + rs_pace_objects("put", tails) 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" + if apply: + args.append("--apply") + grace = RS_PACE_APPLY_GRACE_S + run_env = ["-e", f"CLEANER__PENDING_GRACE_SECONDS={grace}"] + after_start = RS_PACE_APPLY_AFTER_START_S + waiting = "the rate limit pause after a DELETE" + print(f"waiting {grace + 1} s: probe objects older than grace") + time.sleep(grace + 1) else: compose("pause", "s3") print(f"{project}: s3 paused") @@ -3763,7 +3809,16 @@ def cmd_reconcile_signal(*, pace: bool = False) -> int: after_start, limit = RS_AFTER_START_S, float(RS_STOP_LIMIT_S) waiting = "paused S3" try: - compose("run", "-d", "--no-deps", "--name", name, "cleaner", *args) + compose( + "run", + "-d", + "--no-deps", + "--name", + name, + *run_env, + "cleaner", + *args, + ) deadline = time.monotonic() + RS_START_TIMEOUT_S while time.monotonic() < deadline: logs = docker_logs(name) @@ -3821,7 +3876,13 @@ def cmd_reconcile_signal(*, pace: bool = False) -> int: finally: subprocess.run(["docker", "rm", "-f", name], capture_output=True) if pace: - rs_pace_objects("delete") + if apply: + lines = rs_pace_objects("count", tails).strip().splitlines() + counted = lines[-1].split() if lines else [] + if counted[:1] == ["present"]: + left = int(counted[1]) + print(f"{project}: probe objects left after the pass: {left}") + rs_pace_objects("delete", tails) print(f"{project}: probe objects deleted") else: compose("unpause", "s3") @@ -3832,9 +3893,11 @@ def cmd_reconcile_signal(*, pace: bool = False) -> int: 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") + shown += ("reconcile_max_objects_per_second", "reconcile_apply") + shown += ("kind", "action", "object_key", "listed_objects", "found") + shown += ("fixed", "storage_objects", "s3_requests") + shown += ("max_objects_per_second", "duration_ms", "interrupted_by") + shown += ("exit_code", "timestamp") print("== records of the one-off reconcile") for record in records: print( @@ -3847,6 +3910,8 @@ def cmd_reconcile_signal(*, pace: bool = False) -> int: stopped = [ item for item in records if item.get("event") == "Stopped cleaner" ] + # удалённые до сигнала объекты пробы: каждый — запись «Fixed» и fixed + deleted = RS_PACE_OBJECTS - left if left >= 0 else -1 print( f"docker stop took {took:.1f} s, container exited " f"{after_signal:.2f} s after the kill event, exit code " @@ -3867,7 +3932,7 @@ def cmd_reconcile_signal(*, pace: bool = False) -> int: ), ( "Fixed storage discrepancy records", - "0", + str(deleted) if apply else "0", str(len(rc_events(records, RC_FIXED))), ), ( @@ -3895,16 +3960,47 @@ def cmd_reconcile_signal(*, pace: bool = False) -> int: "-" if rate is None else f"{float(rate):g}", ), ) - return report_reconcile( - rows, - passed=( + # ключи страницы, после которой пришёл сигнал, — в итоге (verify W1) + rows.append( + ( + "Finished reconcile pass listed_objects", + str(RS_PACE_OBJECTS), + str(finished.get("listed_objects")), + ), + ) + if apply: + fixed = finished.get("fixed") + rows += [ + ( + "probe objects deleted before the signal", + ">0", + ">0" if deleted > 0 else str(deleted), + ), + ( + "Finished reconcile pass fixed orphan_object", + str(deleted), + str( + fixed.get("orphan_object", 0) + if isinstance(fixed, dict) + else "-", + ), + ), + ] + if apply: + passed = ( + "one-off reconcile --apply stopped by SIGTERM during the rate " + "limit pause: exit 1 within a second, every deleted object fixed" + ) + elif pace: + 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" - ), - ) + ) + else: + passed = ( + "one-off reconcile stopped by SIGTERM: exit 1, nothing changed" + ) + return report_reconcile(rows, passed=passed) def docker_logs(name: str) -> str: @@ -5143,6 +5239,7 @@ def main() -> int: stress.add_argument("--clients", type=int, default=4) signal_cmd = sub.add_parser("reconcile-signal") signal_cmd.add_argument("--pace", action="store_true") + signal_cmd.add_argument("--apply", 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) @@ -5256,7 +5353,7 @@ def main() -> int: clients=args.clients, ) if args.cmd == "reconcile-signal": - return cmd_reconcile_signal(pace=args.pace) + return cmd_reconcile_signal(pace=args.pace, apply=args.apply) if args.cmd == "s3-idle": return cmd_s3_idle( port, diff --git a/AGENTS.md b/AGENTS.md index 594b7a56..4db0ff04 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -66,9 +66,9 @@ max_objects_per_second` (2000 объектов S3/с), отказ по пред дельты уже синхронизированы в основные спеки), спеки синхронизированы (новые capability: с `s3-storage` — `object-storage`, с `attachments` — `attachments`, с -`upload-consistency` — `storage-consistency`); в `KNOWN_ISSUES.md` три открытые записи (bootstrap после удаления +`upload-consistency` — `storage-consistency`); в `KNOWN_ISSUES.md` четыре открытые записи (bootstrap после удаления bucket; уборщик -удаляет объект зависшей загрузки по ключу вне своего префикса; 408 LB на медленные заголовки текстом HAProxy). Отчёт, evidence и рабочий план лабы 3 остались в её +удаляет объект зависшей загрузки по ключу вне своего префикса; 408 LB на медленные заголовки текстом HAProxy; поля `float` настроек принимают `inf`). Отчёт, evidence и рабочий план лабы 3 остались в её репозитории (`REPORT.md`, `evidence/`, `git show 063eedb:PLAN.md`). Стек: Python 3.12, uv, FastAPI, pydantic v2, pydantic-settings, structlog (JSON в stdout), redis-py (клиент Valkey), aiobotocore @@ -394,9 +394,9 @@ structlog (JSON в stdout), redis-py (клиент Valkey), aiobotocore | `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 [--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` | +| `driver.py reconcile-signal [--pace [--apply]]` | только не рабочий проект 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 с, `listed_objects` — ключи страницы; `--pace --apply` (verify W1) — объекты пробы без строки, grace 18 с, `reconcile --apply`, `docker stop` посреди удалений: записей «Fixed» и `fixed` столько же, сколько удалено; объекты удаляются в `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 не идёт | +| `make bench_reconcile_quick` | то же на 2 000 × 4 KiB, по одному проходу каждого вида, окна 5 с, S4 с 300 кандидатами (~4 мин: 3,7 мин на шумном хосте), метка `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` прежнего образа упадёт на новой ревизии) | @@ -461,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. С 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) + services/attachment_reconcile.py # AttachmentReconcileService(db_scope, storage): сверка bucket и БД — S3 → БД (страницы списка, выборка на страницу, множество ключей), БД → S3 (keyset ready; ключ строки вне префикса вложений — чужой объект без HEAD; строка с ключом /original другого вложения — HEAD её объекта, verify W2), зависшие, перепроверка в БД и 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 с; сигнал прекращает паузу, останавливает следующий check_stop — verify W1), ранний отказ по пределу (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 @@ -479,7 +479,7 @@ src/ s3/instance.py # глобал object_storage процесса API, namespace — имя базы; start() и aclose() в lifespan schemas/ dataclasses/.py # DTO между repo → service → api - enums/.py # StrEnum доменов, RunModeEnum; attachment.py — AttachmentStatus, ImageType, ReconcileFinding, ReconcileAction + enums/.py # StrEnum доменов, RunModeEnum; attachment.py — AttachmentStatus, ImageType, ReconcileFinding, ReconcileAction, ReconcileStrategy (batch, head) utils/ constants.py # лимиты контракта (с лабы 4 — 10 MiB, 40 млн пикселей, filename, 10 вложений), размер страницы, префиксы путей, имя bucket S3, разделитель и части ключа объекта, keep-alive клиента S3 image.py # inspect_image: структурная проверка PNG/JPEG без декодирования пикселей (stdlib), тип, размеры, UnsupportedImage / DamagedImage / TooManyPixels diff --git a/KNOWN_ISSUES.md b/KNOWN_ISSUES.md index 69b2b12b..536aa4cb 100644 --- a/KNOWN_ISSUES.md +++ b/KNOWN_ISSUES.md @@ -81,3 +81,25 @@ либо поднять `timeout http-request` и назвать ограничение в `REPORT.md` (уже названо в спеке `load-balancing`, «Ошибки балансировщика в формате контракта»). + +## Поля `float` настроек принимают `inf` + +- **Где:** `src/config/settings.py` — все поля `float` с `gt=0` или + `ge=0`, кроме `[reconciler] max_objects_per_second`: сроки `[database]`, + `[cache]`, `[s3]`, `[uploads]`, `[cleaner] interval_seconds`, + `[reconciler] interval_seconds`. Найдено verify change + `track2-reconcile-cost` (S2) на `max_objects_per_second`; там исправлено + (`allow_inf_nan=False`), остальные поля — вне change. +- **Что:** pydantic принимает `inf` (`RECONCILER__INTERVAL_SECONDS=inf`, + `UPLOADS__WAIT_TIMEOUT_SECONDS=inf`): `inf > 0` верно. `nan` отсекают + `gt` и `ge`. Записи старта («Started API», «Started cleaner») выводят + значение как `Infinity` — это не JSON, и разбор журнала по строкам + ломается. +- **Чем грозит:** оператор, ошибившийся в значении, получает срок без + конца (ожидание места загрузки, вызов S3 без срока, плановая сверка, + которая не наступит) и журнал, который не разбирается как JSON. + Значения по умолчанию и `config_example.toml` не затронуты. +- **Предложение:** `allow_inf_nan=False` у каждого поля `float` (или + `model_config = ConfigDict(allow_inf_nan=False)` у секций), сценарий в + требовании «Некорректное значение останавливает запуск» спека + `service-configuration` и проверка `uv run python -c` с `inf` по полям. diff --git a/Makefile b/Makefile index c432a484..da857510 100644 --- a/Makefile +++ b/Makefile @@ -383,7 +383,7 @@ bench_reconcile: # то же коротко (самопроверка): 2 000 × 4 KiB, по одному проходу каждого # вида, окна под нагрузкой по 5 с, отказ по пределу с 300 кандидатами, -# ~6 мин; в git не идёт +# ~4 мин (3,7 мин на шумном хосте, 2026-10-23); в 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) diff --git a/PLAN.md b/PLAN.md index 1fea0ed4..ec3c1b70 100644 --- a/PLAN.md +++ b/PLAN.md @@ -1611,6 +1611,35 @@ design, «Уточнения apply», пп. 1–13): `api-27`, `api-28`), `make student_test BASE_URL=http://localhost:8090` — 198 passed. +#### Правки по verify + +Verify на `16f2cde`: CRITICAL нет; W1–W3 и S1–S10 — группа 12 +`tasks.md`, решения — design, «Правки по verify», пп. 1–8. Коротко: + +1. W1: `_pace` по сигналу возвращается, проход останавливает следующий + `check_stop()`. Красный прогон на `16f2cde` — `driver.py + reconcile-signal --pace`: `listed_objects` 0 при 8 ключах; новый + режим `--pace --apply`: удалено 4 объекта, «Fixed» и `fixed` — 3. +2. W2: правильно поведение `head` — строка сравнивается с объектом по + своему ключу, чей бы `id` в нём ни стоял; `batch` выровнен (HEAD + такой строки в шаге строк). Тест `test_reconcile_row_with_other_id_key` + красный на `16f2cde` (`batch` не назвал ни `size_mismatch`, ни + `checksum_mismatch` у Y1, Y2). Метка `baseline` действительна: у + строк её набора свои ключи. +3. S1: свежесть объекта другого размера — в классификации, перепроверке + и перед пометкой; «другой SHA-256» перечитывается с `fresh_before`. + Тест `test_reconcile_fresh_overwrite_untouched` красный на `16f2cde` + (объект другого размера, перезаписанный только что, помечен). +4. S2: `allow_inf_nan=False` у `max_objects_per_second`; на образе + `16f2cde` `inf` проходил — «Started cleaner» с `Infinity`. Прочие + поля `float` — `KNOWN_ISSUES.md`. +5. S4, S6, S9 — `bench/reconcile.py`, `run.py`: допуск строк по + `vus_max`, критерии вердиктов, пометки `bg_failed` / `bg_dropped`. + Офлайн-пересборки `summary.md` нет; новые критерии на данных метки + пересчитаны скриптом scratchpad — все выполняются, вердикты те же. +6. S8: спек `load-benchmark` называет исключение для группы из одной + ячейки; S5, S7, S10, W3 — тексты `REPORT.md` и design. + #### Вопросы Нет. Вопрос 1 раздела `### track2-reconciler` (ответ API на потерянный diff --git a/REPORT.md b/REPORT.md index 8081e82c..b9f1a3a1 100644 --- a/REPORT.md +++ b/REPORT.md @@ -751,8 +751,11 @@ reconcile`) получил три аргумента; плановая свер - **Стоимость в итоге.** «Finished reconcile pass» называет объекты S3 (`storage_objects`), запросы S3 по операциям (`s3_requests`), прочитанные байты (`read_bytes`), сеансы БД (`db_sessions`) и - длительность шагов (`phase_ms`). Метка сверяет их с метриками шлюза S3 - и `pg_stat_database`, расхождений нет. + длительность шагов (`phase_ms`). Запросы S3 метка сверяет с метриками + шлюза S3 (в проходах без фона — точное равенство, расхождений нет). + `pg_stat_database` рядом — только справочный счёт: транзакций около + двух на сеанс (`pool_pre_ping` и проверки LB дают свои), равенства с + `db_sessions` нет и не требуется (design, решение 8). ### Согласования с преподавателем @@ -1225,6 +1228,29 @@ Grace проходов — 30 с. Без фоновой нагрузки про - Найденное в каждом проходе равно внесённому по классам, `listed_objects` и `checked_rows` равны модели набора, пометок `count_mismatch` нет: счёт сверки совпал с метриками шлюза S3. +- **Вердикты после verify.** Verify (S6) нашёл, что вердикты + `bench/reconcile.py` проверяли не все критерии гипотез: сеансы + PostgreSQL в H1 (и LIST — с допуском ±1), «~18 против ~2000» запросов + на 1000 объектов в H2, GET на каждую строку в H3, неизменность данных + в S4. Критерии добавлены (LIST и сеансы — точно, H2 — ±25 %, S4 — + ни одного исправления в итоге и записей «Fixed»). Пути пересобрать + `summary.md` метки офлайн у стенда нет, и ради этого он не заводился: + `summary.md` метки посчитан прежним кодом. Новые критерии на данных + метки (`passes.csv`, `windows.csv`, `raw/*-cleaner.json`) пересчитаны + отдельно — все выполняются, вердикты те же: LIST 11 / 31 / 101 и + сеансов 96 / 286 / 953 равны ожидаемым, 18,2 / 18,1 против 2015, GET + 9 900 / 988 / 988 — по строке того же размера с объектом, у S4 `fixed` + пуст во всех 12 проходах. Ошибок фона по всему итогу k6 тоже нет: + `http_req_failed` 0 из 356 170, `dropped_iterations` нет (S9). +- **Метка и правка W2.** После метки verify (W2) нашёл, что `batch` не + сравнивал с объектом строку, ключ которой — `/original` другого + вложения (`head` сравнивал). Исправлено в пользу `head`: каждая строка + сверяется с объектом по своему ключу (спек `storage-consistency`, + «Строка ссылается на объект другого id»). Метка остаётся + действительной: в её наборе у каждой строки свой ключ + (`<база>/attachments/<свой id>/original`, `reconcile.rows_csv`), новая + ветка на нём не срабатывает, лишних запросов S3 и PostgreSQL не + добавляет; на строку прибавилось одно сравнение ключа со своим. Проходы без фоновой нагрузки. Медианы трёх повторов из `summary.md`, разброс там же. «мкс/объект» — длительность прохода / N, CPU — средние @@ -1258,11 +1284,26 @@ CPU — диапазон трёх повторов из `passes.csv` (`cpu_clean Отказ по пределу (S4), `--apply --max-changes 100`, 10 000 согласованных объектов: -| Кандидатов | «До» (`7f4e626`), с | «После», с | Проход без кандидатов (B `batch`), с | HEAD «после» | Не перепроверено | Код | +| Кандидатов | «До» (`7f4e626`), с | «После», с | База — B `batch` (10k, dry-run), с | HEAD «после» | Не перепроверено | Код | | --- | --- | --- | --- | --- | --- | --- | | 1 000 | 7,99 | 3,08 | 2,81 | 101 | 899 | 3 / 3 | | 10 000 | 59,28 | 3,41 | 2,81 | 101 | 9 899 | 3 / 3 | +База S4 — не «проход без кандидатов», как названа в гипотезах выше и в +`summary.md` метки: у B `batch` 75 перепроверок (объекты без строки, +строки без объекта, другой размер) и 25 зависших загрузок; шаг +перепроверки — 0,49–0,51 с прохода (`phase_recheck_ms`). «После» перепроверяет 101 кандидата, поэтому его прирост над +базой мерит цену отказа без лишних перепроверок, а не нулевую; вердикт +от этого не меняется: +0,27 и +0,60 с меньше порога 1 с (замечание S5 +verify, метка не переснималась). + +Повторы D `batch` (r1–r3) в метке идут подряд: в группе без нагрузки на +этапе D одна ячейка, остальные проходы этого набора — блок под фоновой +нагрузкой. Спек `load-benchmark` это исключение теперь называет +(замечание S8 verify). Разброс повторов D `batch` — 30,7–32,2 с (5 %), +у C `batch`, где повторы чередуются с `head`, — 9,1–9,6 с (5 %): шума +от порядка повторов не видно. + Выводы (раздел «Гипотезы» `summary.md`): - **H1 — подтверждена.** Цена `batch` на объект — 281 / 311 / 320 мкс при @@ -1315,12 +1356,12 @@ CPU — диапазон трёх повторов из `passes.csv` (`cpu_clean рабочем стенде (2–3 тыс. объектов) — около секунды в час. Поэтому 2000 оставлен как страховка доли S3 для быстрого уборщика (design, «Risks»), а не как доказанная защита задержек. Влияние на задержки - будет там, где шлюз близок к насыщению: больше фоновой нагрузки, + может проявиться там, где шлюз близок к насыщению: больше фоновой нагрузки, медленнее S3. Его метка не воспроизводит. Чтобы H4 проверить, нужен контраст, который насыщает S3: например, `fast-unlimited` при S3 с 0,5 CPU или с фоном в 2–3 раза больше. Это смена методики и новая метка; в этот change она не входит. -- **S4 — подтверждена.** «До» длиннее прохода без кандидатов на 5,2 с +- **S4 — подтверждена.** «До» длиннее базы (B `batch`) на 5,2 с при 1 000 кандидатах и на 56,5 с при 10 000 (ожидалось ~5 и ~50 с: ~5 мс на кандидата). «После» — на 0,27 и 0,60 с (порог 1 с), HEAD — 101 = `max_changes + 1`, не перепроверено 899 и 9 899. Коды — 3 у обоих, @@ -1328,8 +1369,11 @@ CPU — диапазон трёх повторов из `passes.csv` (`cpu_clean **Выбор предела 2000.** Ключ списка стоит шлюзу 0,100 мс CPU (D `batch`: 0,315 ядра × 31,9 с / 100 501 объект S3). При 2000 объектов в -секунду это ~0,2 ядра S3 из 1, и столько же метка показала у `stand` и -`fast-limited` вместе с фоном. Естественная скорость `batch` на 0,25 CPU +секунду это ~0,2 ядра S3 из 1 — оценка по цене ключа, а не замер. У +`stand` и `fast-limited` метка показала 0,27–0,32 ядра S3 за окно +прохода, но это вместе с фоновыми скачиваниями: сколько из этого +приходится на одну сверку, метка не выделяет (тихого окна без прохода с +CPU S3 в ней нет). Естественная скорость `batch` на 0,25 CPU — ~3 100 объектов/с за проход, с 1 CPU под фоновой нагрузкой — ~7 800/с; предел срезает обе до 2000. diff --git a/bench/reconcile.py b/bench/reconcile.py index f2befd21..2662654b 100644 --- a/bench/reconcile.py +++ b/bench/reconcile.py @@ -110,6 +110,9 @@ CELLS: dict[str, dict[str, Any]] = { } LOAD_CELLS = ("stand", "stand-unlimited", "fast-unlimited", "fast-limited") LIMITED_LOAD = ("stand", "stand-unlimited", "fast-limited") +# пометки ошибок фоновой нагрузки у проходов блока H4: 5xx окон, неуспешные +# запросы и недосланные итерации по всему итогу k6 (verify S9) +BG_FLAGS = ("bg_5xx", "bg_failed", "bg_dropped") # сценарии фоновой нагрузки: скачивания, запись, чтение истории SCENARIOS = {"d": "download", "w": "write", "r": "read"} WINDOWS = ("before", "pass", "after") @@ -118,6 +121,11 @@ H1_SPREAD = 0.20 H1_BYTES_PER_KEY = 300 H2_TIME_RATIO = 10 H2_HEAD_GROWTH_MIB = 5 +# H2: запросов S3 и сеансов PostgreSQL на 1000 объектов — «~18 против +# ~2000» при 1 % расхождений, допуск ±25 % (verify S6) +H2_BATCH_PER_K = 18 +H2_HEAD_PER_K = 2000 +H2_PER_K_TOLERANCE = 0.25 H3_DEEP_RATIO = 5 H3_MS_PER_MIB = 5 H3_CLEANER_SHARE = 0.9 @@ -126,6 +134,11 @@ H3_FAST_RATIO = 1.5 H4_THRESHOLD = 1.5 S4_AFTER_EXTRA_MS = 1000 S4_MS_PER_CANDIDATE = 5 +# размер страницы списка и строк (`[reconciler] page_size`) и выборки +# зависших (`[cleaner] batch_size`) — значения по умолчанию, их берут +# проходы стенда; по ним H1 считает ожидаемые LIST и сеансы +PAGE_SIZE = 1000 +STALE_BATCH = 100 # записи журнала уборщика, которые идут в raw/<проход>-cleaner.json STARTED = "Started cleaner" FINISHED = "Finished reconcile pass" @@ -194,6 +207,10 @@ PASS_FIELDS = [ "mem_peak_mib", "mem_growth_bytes_per_object", "flags", + # с verify S6: исправлено проходом по итогу и записей «Fixed» — + # неизменность данных у отказа по пределу (S4) + "fixed_total", + "fixed_records", ] WINDOW_FIELDS = [ "pass", @@ -363,7 +380,10 @@ def plan_passes( ) -> list[dict[str, Any]]: """Проходы этапов кругами: в круге r — перестановка ячеек этапа генератором `Random(seed + номер этапа × 100 + r)`, круг не начинается - с ячейки, которой кончился прежний (как `uploads.plan_runs`).""" + с ячейки, которой кончился прежний (как `uploads.plan_runs`). У группы + из одной ячейки (D без нагрузки — только `batch`) повторы идут подряд: + остальные проходы набора — блок под нагрузкой (спек `load-benchmark`, + «Профиль сверки», verify S8).""" plan: list[dict[str, Any]] = [] for stage_no, (stage, cells) in enumerate(stages): previous = None @@ -537,6 +557,29 @@ def summary_count(k6_data: dict[str, Any], name: str) -> int | None: return None if count is None else int(count) +def background_errors(k6_data: dict[str, Any]) -> dict[str, int]: + """Ошибки фоновой нагрузки по всему итогу k6, а не по окнам (verify + S9): неуспешные запросы (`http_req_failed`: у Rate-метрики `passes` — + число неуспешных) и недосланные итерации (`dropped_iterations`).""" + metrics = k6_data.get("metrics", {}) + failed = metrics.get("http_req_failed", {}).get("values", {}) + dropped = metrics.get("dropped_iterations", {}).get("values", {}) + return { + "failed": int(failed.get("passes", 0) or 0), + "dropped": int(dropped.get("count", 0) or 0), + } + + +def background_flags(errors: dict[str, int]) -> list[str]: + """Пометки проходов блока по `background_errors`.""" + flags = [] + if errors.get("failed"): + flags.append("bg_failed") + if errors.get("dropped"): + flags.append("bg_dropped") + return flags + + def line_problems( requests: list[Request], k6_data: dict[str, Any], @@ -549,11 +592,17 @@ def line_problems( счётчике `bg_lines_<сценарий>`: у прерванной строка может быть, а отсчётов нет. Поэтому снизу — строк не меньше итераций и не меньше счётчика (у каждой завершённой итерации строка есть: пропажу видно), - сверху — лишних строк против каждого из них не больше VU сценария - (столько итераций может быть в полёте). Возвращает расхождения и число + сверху — лишних строк против каждого из них не больше VU сценария и + не больше VU, созданных k6 за прогон (`vus_max` итога): столько + итераций может быть в полёте. Возвращает расхождения и число прерванных (строк сверх итераций) по сценариям.""" problems = [] interrupted: dict[str, int] = {} + # в полёте не больше VU, созданных k6 за прогон (`vus_max` итога — + # на все сценарии), и не больше VU сценария (verify S4) + created = k6_data.get("metrics", {}).get("vus_max", {}).get("values", {}) + if created.get("max") is not None: + max_vus = min(max_vus, int(created["max"])) for kind, scenario in SCENARIOS.items(): lines = sum(1 for r in requests if r.kind == kind) counted = summary_count(k6_data, f"bg_lines_{scenario}") @@ -845,6 +894,8 @@ def pass_row( if pg is not None: row.update(pg) row["flags"] = " ".join(flags) + row["fixed_total"] = sum((finished.get("fixed") or {}).values()) + row["fixed_records"] = kept.get("fixed_records") return row @@ -1002,6 +1053,45 @@ def stage_n(meta: dict[str, Any], stage: str) -> int | None: return None +def expected_batch_requests(row: dict[str, Any]) -> tuple[int, int, int]: + """LIST, HEAD и сеансы PostgreSQL поверхностного dry-run `batch` по + модели прохода (H1): страницы списка (страница без ключей — только у + пустого bucket) и проба bucket, если есть кандидаты без объекта или с + другим размером; HEAD — по одному на такого кандидата и объект без + строки; сеанс — на страницу списка с ключами, на каждую страницу строк + `ready` и выборку зависших (последняя — неполная) и на перепроверку + кандидата, кроме зависших.""" + + def count(column: str) -> int: + return int(num(row.get(column)) or 0) + + objects, ready = count("objects"), count("ready_rows") + orphan, missing = ( + count("expected_orphan_object"), + count( + "expected_missing_object", + ), + ) + size, stale = ( + count("expected_size_mismatch"), + count( + "expected_stale_pending", + ), + ) + probe = 1 if missing or size else 0 + lists = max(1, math.ceil(objects / PAGE_SIZE)) + probe + heads = orphan + missing + size + sessions = ( + math.ceil(objects / PAGE_SIZE) + + ready // PAGE_SIZE + + 1 + + stale // STALE_BATCH + + 1 + + heads + ) + return lists, heads, sessions + + def verdict_h1(meta: dict[str, Any], passes: list[dict[str, Any]]) -> Verdict: """Линейность `batch`: цена на объект, запросы S3, сеансы, память.""" stages = [ @@ -1028,20 +1118,19 @@ def verdict_h1(meta: dict[str, Any], passes: list[dict[str, Any]]) -> Verdict: 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 + want_list, want_head, want_sessions = expected_batch_requests(row) + got_list = cell_median(passes, s, "batch", "s3_list") + got_head = cell_median(passes, s, "batch", "s3_head") + got_sessions = cell_median(passes, s, "batch", "db_sessions") + # счёт точный: набор неизменен, допуска нет (verify S6) + ok_requests &= got_list == want_list ok_requests &= got_head == want_head + ok_requests &= got_sessions == want_sessions 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)}", + f"{fmt(got_sessions, 0)} (ожидалось {want_sessions})", ) slope = memory_slope(passes, stages, "batch") memory_ok = slope is not None and slope <= H1_BYTES_PER_KEY @@ -1056,6 +1145,8 @@ def verdict_h1(meta: dict[str, Any], passes: list[dict[str, Any]]) -> Verdict: "H1", f"цена на объект `batch` различается не больше чем на " f"{H1_SPREAD:.0%}; LIST = ⌈N/1000⌉ + 1, HEAD — только у кандидатов; " + "сеансов — по одному на страницу списка, страницу строк `ready` и " + "выборку зависших плюс по одному на кандидата, кроме зависших; " f"прирост пика памяти уборщика от N ≤ {H1_BYTES_PER_KEY} Б на ключ", f"разброс цены {fmt(spread_pct, 1)} %, наклон пика памяти " f"{fmt(slope, 0)} Б на ключ", @@ -1124,6 +1215,16 @@ def verdict_h2(meta: dict[str, Any], passes: list[dict[str, Any]]) -> Verdict: return total / n * 1000 ok &= time_ratio is not None and time_ratio >= H2_TIME_RATIO + # «~18 против ~2000» запросов S3 и сеансов на 1000 объектов + for cell, target in ( + ("batch", H2_BATCH_PER_K), + ("head", H2_HEAD_PER_K), + ): + value = per_k(cell) + ok &= ( + value is not None + and abs(value - target) <= target * H2_PER_K_TOLERANCE + ) details.append( f"{s}: HEAD / batch по времени {fmt(time_ratio, 1)}×; запросов " f"S3 и сеансов на 1000 объектов — batch {fmt(per_k('batch'), 1)}, " @@ -1136,7 +1237,9 @@ def verdict_h2(meta: dict[str, Any], passes: list[dict[str, Any]]) -> Verdict: ) return Verdict( "H2", - f"HEAD дороже `batch` по времени на объект ≥ {H2_TIME_RATIO}×, " + f"HEAD дороже `batch` по времени на объект ≥ {H2_TIME_RATIO}×; " + f"запросов S3 и сеансов на 1000 объектов — ~{H2_BATCH_PER_K} у " + f"`batch` и ~{H2_HEAD_PER_K} у HEAD (±{H2_PER_K_TOLERANCE:.0%}); " f"пик памяти HEAD от N растёт не больше чем на {H2_HEAD_GROWTH_MIB} " "МиБ", "; ".join(details), @@ -1156,6 +1259,26 @@ def verdict_h3(meta: dict[str, Any], passes: list[dict[str, Any]]) -> Verdict: return Verdict("H3", "глубокая дороже", "нет ячеек", UNTESTED) checks = [] details = [] + # GET на каждую строку того же размера с объектом (verify S6): строки + # `ready` без объекта и с другим размером не читаются + for stage, cell in ( + (small, "deep"), + (large, "deep"), + (large, "deep-fast"), + ): + rows = cell_rows(passes, stage, cell) + if not rows: + continue + row = rows[0] + want_get = int(num(row.get("ready_rows")) or 0) - sum( + int(num(row.get(f"expected_{kind}")) or 0) + for kind in ("missing_object", "size_mismatch") + ) + got_get = cell_median(passes, stage, cell, "s3_get") + checks.append(got_get == want_get) + details.append( + f"{stage} {cell}: GET {fmt(got_get, 0)} (ожидалось {want_get})", + ) deep_ratio = ratio(deep_small, batch_small) if deep_ratio is not None: checks.append(deep_ratio >= H3_DEEP_RATIO) @@ -1187,8 +1310,9 @@ def verdict_h3(meta: dict[str, Any], passes: list[dict[str, Any]]) -> Verdict: holds = bool(checks) and all(checks) return Verdict( "H3", - f"глубокая на 4 KiB дороже `batch` ≥ {H3_DEEP_RATIO}×; ≥ " - f"{H3_MS_PER_MIB} мс на MiB; на лимите стенда — CPU уборщика ≥ " + f"глубокая на 4 KiB дороже `batch` ≥ {H3_DEEP_RATIO}×, GET на " + f"каждую строку того же размера; ≥ {H3_MS_PER_MIB} мс на MiB; на " + "лимите стенда — CPU уборщика ≥ " f"{H3_CLEANER_SHARE:.0%} лимита, S3 ≤ {H3_S3_CORES} ядра; с 1 CPU " f"быстрее ≥ {H3_FAST_RATIO}×", "; ".join(details), @@ -1197,7 +1321,13 @@ def verdict_h3(meta: dict[str, Any], passes: list[dict[str, Any]]) -> Verdict: ) -def verdict_h4(window_rows: list[dict[str, Any]]) -> Verdict: +def verdict_h4( + window_rows: list[dict[str, Any]], + passes: Iterable[dict[str, Any]] = (), +) -> Verdict: + """Порог решения 10. Ошибки фона — 5xx окон и пометки проходов + `bg_5xx`, `bg_failed` (`http_req_failed` итога k6), `bg_dropped` + (`dropped_iterations`): с ними H4 не подтверждается.""" ratios = load_ratios(window_rows) if not ratios: return Verdict( @@ -1224,6 +1354,18 @@ def verdict_h4(window_rows: list[dict[str, Any]]) -> Verdict: if cell in LIMITED_LOAD and (r is None or r > H4_THRESHOLD): holds = False details.append(f"{cell}: " + ", ".join(parts)) + flagged = sorted( + { + flag + for row in passes + if row.get("cell") in LOAD_CELLS + for flag in str(row.get("flags") or "").split() + if flag in BG_FLAGS + }, + ) + if flagged: + fives = True + details.append("пометки фона: " + ", ".join(flagged)) contrast = ratios.get("fast-unlimited", {}).get("download", {}).get("r") if fives: verdict = REFUTED if not holds else UNTESTED @@ -1256,11 +1398,20 @@ def verdict_s4(meta: dict[str, Any], passes: list[dict[str, Any]]) -> Verdict: 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) + both = [ + row for cell in ("before", "after") for row in cell_rows(passes, stage, cell) - } + ] + codes = {int(num(row["exit_code"]) or -1) for row in both} + # данные не менялись (verify S6): ни одного исправления в итоге и + # ни одной записи «Fixed»; нет столбца (метка до правки) — не + # доказано + unchanged = all( + num(row.get("fixed_total")) == 0 + and num(row.get("fixed_records")) == 0 + for row in both + ) if before is None or after is None: continue extra_before = None if base is None else before - base @@ -1271,21 +1422,24 @@ def verdict_s4(meta: dict[str, Any], passes: list[dict[str, Any]]) -> Verdict: ) checks.append(heads is not None and heads <= limit + 1) checks.append(codes == {3}) + checks.append(unchanged) 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)}", + f"с), HEAD после {fmt(heads, 0)}, коды {sorted(codes)}, данные " + f"{'не менялись' if unchanged else 'менялись или не известны'}", ) if not checks: return Verdict("S4", "цена отказа", "нет ячеек", UNTESTED) return Verdict( "S4", - f"после — не дольше прохода без кандидатов на " - f"{S4_AFTER_EXTRA_MS / 1000:.0f} с, HEAD ≤ предела + 1, код 3 у " - "обоих", + f"после — не дольше базы на {S4_AFTER_EXTRA_MS / 1000:.0f} с (база " + f"— поверхностный dry-run `batch` этапа {base_stage} того же N: " + "перепроверка его кандидатов и выборка зависших, без отказа по " + "пределу), HEAD ≤ предела + 1, код 3 у обоих, ни одного исправления", "; ".join(details), CONFIRMED if all(checks) else REFUTED, details, @@ -1301,7 +1455,7 @@ def verdicts( verdict_h1(meta, passes), verdict_h2(meta, passes), verdict_h3(meta, passes), - verdict_h4(window_rows), + verdict_h4(window_rows, passes), verdict_s4(meta, passes), ] @@ -1823,6 +1977,38 @@ def selftest() -> int: len(line_problems(parsed, {"metrics": {}}, max_vus=5)[0]), 3, ) + # верхний допуск — не больше VU, созданных k6 (`vus_max` итога) + capped = summary(4, 0) + capped["metrics"]["vus_max"] = {"values": {"max": 3}} + expect( + "lines over vus_max", + len(line_problems(parsed, capped, max_vus=5)[0]), + 1, + ) + capped["metrics"]["vus_max"] = {"values": {"max": 300}} + expect( + "lines vus_max above scenario VU", + line_problems(parsed, capped, max_vus=5)[0], + [], + ) + # ошибки фона по всему итогу k6 + k6_errors = { + "metrics": { + "http_req_failed": {"values": {"passes": 2, "fails": 10}}, + "dropped_iterations": {"values": {"count": 1}}, + }, + } + expect( + "bg errors", + background_errors(k6_errors), + {"failed": 2, "dropped": 1}, + ) + expect( + "bg flags", + background_flags(background_errors(k6_errors)), + ["bg_failed", "bg_dropped"], + ) + expect("bg no errors", background_flags(background_errors({})), []) bounds = {"before": (0, 10), "pass": (10, 20), "after": (20, 30)} rows, ratios_one = windows_of(parsed, bounds) expect("window rows", len(rows), 12) @@ -1871,6 +2057,7 @@ def selftest() -> int: round(1_500_000 / 997, 2), ) expect("row fields", set(row) <= set(PASS_FIELDS), True) + expect("row fixed", (row["fixed_total"], row["fixed_records"]), (0, 0)) # вердикты и сводка на синтетических проходах meta = { @@ -1909,6 +2096,7 @@ def selftest() -> int: "cell": cell, "load": cell in LOAD_CELLS, "objects": mdl.objects, + "ready_rows": mdl.ready_rows, "us_per_object": us, "duration_ms": us * mdl.objects / 1000, "s3_list": math.ceil(mdl.objects / 1000) + 1, @@ -1922,25 +2110,54 @@ def selftest() -> int: ), "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": "", + "fixed_total": 0, + "fixed_records": 0, **{f"expected_{k}": mdl.found.get(k, 0) for k in CLASSES}, }, ) + base["db_sessions"] = expected_batch_requests(base)[2] base.update(extra) return base + b_batch = synthetic("B", "batch", 10_000, 300) + expect( + "batch requests B", + expected_batch_requests(b_batch), + (11, 75, 96), + ) + expect( + "batch requests D", + expected_batch_requests(synthetic("D", "batch", 100_000, 300)), + (101, 750, 953), + ) passes = [ - synthetic("B", "batch", 10_000, 300), + b_batch, 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( + "B", + "head", + 10_000, + 5000, + mem_peak_mib=98.0, + s3_head=9950, + db_sessions=10061, + ), + synthetic("B", "deep", 10_000, 2700, s3_get=9900), + synthetic( + "A", + "deep", + 1000, + 10_500, + cpu_cleaner=0.245, + cpu_s3=0.19, + s3_get=988, + ), + synthetic("A", "deep-fast", 1000, 4800, s3_get=988), synthetic( "S4-300", "before", @@ -1963,6 +2180,38 @@ def selftest() -> int: 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) + + def refuted(name: str, index: int, **change: Any) -> None: + """Вердикт `name` опровергнут, если у прохода `index` изменить + столбцы `change` (критерии verify S6).""" + changed = [dict(row) for row in passes] + changed[index].update(change) + verdict = { + item.name: item.verdict for item in verdicts(meta, changed, []) + }[name] + expect(f"verdict {name} refuted by {sorted(change)}", verdict, REFUTED) + + refuted("H1", 0, db_sessions=97) + refuted("H1", 0, s3_list=12) + refuted("H2", 2, db_sessions=500) + refuted("H3", 3, s3_get=9950) + refuted("S4", 7, fixed_total=1) + refuted("S4", 6, fixed_records=None) + # H4: без 5xx окон контраст подтверждает, пометка фона — нет + clean, _ = windows_of([r for r in parsed if r.status < 500], bounds) + expect( + "verdict H4 clean", + verdict_h4(rows_with_cells(clean)).verdict, + CONFIRMED, + ) + expect( + "verdict H4 bg_failed", + verdict_h4( + rows_with_cells(clean), + [{"cell": "fast-unlimited", "flags": "bg_failed"}], + ).verdict, + UNTESTED, + ) summary = render_summary(meta, passes, rows_with_cells(rows)) for needle in ("## Гипотезы", "### H1", "### S4", "| B | 9975 | batch"): if needle not in summary: diff --git a/bench/run.py b/bench/run.py index 9032fee8..8dd684ab 100644 --- a/bench/run.py +++ b/bench/run.py @@ -6475,6 +6475,12 @@ class Bench: self.results.meta["reconcile"].setdefault("bg_interrupted", {})[ stage ] = interrupted + # ошибки фона по всему итогу k6, не только 5xx окон (verify S9) + errors = reconcile.background_errors(k6_data) + self.results.meta["reconcile"].setdefault("bg_errors", {})[stage] = ( + errors + ) + block_flags = reconcile.background_flags(errors) self.results.write_meta() if problems: raise BenchError(f"{stage}: " + "; ".join(problems)) @@ -6504,10 +6510,10 @@ class Bench: ], ) pass_row = result["row"] + flags = [pass_row["flags"], *block_flags] if any(value["s5xx"] for value in ratios.values()): - pass_row["flags"] = " ".join( - filter(None, [pass_row["flags"], "bg_5xx"]), - ) + flags.append("bg_5xx") + pass_row["flags"] = " ".join(filter(None, flags)) self.results.add_pass(pass_row) self.say( f"{entry['pass']}: r " diff --git a/openspec/changes/track2-reconcile-cost/design.md b/openspec/changes/track2-reconcile-cost/design.md index 645f20f5..f4c1e468 100644 --- a/openspec/changes/track2-reconcile-cost/design.md +++ b/openspec/changes/track2-reconcile-cost/design.md @@ -646,8 +646,10 @@ fluentd, а это ещё один сервис. *Альтернатива:* п 10: `stand`, `stand-unlimited` и `fast-limited` — медиана `r` ≤ 1,5 по всем трём сценариям; `fast-unlimited` — `r` скачиваний > 1,5 (проба: 2,2–2,75). -- **S4 — цена отказа по пределу (ожидание, не гипотеза трека).** Проход - без кандидатов — ячейка `batch` этапа B, тот же N = 10k: +- **S4 — цена отказа по пределу (ожидание, не гипотеза трека).** База — + ячейка `batch` этапа B, тот же N = 10k: поверхностный dry-run с 75 + перепроверками и 25 зависшими, без отказа по пределу (прежде здесь — + «проход без кандидатов», что неверно; verify S5): - `before` длиннее него примерно на D × 5 мс: +5 с при 1 000 и +50 с при 10 000; - `after` — не больше чем на 1 с, запросов HEAD — не больше @@ -911,6 +913,71 @@ change» → описано в нём. H4 — новая метка с контрастом, который насыщает S3; в change она не входит. +### Правки по verify + +Verify на `16f2cde`: CRITICAL нет, W1–W3 и S1–S10 (`tasks.md`, группа +12). Решения приняты без пользователя, то же — `PLAN.md`, +`### track2-reconcile-cost`, «Правки по verify». + +1. **W1 — сигнал в паузе предела.** `_pace` по сигналу перестаёт ждать и + возвращается, а не бросает `_Stopped`: вызов перед паузой уже + выполнен, и его итог должен дойти до учёта. Иначе удачный DELETE + (или уборка зависшей) перед паузой терял «Fixed» и счёт `fixed` и + оставался в журнале `warning` «Found», а ключи страницы — в + `listed_objects` (0 при `storage_objects` 8 в прежнем + `evidence/reconcile/service.md`). Остановку делает `check_stop()` + перед следующим вызовом — он стоит перед каждым вызовом хранилища, + поэтому остановка не медленнее. Проверка — `driver.py + reconcile-signal --pace` (строка `listed_objects`) и новый режим + `--pace --apply`: объекты пробы без строки, grace 18 с, `docker stop` + посреди удалений; на `16f2cde` — удалено 4, «Fixed» и `fixed` — 3. + Тест отказов не выбран: hook запускает сверку синхронно, сигнал + посреди прохода он не шлёт. +2. **W2 — строка с ключом `/original` другого `id`.** Правильно + поведение `head`: строка `ready` сравнивается с объектом по ключу из + её метаданных. Объект по ключу и есть её оригинал — его отдаёт API, и + другой размер даёт 500 на скачивании, пока сверка не пометит строку + (спек `attachments`, «Скачивание оригинала»). Требование «Объект, на + который ссылается строка, не удаляется» это не задевает: пометка не + удаляет объект, а `/original` остаётся чужим. `batch` выровнен: + шаг строк делает HEAD строки, ключ которой — `/original` другого + вложения (`_key_of_other_id`: сравнение со своим ключом на каждую + строку, разбор — только у несовпавших), а шаг списка у нестандартного + ключа сравнивает каждую строку этого ключа, а не одну. *Альтернатива:* + выборка страницы по всем ключам (`object_key = ANY`) — строки чужих + ключей пришли бы в шаге списка без HEAD. Отвергнута: выражение страницы + тяжелее на каждой странице ради редкого случая, а цену `batch` уже + измерила метка. *Альтернатива:* `head` выровнять под `batch` (не + сравнивать). Отвергнута: строка осталась бы `ready` с объектом не того + размера и 500 на скачивании. Метка `baseline` действительна: в её + наборе у каждой строки свой ключ (`reconcile.rows_csv`), ветка не + срабатывает и запросов не добавляет. +3. **S1 — свежесть в перепроверке.** Объект другого размера моложе grace + — свежий в классификации (`fresh_objects`), перепроверке и перед + пометкой; «другой SHA-256» перечитывается с `fresh_before`. Вернувшийся + оригинал читается без порога: снять пометку может только тот же + SHA-256, а те же байты свежестью не опасны (`test_reconcile_restored_ + original` кладёт их и сразу запускает `--apply`). Сценарий «Недавно + перезаписанный объект не тронут». +4. **S2.** `allow_inf_nan=False` только у `max_objects_per_second`. Тот же + дефект у прочих полей `float` настроек (сроки, интервалы) — вне change, + `KNOWN_ISSUES.md`. +5. **S4.** Верхний допуск строк фона — меньшее из VU сценария и + `vus_max` итога k6 (на все сценарии). +6. **S6.** Вердикты проверяют LIST и сеансы H1 точно (набор неизменен), + «~18 / ~2000» H2 с допуском ±25 %, GET H3 — по строкам `ready` с + объектом того же размера, S4 — новые столбцы `passes.csv` + `fixed_total` и `fixed_records` в конце. Пересборки `summary.md` + офлайн нет и не заводится; на данных метки новые критерии пересчитаны + скриптом вне репозитория — выполняются (`REPORT.md`). +7. **S8.** У группы из одной ячейки (D без нагрузки) повторы подряд — + уточнён спек, а не план: перемешать их можно только с проходами под + нагрузкой, а это другой блок k6 и другая методика H4. +8. **S9.** `http_req_failed` и `dropped_iterations` итога k6 — пометки + `bg_failed` и `bg_dropped` всех проходов блока (по окнам ошибки не + разложить); `meta.reconcile.bg_errors`; с любой из пометок H4 не + подтверждается. + ## Risks / Trade-offs - **[Предел 2000/с удлиняет плановый проход вдвое]** → на 100k с ~30 до diff --git a/openspec/changes/track2-reconcile-cost/specs/load-benchmark/spec.md b/openspec/changes/track2-reconcile-cost/specs/load-benchmark/spec.md index 73da8e77..c210a53b 100644 --- a/openspec/changes/track2-reconcile-cost/specs/load-benchmark/spec.md +++ b/openspec/changes/track2-reconcile-cost/specs/load-benchmark/spec.md @@ -174,6 +174,11 @@ bench_reconcile_quick` — то же на малом наборе и одним checkout. Каждый проход повторяется три раза, повторы одной ячейки не идут подряд. +Исключение — группа проходов из одной ячейки (этап 100k без нагрузки — +только стратегия по умолчанию): её повторы идут подряд, потому что +остальные проходы того же набора идут под фоновой нагрузкой отдельным +блоком, и вставить их между повторами значило бы смешать проходы без +нагрузки с проходами под ней. Варианты сравниваются внутри одной метки, на одних данных и в одной сессии хоста. Шум — разброс повторов ячейки, а у проходов с фоновой нагрузкой ещё отношение p95 окон до и после прохода (A/A). @@ -195,7 +200,9 @@ bench_reconcile_quick` — то же на малом наборе и одним не результат; - в проходах без фоновой нагрузки запросы к S3 по счётчикам сверки SHALL совпадать с метриками шлюза, иначе проход помечается; -- ответ 5xx фоновой нагрузки — пометка прохода. +- ответ 5xx фоновой нагрузки в окнах прохода — пометка прохода; любой + неуспешный запрос фона или недосланная итерация по всему итогу + генератора — пометка всех проходов блока. В паспорте метки SHALL быть: - лимиты и образы, в том числе commit варианта «до»; diff --git a/openspec/changes/track2-reconcile-cost/specs/service-configuration/spec.md b/openspec/changes/track2-reconcile-cost/specs/service-configuration/spec.md index 09507819..e3d87058 100644 --- a/openspec/changes/track2-reconcile-cost/specs/service-configuration/spec.md +++ b/openspec/changes/track2-reconcile-cost/specs/service-configuration/spec.md @@ -15,8 +15,9 @@ «Скорость сверки»), по умолчанию 2000; 0 — без ограничения. `interval_seconds` и `max_objects_per_second` SHALL быть -неотрицательными числами, `page_size` и `max_changes` — целыми не меньше -1. Иначе уборщик MUST NOT стартовать (требование «Некорректное значение +неотрицательными числами, `max_objects_per_second` — ещё и конечным (не +`inf` и не `nan`), `page_size` и `max_changes` — целыми не меньше 1. +Иначе уборщик MUST NOT стартовать (требование «Некорректное значение останавливает запуск»). Отдельного grace у сверки нет: она берёт `[cleaner] @@ -38,7 +39,8 @@ pending_grace_seconds` и его проверку границы живой за #### Scenario: Неверный параметр сверки - **WHEN** уборщик запускается с `RECONCILER__PAGE_SIZE=5000`, - `RECONCILER__MAX_CHANGES=0`, `RECONCILER__INTERVAL_SECONDS=-1` или - `RECONCILER__MAX_OBJECTS_PER_SECOND=-1` + `RECONCILER__MAX_CHANGES=0`, `RECONCILER__INTERVAL_SECONDS=-1`, + `RECONCILER__MAX_OBJECTS_PER_SECOND=-1` или + `RECONCILER__MAX_OBJECTS_PER_SECOND=inf` - **THEN** уборщик не стартует, в журнале — ошибка проверки настроек с именем поля diff --git a/openspec/changes/track2-reconcile-cost/specs/storage-consistency/spec.md b/openspec/changes/track2-reconcile-cost/specs/storage-consistency/spec.md index 5c9a4ea5..d8ec2b42 100644 --- a/openspec/changes/track2-reconcile-cost/specs/storage-consistency/spec.md +++ b/openspec/changes/track2-reconcile-cost/specs/storage-consistency/spec.md @@ -52,7 +52,10 @@ SHALL ничего не менять (dry-run). С `--apply` он SHALL испр Обе стратегии SHALL находить на одних данных одни и те же расхождения тех же классов и подчиняться одним правилам безопасности (требование -«Безопасность сверки»). +«Безопасность сверки»). Каждое вложение `ready` сверка SHALL сравнивать +с объектом по ключу из его метаданных, чей бы `id` ни стоял в этом +ключе: строку, которая ссылается на `/original` другого вложения, +сверка проверяет так же, как строку со своим ключом. По умолчанию сверка поверхностная: наличие и размер объекта, байты она не читает. С `--deep` разовый проход SHALL ещё читать каждый объект @@ -135,6 +138,20 @@ SHA-256 его содержимого с метаданными. Планова - **AND** сверка с `--deep --apply` помечает оригинал потерянным: скачивание — 404, метаданные — 200 +#### Scenario: Строка ссылается на объект другого id + +- **WHEN** всё это старше grace, и выполняются сверки без `--apply` с + `--deep` — стратегией по умолчанию и `--strategy head`: + - готовое вложение Y1 ссылается на ключ `/original`, строки Z1 нет, + а объект по этому ключу другого размера, чем у Y1; + - готовое вложение Y2 ссылается на ключ `/original`, строки Z2 нет, + а объект по этому ключу того же размера с другими байтами +- **THEN** оба отчёта называют Y1 классом «другой размер», Y2 — «другой + SHA-256», а объекты `/original`, `/original`, `/original` и + `/original` — чужими; код выхода 3 +- **AND** сверка с `--deep --apply` помечает Y1 и Y2 потерянными, а все + четыре объекта на месте + ### Requirement: Безопасность сверки Сверка MUST NOT удалять: @@ -165,6 +182,9 @@ Grace — тот же, что у уборщика (capability `service-configura - вернувшийся оригинал — пометка на месте, объект того же размера и того же SHA-256 заново прочитанного содержимого. +Объект другого размера или другого SHA-256, изменённый меньше grace +назад, — свежий и при перепроверке: расхождение не подтверждено. + Не подтвердилось — действие не выполняется. Отсутствие объекта MUST NOT считаться подтверждённым, пока не проверено, что bucket на месте. Иначе удалённый bucket выглядел бы как потеря всех оригиналов. @@ -200,6 +220,17 @@ NOT читать и менять. Вложение, в метаданных ко - **THEN** объект на месте, вложение не помечено, а отчёт считает их свежими, а не расхождениями +#### Scenario: Недавно перезаписанный объект не тронут + +- **WHEN** у двух готовых вложений старше grace объекты меньше grace + назад перезаписаны мимо API — у одного байтами другого размера, у + другого другими байтами того же размера, — и выполняются сверка с + `--deep --apply` и сверка с `--deep --strategy head` без `--apply` +- **THEN** ни одно вложение не помечено и не названо расхождением, а + итоги считают оба объекта свежими +- **AND** когда объектам больше grace, сверка с `--deep` называет первое + классом «другой размер», второе — «другой SHA-256» + #### Scenario: Используемое вложение не удаляется - **WHEN** у вложения, на которое ссылается сообщение, удалён объект, diff --git a/openspec/changes/track2-reconcile-cost/tasks.md b/openspec/changes/track2-reconcile-cost/tasks.md index 73346941..4e087924 100644 --- a/openspec/changes/track2-reconcile-cost/tasks.md +++ b/openspec/changes/track2-reconcile-cost/tasks.md @@ -381,3 +381,78 @@ Evidence и метка — только с закоммиченного кода метки, evidence; раздел `### track2-reconcile-cost` дополнен. Затем commit evidence и отчёта — точка 4. Проверка: дерево чистое после commit. + +## 12. Замечания проверки + +Verify ветки `feat/track2-reconcile-cost` на `16f2cde`: CRITICAL нет, +W1–W3 и S1–S10. Решения — design, «Правки по verify», и `PLAN.md`. +Красный прогон новых проверок — на коде `16f2cde` (дерево с тестами и +драйвером, `src` прежний), до правки `src`. Точки commit: 1 — код, +тесты, спеки и документы (12.1–12.14); 2 — evidence и числа с +закоммиченного кода (12.15). + +- [x] 12.1 **W1.** `_pace` по сигналу перестаёт ждать и возвращается, а + проход останавливает следующий `check_stop()` перед вызовом: удачный + DELETE или уборка зависшей перед паузой пишется «Fixed» и считается в + `fixed`, ключи страницы — в `listed_objects`. Проверка: `driver.py + reconcile-signal --pace` ещё сверяет `listed_objects` со + `storage_objects`, новый режим `--pace --apply` (объекты без строки, + grace 18 с, `docker stop` во время паузы после DELETE) — удалённых + объектов столько же, сколько записей «Fixed» и `fixed`; оба красные + на `16f2cde`, зелёные после правки. +- [x] 12.2 **W2.** Стратегия `batch` сравнивает с объектом и строку, + ключ которой — `/original` другого `id` (шаг строк — HEAD такой + строки, как у `head`), а строки нестандартного ключа — все, а не одну. + Сценарий «Строка ссылается на объект другого `id`» — в дельте и + основном спеке `storage-consistency`; тест + `test_reconcile_row_with_other_id_key` (другой размер и, с `--deep`, + другой SHA-256 у `/original`; обе стратегии) — красный на + `16f2cde` (`batch` молчит), зелёный после. Решение и действительность + метки `baseline` — design и `REPORT.md`. +- [x] 12.3 **W3.** `REPORT.md`, «Выбор предела 2000»: 0,27–0,32 ядра — + вместе с фоном, долю одной сверки метка не выделяет. +- [x] 12.4 **S1.** Свежесть объекта и в перепроверке: «другой SHA-256» + перечитывается с `fresh_before`, объект другого размера моложе grace — + свежий в классификации, перепроверке и перед пометкой. Сценарий + «Недавно перезаписанный объект не тронут» — в дельте и основном спеке; + тест `test_reconcile_fresh_overwrite_untouched` — красный на `16f2cde` + (другой размер помечен), зелёный после. +- [x] 12.5 **S2.** `max_objects_per_second` — `allow_inf_nan=False`; + вариант `inf` в сценарии «Неверный параметр сверки» (дельта и основной + спек `service-configuration`). Проверка: `RECONCILER__MAX_OBJECTS_PER_SECOND=inf` + — «Invalid cleaner settings» и код 2. Прочие поля `float` настроек с + тем же дефектом — `KNOWN_ISSUES.md`. +- [x] 12.6 **S4.** `reconcile.line_problems`: верхний допуск — меньшее + из VU сценария и `vus_max` итога k6; `--selftest`. +- [x] 12.7 **S5.** База S4 — «проход B `batch`» с его 75 перепроверками + и 25 зависшими, а не «без кандидатов»: `bench/reconcile.py`, design, + `REPORT.md`. Метка не переснимается. +- [x] 12.8 **S6.** Вердикты: сеансы PostgreSQL в H1, LIST без допуска, + ~18 и ~2000 запросов на 1000 объектов в H2, GET на строку в H3, + неизменность данных в S4 (столбец `fixed_total`); `--selftest`. + Офлайн-пути пересборки `summary.md` нет — вердикты метки на её данных + пересчитаны скриптом scratchpad, итог — в `REPORT.md`. +- [x] 12.9 **S7, S10.** `REPORT.md`: `pg_stat_database` — справочный + счёт (решение 8); «может проявиться» вместо «будет». +- [x] 12.10 **S8.** Повторы ячейки группы из одной ячейки (D `batch`) + идут подряд: спек `load-benchmark` (дельта и основной) уточнён, + оговорка в `REPORT.md`. +- [x] 12.11 **S9.** Блок H4: `http_req_failed` и `dropped_iterations` + итога k6 — пометки `bg_failed` и `bg_dropped` проходов блока, H4 с + ними не подтверждается; `--selftest`. +- [ ] 12.12 **S3.** Числа: AGENTS.md (проверки отказов, карта кода с + `ReconcileStrategy`, время быстрого профиля), `Makefile`, `bench.md`, + `student-tests.md` — по факту прогонов 12.14 и 12.15. +- [x] 12.13 Правила, AGENTS.md, design («Правки по verify»), `PLAN.md`: + W1, W2, S1, S2, S8, S9. +- [x] 12.14 Проверки точки 1: `make lint`, `make check`, `openspec + validate track2-reconcile-cost --strict` и `--specs`, `--selftest` + модулей `bench/`, `make bench_reconcile_quick`, новые и затронутые + тесты отказов (`make failure_checks FAULT_ARGS='-k …'`) и драйвер — + красные до правки, зелёные после; временные стенды убраны. +- [ ] 12.15 Точка 2, с закоммиченного кода: `make rolling_update + APP_OUT_PORT=8090`, пересоздание уборщика, `make student_test + BASE_URL=http://localhost:8090`, полный `make failure_checks`; + `evidence/reconcile/service.md` (раздел паузы и `--pace --apply`), + `evidence/tests/failure-checks.md` (полный прогон и красные прогоны + 12.1, 12.2, 12.4), числа в документах. diff --git a/openspec/specs/load-benchmark/spec.md b/openspec/specs/load-benchmark/spec.md index ac92876e..f6d5d84d 100644 --- a/openspec/specs/load-benchmark/spec.md +++ b/openspec/specs/load-benchmark/spec.md @@ -2018,6 +2018,11 @@ bench_reconcile_quick` — то же на малом наборе и одним checkout. Каждый проход повторяется три раза, повторы одной ячейки не идут подряд. +Исключение — группа проходов из одной ячейки (этап 100k без нагрузки — +только стратегия по умолчанию): её повторы идут подряд, потому что +остальные проходы того же набора идут под фоновой нагрузкой отдельным +блоком, и вставить их между повторами значило бы смешать проходы без +нагрузки с проходами под ней. Варианты сравниваются внутри одной метки, на одних данных и в одной сессии хоста. Шум — разброс повторов ячейки, а у проходов с фоновой нагрузкой ещё отношение p95 окон до и после прохода (A/A). @@ -2039,7 +2044,9 @@ bench_reconcile_quick` — то же на малом наборе и одним не результат; - в проходах без фоновой нагрузки запросы к S3 по счётчикам сверки SHALL совпадать с метриками шлюза, иначе проход помечается; -- ответ 5xx фоновой нагрузки — пометка прохода. +- ответ 5xx фоновой нагрузки в окнах прохода — пометка прохода; любой + неуспешный запрос фона или недосланная итерация по всему итогу + генератора — пометка всех проходов блока. В паспорте метки SHALL быть: - лимиты и образы, в том числе commit варианта «до»; diff --git a/openspec/specs/service-configuration/spec.md b/openspec/specs/service-configuration/spec.md index dfdc4abf..1486ae1e 100644 --- a/openspec/specs/service-configuration/spec.md +++ b/openspec/specs/service-configuration/spec.md @@ -479,8 +479,9 @@ grace SHALL быть описаны в `REPORT.md`. «Скорость сверки»), по умолчанию 2000; 0 — без ограничения. `interval_seconds` и `max_objects_per_second` SHALL быть -неотрицательными числами, `page_size` и `max_changes` — целыми не меньше -1. Иначе уборщик MUST NOT стартовать (требование «Некорректное значение +неотрицательными числами, `max_objects_per_second` — ещё и конечным (не +`inf` и не `nan`), `page_size` и `max_changes` — целыми не меньше 1. +Иначе уборщик MUST NOT стартовать (требование «Некорректное значение останавливает запуск»). Отдельного grace у сверки нет: она берёт `[cleaner] @@ -502,7 +503,8 @@ pending_grace_seconds` и его проверку границы живой за #### Scenario: Неверный параметр сверки - **WHEN** уборщик запускается с `RECONCILER__PAGE_SIZE=5000`, - `RECONCILER__MAX_CHANGES=0`, `RECONCILER__INTERVAL_SECONDS=-1` или - `RECONCILER__MAX_OBJECTS_PER_SECOND=-1` + `RECONCILER__MAX_CHANGES=0`, `RECONCILER__INTERVAL_SECONDS=-1`, + `RECONCILER__MAX_OBJECTS_PER_SECOND=-1` или + `RECONCILER__MAX_OBJECTS_PER_SECOND=inf` - **THEN** уборщик не стартует, в журнале — ошибка проверки настроек с именем поля diff --git a/openspec/specs/storage-consistency/spec.md b/openspec/specs/storage-consistency/spec.md index ae6cdae5..9be6a85b 100644 --- a/openspec/specs/storage-consistency/spec.md +++ b/openspec/specs/storage-consistency/spec.md @@ -216,7 +216,10 @@ SHALL ничего не менять (dry-run). С `--apply` он SHALL испр Обе стратегии SHALL находить на одних данных одни и те же расхождения тех же классов и подчиняться одним правилам безопасности (требование -«Безопасность сверки»). +«Безопасность сверки»). Каждое вложение `ready` сверка SHALL сравнивать +с объектом по ключу из его метаданных, чей бы `id` ни стоял в этом +ключе: строку, которая ссылается на `/original` другого вложения, +сверка проверяет так же, как строку со своим ключом. По умолчанию сверка поверхностная: наличие и размер объекта, байты она не читает. С `--deep` разовый проход SHALL ещё читать каждый объект @@ -299,6 +302,20 @@ SHA-256 его содержимого с метаданными. Планова - **AND** сверка с `--deep --apply` помечает оригинал потерянным: скачивание — 404, метаданные — 200 +#### Scenario: Строка ссылается на объект другого id + +- **WHEN** всё это старше grace, и выполняются сверки без `--apply` с + `--deep` — стратегией по умолчанию и `--strategy head`: + - готовое вложение Y1 ссылается на ключ `/original`, строки Z1 нет, + а объект по этому ключу другого размера, чем у Y1; + - готовое вложение Y2 ссылается на ключ `/original`, строки Z2 нет, + а объект по этому ключу того же размера с другими байтами +- **THEN** оба отчёта называют Y1 классом «другой размер», Y2 — «другой + SHA-256», а объекты `/original`, `/original`, `/original` и + `/original` — чужими; код выхода 3 +- **AND** сверка с `--deep --apply` помечает Y1 и Y2 потерянными, а все + четыре объекта на месте + ### Requirement: Безопасность сверки Сверка MUST NOT удалять: @@ -329,6 +346,9 @@ Grace — тот же, что у уборщика (capability `service-configura - вернувшийся оригинал — пометка на месте, объект того же размера и того же SHA-256 заново прочитанного содержимого. +Объект другого размера или другого SHA-256, изменённый меньше grace +назад, — свежий и при перепроверке: расхождение не подтверждено. + Не подтвердилось — действие не выполняется. Отсутствие объекта MUST NOT считаться подтверждённым, пока не проверено, что bucket на месте. Иначе удалённый bucket выглядел бы как потеря всех оригиналов. @@ -364,6 +384,17 @@ NOT читать и менять. Вложение, в метаданных ко - **THEN** объект на месте, вложение не помечено, а отчёт считает их свежими, а не расхождениями +#### Scenario: Недавно перезаписанный объект не тронут + +- **WHEN** у двух готовых вложений старше grace объекты меньше grace + назад перезаписаны мимо API — у одного байтами другого размера, у + другого другими байтами того же размера, — и выполняются сверка с + `--deep --apply` и сверка с `--deep --strategy head` без `--apply` +- **THEN** ни одно вложение не помечено и не названо расхождением, а + итоги считают оба объекта свежими +- **AND** когда объектам больше grace, сверка с `--deep` называет первое + классом «другой размер», второе — «другой SHA-256» + #### Scenario: Используемое вложение не удаляется - **WHEN** у вложения, на которое ссылается сообщение, удалён объект, diff --git a/src/config/settings.py b/src/config/settings.py index 0be6b427..c48d2485 100644 --- a/src/config/settings.py +++ b/src/config/settings.py @@ -282,8 +282,13 @@ class Reconciler(BaseModel): 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) + # (design change `track2-reconcile-cost`, решение 6); `inf` и `nan` — + # ошибка: «Started cleaner» не JSON, а пауза бессмысленна (verify S2) + max_objects_per_second: float = Field( + default=2000.0, + ge=0, + allow_inf_nan=False, + ) class Settings(BaseSettings): diff --git a/src/core/services/attachment_reconcile.py b/src/core/services/attachment_reconcile.py index 0773c5fe..0ef8f612 100644 --- a/src/core/services/attachment_reconcile.py +++ b/src/core/services/attachment_reconcile.py @@ -9,8 +9,10 @@ `head` — своя выборка строки на объект, множества нет, объект строки с тем же ключом проверяет шаг 2; 2. БД → S3: keyset строк `ready` по `id`. `batch` — ключа нет в `seen`, - кандидат «метаданные без объекта»; `head` — HEAD объекта каждой строки - своей базы; + кандидат «метаданные без объекта»; строка, ключ которой — + `/original` другого вложения, — HEAD её объекта (шаг 1 сравнил + объект со строкой своего `id`); `head` — HEAD объекта каждой строки + своей базы. Каждая строка сравнивается с объектом по своему ключу; 3. зависшие загрузки — кандидаты уборщика (`get_stale_pending`); 4. перепроверка каждого кандидата в БД и S3 перед решением, в обоих режимах; отсутствие объекта — только после проверки, что bucket на @@ -136,7 +138,8 @@ def _age_seconds(moment: datetime, *, now: datetime) -> int: class _Stopped(Exception): - """Сигнал остановки между вызовами хранилища или во время паузы.""" + """Сигнал остановки перед вызовом хранилища; пауза предела скорости по + сигналу только прекращает ожидание.""" @dataclass(frozen=True, slots=True) @@ -315,16 +318,19 @@ class AttachmentReconcileService: async def _pace(self, state: _Pass) -> None: """После вызова S3: затронуто больше, чем предел × время с начала - прохода, — ждать кусками с проверкой сигнала (решение 6).""" + прохода, — ждать кусками с проверкой сигнала (решение 6). Сигнал + прекращает ожидание, но не бросает: вызов перед паузой уже + выполнен, и его итог (страница, удаление) должен дойти до записи и + счёта; проход останавливает `check_stop()` перед следующим вызовом + (verify W1).""" if state.rate <= 0: return - while True: + while not state.stop_requested(): 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_page( self, @@ -439,7 +445,11 @@ class AttachmentReconcileService: objects: tuple[StoredObjectInfo, ...], parsed: dict[str, UUID | None], ) -> None: - """`batch`: строки страницы одним выражением, ключи — в `seen`.""" + """`batch`: строки страницы одним выражением, ключи — в `seen`. + Объект стандартного ключа сравнивается со строкой своего `id`, + нестандартного — с каждой строкой этого ключа. Строку, ключ которой + — `/original` другого вложения, сравнивает шаг строк + (`_check_rows`).""" 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] = [] @@ -453,20 +463,23 @@ class AttachmentReconcileService: object_keys=keys, ) by_id = {row.id: row for row in rows} - by_key = {row.object_key: row for row in rows} + by_key: dict[str, list[dataclasses.AttachmentFullDTO]] = {} + for row in rows: + by_key.setdefault(row.object_key, []).append(row) 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) - ) + if attachment_id is None and item.key in by_key: + for row in by_key[item.key]: + await self._row_with_object(state, row=row, stored=item) + continue await self._classify_object( state, item, attachment_id=attachment_id, - row=row, + row=None + if attachment_id is None + else by_id.get(attachment_id), ) async def _row_for_object( @@ -561,6 +574,10 @@ class AttachmentReconcileService: if row.updated_at >= state.older_than: state.fresh_rows += 1 return + if _is_fresh(stored, older_than=state.older_than): + # объект перезаписан меньше grace назад (verify S1) + state.fresh_objects += 1 + return state.candidates.append( _finding( ReconcileFinding.SIZE_MISMATCH, @@ -618,6 +635,11 @@ class AttachmentReconcileService: await self._check_row_object(state, row) elif row.object_key not in state.seen: self._row_without_object(state, row) + elif self._key_of_other_id(row): + # объект есть, но шаг списка сравнил его со строкой + # своего `id`: эту строку — HEAD, как у `head` (verify + # W2) + await self._check_row_object(state, row) if len(rows) < page_size: return after = rows[-1].id @@ -762,7 +784,11 @@ class AttachmentReconcileService: return None if stored is None: return _finding(ReconcileFinding.MISSING_OBJECT, row, state) - if stored.size != row.size_bytes: + if stored.size != row.size_bytes and not _is_fresh( + stored, + older_than=state.older_than, + ): + # объект другого размера моложе grace — свежий (verify S1) return _finding( ReconcileFinding.SIZE_MISMATCH, row, @@ -779,11 +805,15 @@ class AttachmentReconcileService: state: _Pass, ) -> dataclasses.ReconcileFindingDTO | None: """«Другой SHA-256» и «оригинал вернулся»: объект читается заново - и сравнивается с размером и SHA-256 строки.""" + и сравнивается с размером и SHA-256 строки. Объект «другого + SHA-256» моложе grace не читается и не подтверждается (verify S1); + вернувшийся — читается любой: снимает пометку только тот же + SHA-256.""" read = await self._read( state, candidate.object_key, size=row.size_bytes, + fresh_before=_fresh_before(candidate.kind, state), ) if read is None or read.sha256 is None: # объекта нет или размер другой: это уже другой класс, его @@ -860,6 +890,22 @@ class AttachmentReconcileService: def _own_key(self, key: str) -> bool: return attachment_object_repo.is_own_key(self.storage, key=key) + def _key_of_other_id(self, row: dataclasses.AttachmentFullDTO) -> bool: + """Ключ строки — `/original` другого вложения. Сравнение с + ключом своего `id` — на каждую строку, разбор — только у + несовпавших.""" + own = attachment_object_repo.original_key( + self.storage, + attachment_id=row.id, + ) + if row.object_key == own: + return False + other = attachment_object_repo.parse_original_key( + self.storage, + key=row.object_key, + ) + return other is not None + async def _references( self, candidate: dataclasses.ReconcileFindingDTO, @@ -947,6 +993,7 @@ class AttachmentReconcileService: state, finding.object_key, size=finding.size_bytes, + fresh_before=_fresh_before(kind, state), ) same = ( read is not None @@ -967,8 +1014,12 @@ class AttachmentReconcileService: # HEAD мог ждать S3 до срока: шаг с БД — только без сигнала state.check_stop() # метаданные без объекта или другой размер: объекта по-прежнему нет - # или размер по-прежнему другой - if stored is not None and stored.size == finding.size_bytes: + # или размер по-прежнему другой, и объект не моложе grace (verify + # S1) + if stored is not None and ( + stored.size == finding.size_bytes + or _is_fresh(stored, older_than=state.older_than) + ): return None return await self._mark_lost(finding) @@ -1123,6 +1174,17 @@ def _is_fresh(stored: StoredObjectInfo, *, older_than: datetime) -> bool: return stored.last_modified is None or stored.last_modified >= older_than +def _fresh_before( + kind: ReconcileFinding, + state: _Pass, +) -> datetime | None: + """Порог свежести чтения перепроверки: «другой SHA-256» — grace + прохода, «оригинал вернулся» — без порога.""" + if kind == ReconcileFinding.CHECKSUM_MISMATCH: + return state.older_than + return None + + def _object_age(state: _Pass, stored: StoredObjectInfo) -> int: return ( 0 if stored.last_modified is None else state.age(stored.last_modified) diff --git a/student-tests/test_failures.py b/student-tests/test_failures.py index 8559e9ec..9f5986e3 100644 --- a/student-tests/test_failures.py +++ b/student-tests/test_failures.py @@ -2577,3 +2577,152 @@ def test_reconcile_limit_stops_rechecks( applied = run_reconcile(stand, "apply", 100) assert set(applied.kinds(FIXED, ids=ids)) == ids assert ids <= lost_ids(stand) + + +def own_findings( + run: Reconcile, + event: str, + keys: Collection[str], +) -> set[tuple[str, str, str | None]]: + """Записи `event` о своих ключах: класс, ключ и `id` вложения — у + строки, ссылающейся на чужой ключ, `id` и ключ из разных вложений.""" + return { + (item["kind"], item["object_key"], item.get("attachment_id")) + for item in run.events(event) + if item.get("object_key") in keys + } + + +@pytest.mark.spec( + "storage-consistency", + "Строка ссылается на объект другого id", +) +def test_reconcile_row_with_other_id_key( + api: Api, + stand: Stand, + alice: Actor, + chat: dict[str, Any], +) -> None: + """Замечание W2 verify `track2-reconcile-cost`: строка Y ссылается на + `/original` чужого `id`. Обе стратегии сравнивают Y с объектом по + её ключу: другой размер и, с `--deep`, другой SHA-256 — расхождения + Y; объекты Z и `/original` — чужие и на месте.""" + data = images.png_noise(64, 48, seed=17) + y1, y2 = (api.upload(alice, chat["id"], data) for _ in range(2)) + z1, z2 = (str(uuid.uuid4()) for _ in range(2)) + keys = { + "y1": object_key(y1["id"]), + "y2": object_key(y2["id"]), + "z1": object_key(z1), + "z2": object_key(z2), + } + # Z1 — другого размера, Z2 — того же размера с другими байтами + put_object(stand, keys["z1"], data + b"\0") + put_object(stand, keys["z2"], same_size_bytes(data, seed=17)) + try: + stand("set-key", y1["id"], keys["z1"]) + stand("set-key", y2["id"], keys["z2"]) + for item in (y1, y2): + stand("age-row", item["id"], str(AGED_S)) + # объекты Z записаны только что: после G + 1 все старше grace + time.sleep(OBJECT_AGE_WAIT_S) + expected = { + ("size_mismatch", keys["z1"], y1["id"]), + ("checksum_mismatch", keys["z2"], y2["id"]), + ("unknown_object", keys["z1"], z1), + ("unknown_object", keys["z2"], z2), + ("unknown_object", keys["y1"], y1["id"]), + ("unknown_object", keys["y2"], y2["id"]), + } + batch = run_reconcile(stand, "dry-run", options=DEEP) + head = run_reconcile( + stand, + "dry-run", + options=(*DEEP, *HEAD_STRATEGY), + ) + assert own_findings(batch, FOUND, keys.values()) == expected + assert own_findings(head, FOUND, keys.values()) == expected + assert batch.exit_code == head.exit_code == 3 + # поверхностная сверка видит только другой размер + shallow = run_reconcile(stand, "dry-run") + assert own_findings(shallow, FOUND, keys.values()) == expected - { + ("checksum_mismatch", keys["z2"], y2["id"]), + } + + applied = run_reconcile(stand, "apply", options=DEEP) + assert own_findings(applied, FIXED, keys.values()) == { + ("size_mismatch", keys["z1"], y1["id"]), + ("checksum_mismatch", keys["z2"], y2["id"]), + } + assert applied.exit_code == 3 + # ни один объект не удалён, обе строки — ready и помечены + assert {y1["id"], y2["id"], z1, z2} <= stored_ids(stand) + rows = attachment_rows(stand) + assert rows[y1["id"]] == rows[y2["id"]] == "ready" + assert {y1["id"], y2["id"]} <= lost_ids(stand) + finally: + # прежние ключи; объекты Z, на которые больше никто не ссылается, + # — прочь, чтобы следующие проходы не удаляли их как свои + stand("set-key", y1["id"], keys["y1"]) + stand("set-key", y2["id"], keys["y2"]) + stand("delete-object", keys["z1"]) + stand("delete-object", keys["z2"]) + + +@pytest.mark.spec( + "storage-consistency", + "Недавно перезаписанный объект не тронут", +) +def test_reconcile_fresh_overwrite_untouched( + api: Api, + stand: Stand, + alice: Actor, + chat: dict[str, Any], +) -> None: + """Замечание S1 verify `track2-reconcile-cost`: объект готового + вложения старше grace перезаписан мимо API меньше grace назад — другим + размером (A) и теми же размером с другими байтами (B). Сверка с + `--deep --apply` и HEAD-стратегией считает оба объекта свежими; после + grace — расхождения.""" + data = images.png_noise(64, 48, seed=19) + a, b = (api.upload(alice, chat["id"], data) for _ in range(2)) + ids = {a["id"], b["id"]} + for item in (a, b): + stand("age-row", item["id"], str(AGED_S)) + + def overwrite() -> float: + """Объекты A и B заново перезаписаны: моложе grace с этого момента.""" + put_object(stand, object_key(a["id"]), data + b"\0") + put_object(stand, object_key(b["id"]), same_size_bytes(data, seed=19)) + return time.monotonic() + + try: + # перед каждым проходом объекты перезаписываются заново: глубокий + # проход читает весь bucket стенда, и два подряд дольше grace + for options, mode in ( + (DEEP, "apply"), + ((*DEEP, *HEAD_STRATEGY), "dry-run"), + ): + written = overwrite() + run = run_reconcile(stand, mode, options=options) + # проход — пока объекты моложе grace, иначе он ничего не + # доказывает + assert time.monotonic() - written < CLEANER_GRACE_S, ( + "reconcile run took longer than the stand grace period" + ) + assert not run.about(FOUND, ids=ids), run.finished + assert not run.about(FIXED, ids=ids), run.finished + assert run.finished["fresh_objects"] >= len(ids), run.finished + assert not ids & lost_ids(stand) + assert_error(api.attachment_content(alice, a["id"]), 500) + + time.sleep(max(0.0, OBJECT_AGE_WAIT_S - (time.monotonic() - written))) + aged = run_reconcile(stand, "dry-run", options=DEEP) + assert aged.kinds(FOUND, ids=ids) == { + a["id"]: "size_mismatch", + b["id"]: "checksum_mismatch", + } + finally: + # стенд — с исходными байтами: расхождений не остаётся + for item in (a, b): + put_object(stand, object_key(item["id"]), data)