fix: address track2-reconcile-cost verify findings
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
+15
-5
@@ -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 закоммичены раньше метки.
|
||||
|
||||
|
||||
@@ -194,7 +194,12 @@ paths:
|
||||
HEAD на строку своей базы (с `deep` у непомеченной строки старше
|
||||
grace — сразу GET). Множества `seen` нет. Классификация пары —
|
||||
общая `_row_with_object`, строки без объекта — `_row_without_object`:
|
||||
расхождения те же, что у `batch`;
|
||||
расхождения те же, что у `batch`. Каждая строка сравнивается с
|
||||
объектом по своему ключу: у `batch` шаг списка сравнивает объект
|
||||
стандартного ключа со строкой своего `id`, нестандартного — с
|
||||
каждой строкой этого ключа, а строку с ключом `<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`
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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 ссылаются на `<Z1>/original` другого размера и `<Z2>/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` →
|
||||
|
||||
@@ -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/<uuid>/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/<uuid>/` (сверка этот префикс не читает), удаляются в `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), проходы, отказы
|
||||
|
||||
@@ -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): объекты пробы без строки
|
||||
(<id>/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): объекты
|
||||
# пробы — без строки (<id>/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,
|
||||
|
||||
@@ -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 <LB> reconcile-cycle` | сверка на рабочем стенде (~2 мин): исходный dry-run без расхождений (иначе код 2), расхождения с обеих сторон, dry-run без изменений, 500 → `--apply` → 404 и 200, повтор, удаление чужого объекта, свежий объект после grace, возврат оригинала; `evidence/reconcile/cycle.md` |
|
||||
| `driver.py --port <LB> 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/<domain>.py # <Domain>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; строка с ключом <id>/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/<domain>.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/<domain>.py # DTO между repo → service → api
|
||||
enums/<domain>.py # StrEnum доменов, RunModeEnum; attachment.py — AttachmentStatus, ImageType, ReconcileFinding, ReconcileAction
|
||||
enums/<domain>.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
|
||||
|
||||
@@ -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` по полям.
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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 на потерянный
|
||||
|
||||
@@ -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` не
|
||||
сравнивал с объектом строку, ключ которой — `<Z>/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.
|
||||
|
||||
|
||||
+279
-30
@@ -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:
|
||||
|
||||
+9
-3
@@ -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 "
|
||||
|
||||
@@ -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 — строка с ключом `<Z>/original` другого `id`.** Правильно
|
||||
поведение `head`: строка `ready` сравнивается с объектом по ключу из
|
||||
её метаданных. Объект по ключу и есть её оригинал — его отдаёт API, и
|
||||
другой размер даёт 500 на скачивании, пока сверка не пометит строку
|
||||
(спек `attachments`, «Скачивание оригинала»). Требование «Объект, на
|
||||
который ссылается строка, не удаляется» это не задевает: пометка не
|
||||
удаляет объект, а `<Z>/original` остаётся чужим. `batch` выровнен:
|
||||
шаг строк делает HEAD строки, ключ которой — `<id>/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 до
|
||||
|
||||
@@ -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 варианта «до»;
|
||||
|
||||
@@ -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** уборщик не стартует, в журнале — ошибка проверки настроек с
|
||||
именем поля
|
||||
|
||||
@@ -52,7 +52,10 @@ SHALL ничего не менять (dry-run). С `--apply` он SHALL испр
|
||||
|
||||
Обе стратегии SHALL находить на одних данных одни и те же расхождения
|
||||
тех же классов и подчиняться одним правилам безопасности (требование
|
||||
«Безопасность сверки»).
|
||||
«Безопасность сверки»). Каждое вложение `ready` сверка SHALL сравнивать
|
||||
с объектом по ключу из его метаданных, чей бы `id` ни стоял в этом
|
||||
ключе: строку, которая ссылается на `<Z>/original` другого вложения,
|
||||
сверка проверяет так же, как строку со своим ключом.
|
||||
|
||||
По умолчанию сверка поверхностная: наличие и размер объекта, байты она
|
||||
не читает. С `--deep` разовый проход SHALL ещё читать каждый объект
|
||||
@@ -135,6 +138,20 @@ SHA-256 его содержимого с метаданными. Планова
|
||||
- **AND** сверка с `--deep --apply` помечает оригинал потерянным:
|
||||
скачивание — 404, метаданные — 200
|
||||
|
||||
#### Scenario: Строка ссылается на объект другого id
|
||||
|
||||
- **WHEN** всё это старше grace, и выполняются сверки без `--apply` с
|
||||
`--deep` — стратегией по умолчанию и `--strategy head`:
|
||||
- готовое вложение Y1 ссылается на ключ `<Z1>/original`, строки Z1 нет,
|
||||
а объект по этому ключу другого размера, чем у Y1;
|
||||
- готовое вложение Y2 ссылается на ключ `<Z2>/original`, строки Z2 нет,
|
||||
а объект по этому ключу того же размера с другими байтами
|
||||
- **THEN** оба отчёта называют Y1 классом «другой размер», Y2 — «другой
|
||||
SHA-256», а объекты `<Z1>/original`, `<Z2>/original`, `<Y1>/original` и
|
||||
`<Y2>/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** у вложения, на которое ссылается сообщение, удалён объект,
|
||||
|
||||
@@ -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` сравнивает с объектом и строку,
|
||||
ключ которой — `<Z>/original` другого `id` (шаг строк — HEAD такой
|
||||
строки, как у `head`), а строки нестандартного ключа — все, а не одну.
|
||||
Сценарий «Строка ссылается на объект другого `id`» — в дельте и
|
||||
основном спеке `storage-consistency`; тест
|
||||
`test_reconcile_row_with_other_id_key` (другой размер и, с `--deep`,
|
||||
другой SHA-256 у `<Z>/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), числа в документах.
|
||||
|
||||
@@ -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 варианта «до»;
|
||||
|
||||
@@ -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** уборщик не стартует, в журнале — ошибка проверки настроек с
|
||||
именем поля
|
||||
|
||||
@@ -216,7 +216,10 @@ SHALL ничего не менять (dry-run). С `--apply` он SHALL испр
|
||||
|
||||
Обе стратегии SHALL находить на одних данных одни и те же расхождения
|
||||
тех же классов и подчиняться одним правилам безопасности (требование
|
||||
«Безопасность сверки»).
|
||||
«Безопасность сверки»). Каждое вложение `ready` сверка SHALL сравнивать
|
||||
с объектом по ключу из его метаданных, чей бы `id` ни стоял в этом
|
||||
ключе: строку, которая ссылается на `<Z>/original` другого вложения,
|
||||
сверка проверяет так же, как строку со своим ключом.
|
||||
|
||||
По умолчанию сверка поверхностная: наличие и размер объекта, байты она
|
||||
не читает. С `--deep` разовый проход SHALL ещё читать каждый объект
|
||||
@@ -299,6 +302,20 @@ SHA-256 его содержимого с метаданными. Планова
|
||||
- **AND** сверка с `--deep --apply` помечает оригинал потерянным:
|
||||
скачивание — 404, метаданные — 200
|
||||
|
||||
#### Scenario: Строка ссылается на объект другого id
|
||||
|
||||
- **WHEN** всё это старше grace, и выполняются сверки без `--apply` с
|
||||
`--deep` — стратегией по умолчанию и `--strategy head`:
|
||||
- готовое вложение Y1 ссылается на ключ `<Z1>/original`, строки Z1 нет,
|
||||
а объект по этому ключу другого размера, чем у Y1;
|
||||
- готовое вложение Y2 ссылается на ключ `<Z2>/original`, строки Z2 нет,
|
||||
а объект по этому ключу того же размера с другими байтами
|
||||
- **THEN** оба отчёта называют Y1 классом «другой размер», Y2 — «другой
|
||||
SHA-256», а объекты `<Z1>/original`, `<Z2>/original`, `<Y1>/original` и
|
||||
`<Y2>/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** у вложения, на которое ссылается сообщение, удалён объект,
|
||||
|
||||
@@ -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):
|
||||
|
||||
@@ -9,8 +9,10 @@
|
||||
`head` — своя выборка строки на объект, множества нет, объект строки с
|
||||
тем же ключом проверяет шаг 2;
|
||||
2. БД → S3: keyset строк `ready` по `id`. `batch` — ключа нет в `seen`,
|
||||
кандидат «метаданные без объекта»; `head` — HEAD объекта каждой строки
|
||||
своей базы;
|
||||
кандидат «метаданные без объекта»; строка, ключ которой —
|
||||
`<id>/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`,
|
||||
нестандартного — с каждой строкой этого ключа. Строку, ключ которой
|
||||
— `<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:
|
||||
"""Ключ строки — `<id>/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)
|
||||
|
||||
@@ -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 ссылается на
|
||||
`<Z>/original` чужого `id`. Обе стратегии сравнивают Y с объектом по
|
||||
её ключу: другой размер и, с `--deep`, другой SHA-256 — расхождения
|
||||
Y; объекты Z и `<Y>/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)
|
||||
|
||||
Reference in New Issue
Block a user