From b5983f0e35de368f21d3dce030ed2ba23d6cd815 Mon Sep 17 00:00:00 2001 From: roman Date: Fri, 23 Oct 2026 01:13:36 +0300 Subject: [PATCH] fix: drop aiohttp read timeout of the S3 client aiohttp 3.13-3.14.5 re-arms sock_read in resume_reading() after a streamed response has already returned the connection to the pool; the timer fires while the connection idles and the next call on it fails in 1 ms with ReadTimeoutError (503 on a healthy S3). The call and per-chunk asyncio.timeout stay the only S3 timeout. Adds driver.py s3-idle and documents the timeouts in the rules. Co-Authored-By: Claude Opus 5.5 --- .claude/rules/infra.md | 19 +- .claude/rules/student-tests.md | 38 +- .claude/skills/run-mtusi-messenger/SKILL.md | 2 + .claude/skills/run-mtusi-messenger/driver.py | 449 ++++++++++++++++++ AGENTS.md | 11 +- PLAN.md | 17 + .../changes/fix-upload-put-flake/design.md | 37 +- .../changes/fix-upload-put-flake/tasks.md | 10 +- src/infra/s3/client.py | 17 +- 9 files changed, 579 insertions(+), 21 deletions(-) diff --git a/.claude/rules/infra.md b/.claude/rules/infra.md index 0da19d57..473ad961 100644 --- a/.claude/rules/infra.md +++ b/.claude/rules/infra.md @@ -179,8 +179,23 @@ paths: не повторяется, загрузку повторяет клиент контракта; - **срок на вызов** — `asyncio.timeout([s3] timeout_seconds)` (5 с, меньше `timeout server` HAProxy), у `open` — ещё и на каждый блок - чтения тела; `connect_timeout_seconds` и `read_timeout` botocore — - из `[s3]`; пул aiohttp — `[s3] max_connections`. Отдельного срока PUT + чтения тела. Это единственный срок вызова: `connect_timeout_seconds` + — из `[s3]`, `read_timeout` botocore **выключен (`None`)**; пул + aiohttp — `[s3] max_connections`; + - **почему без `read_timeout`** (design change `fix-upload-put-flake`, + решение 1): aiobotocore превращает его в `sock_read` aiohttp, а + aiohttp 3.13–3.14.5 после потокового ответа больше буфера (128 KiB) + перевзводит этот срок в `resume_reading()` уже у соединения, которое + вернулось в пул. Через срок он срабатывает на простаивающем + соединении, пул отдаёт его следующему вызову (проверяет только + `is_connected()` и keep-alive), и вызов падает за 1 мс — + `ReadTimeoutError`, 503 на исправном S3. Включать `read_timeout` + снова — только с новой пробой (`driver.py s3-idle`, тест + `test_upload_after_idle_s3`). Отсюда правило: всякое новое чтение из + S3 — внутри `_call` или `_read_chunk` под `asyncio.timeout`, а не + голым `await` на ответе aiohttp, иначе оно останется без срока; + - правило «повторов нет» (пункт выше) прежнее: причина 503 убрана, а не + скрыта повтором (решение 2 того же design). Отдельного срока PUT по размеру нет: места API ограничивают одновременные PUT (4 на реплику, 12 при замене), p95 при 12 — 1,6–1,9 с (design change `upload-memory`, решение 8), а больший срок удлинил бы границу B diff --git a/.claude/rules/student-tests.md b/.claude/rules/student-tests.md index d1f94c0d..39053185 100644 --- a/.claude/rules/student-tests.md +++ b/.claude/rules/student-tests.md @@ -265,6 +265,30 @@ paths: два теста W1 зелёные (ветки были верны) и красные на временных регрессиях — `_recheck_orphan` без проверки ссылок и уборка зависших под пределом (design, «Уточнения apply», п. 22); +- с change `fix-upload-put-flake` (design, решение 3) — простой S3 после + скачиваний, тоже проверка отказов: + - четвёртый API стенда отказов — «с коротким сроком S3» + (`<проект>-api-s3`, `S3_ENV` в `run_failures.py`: + `S3__TIMEOUT_SECONDS=1`), тестам — `FAULT_S3_BASE_URL` (фикстура + `s3_api`, срок клиента 30 с) и `FAULT_S3_ENV`; тест сверяет стенд + (`assert_s3_stand`). Других тестов на нём нет: пул S3 процесса — только + от этого теста. Короткий срок нужен, чтобы простой дольше срока вызова + длился 1,5 с, а не 6; + - `api_client.py`: `attachment_content_slowly` — скачивание потоком с + паузой после каждого блока 64 KiB, ответ с байтами в `content` (его + проверяет `assert_content`); + - `test_upload_after_idle_s3` («Загрузка после простоя S3»): PNG из шума + ~4 MiB загружен один раз; до 8 раундов — 10 одновременных медленных + скачиваний (барьер, своё соединение, 2 мс на блок), простой + `S3__TIMEOUT_SECONDS + 0,5` с, 12 загрузок `sample.png` по одной, + каждая 201; сообщение падения — раунд, загрузка и ответ. Тест + вероятностный внутри раунда: до правки соединение портится с p ≈ + 0,28, промах восьми раундов ≈ 4e-12 (докстринг); + - красный прогон на `4cfaab0` (тест без правки клиента): `make + failure_checks FAULT_ARGS='-k idle_s3'` три раза — каждый 1 failed в + первом раунде (загрузки 4, 8, 3: 503 `unavailable`, в журнале API — + `put_object` `ReadTimeoutError` за 1 мс); после правки — 1 passed, + ~16 с (`evidence/tests/failure-checks.md`); - исключения сверки: «Принявшая реплика остановлена» — `driver.py attachment-failover` → `evidence/attachments/failover.md`; «Байты не в БД и не на диске API» — `driver.py attachment-storage` → @@ -332,17 +356,19 @@ paths: healthcheck PostgreSQL проверяет служебную базу `postgres` (иначе каждая проверка — сессия в базе приложения и шум счётчика `db-sessions`); - - три API на свободных портах `127.0.0.1`: обычный (`BASE_URL`; с + - четыре API на свободных портах `127.0.0.1`: обычный (`BASE_URL`; с лабы 4 в окружении `MAX_UPLOAD_BYTES=1` и `MAX_IMAGE_PIXELS=1` — `LIMITS_ENV`, тест получает их в `FAULT_LIMITS_ENV` и грузит `sample.png`: лимиты — константы, спек `service-configuration`), «тесный» (`FAULT_TIGHT_BASE_URL`: сроки сессии и ключа - идемпотентности 2 с, пул 1, короткие таймауты) и с change + идемпотентности 2 с, пул 1, короткие таймауты), с change `upload-memory` «узкий по загрузкам» (`FAULT_UPLOADS_BASE_URL`, `UPLOADS_ENV` → `FAULT_UPLOADS_ENV`: 1 место, 1 в очереди, ожидание - 1 с, срок тела 3 с); без любого из трёх адресов `pytest -m fault` + 1 с, срок тела 3 с), с change `fix-upload-put-flake` — «с коротким + сроком S3» (`FAULT_S3_BASE_URL`, `S3_ENV` → `FAULT_S3_ENV`: срок + вызова S3 1 с); без любого из четырёх адресов `pytest -m fault` останавливается до первого теста; при падении печатаются журналы - всех трёх; + всех четырёх; - уборщик (с лабы 4): после bootstrap — `up -d --no-deps cleaner` с grace 20 с и интервалом 1 с из `failures.compose.yml` (`CLEANER__*`, `restart: "no"`: падение не прячется за @@ -353,7 +379,9 @@ paths: С change `track2-reconciler` — без плановой сверки (`RECONCILER__INTERVAL_SECONDS: "0"`, строка `start cleaner` называет и её интервал), а `<проект>-cleaner-scheduled` hook `run-cleaner` - убирается вместе с API. Прогон — ~9,5 мин (48 проверок, pytest ~535 с; + убирается вместе с API. Прогон — ~9,5 мин (с change + `fix-upload-put-flake` — 49 проверок, четвёртый API и тест простоя S3 + добавляют ~20 с; до него 48 проверок, pytest ~535 с; до правок по verify `track2-reconciler` — 45 и ~460 с; до `track2-reconciler` — 37 и ~255 с, до `upload-memory` — 32 и ~220 с, до `upload-consistency` ~70 с); diff --git a/.claude/skills/run-mtusi-messenger/SKILL.md b/.claude/skills/run-mtusi-messenger/SKILL.md index afcc1106..1add7524 100644 --- a/.claude/skills/run-mtusi-messenger/SKILL.md +++ b/.claude/skills/run-mtusi-messenger/SKILL.md @@ -127,6 +127,7 @@ python3 $D stop | `reconcile-cycle` | только стенд с LB: спеки `storage-consistency` (сверка bucket и БД) и `attachments` «Потерянный оригинал» (design change `track2-reconciler`, решение 12). (1) исходный dry-run с grace по умолчанию — расхождений нет, иначе код 2; (2) синтетические Алиса, Боб, чат, вложения A (в сообщении), B, C; (3) объект O без строки и чужой ключ X — `docker exec` реплики (botocore образа её ключами), объект A удалён (`weed shell fs.rm`), строка B удалена и размер C изменён (psql), P — триггер COMMIT на уникальный `filename` (503, строка `pending` и объект); (4) после grace 30 с dry-run: таблица «класс → действие → ключ → `id` → возраст», снимки строк, объектов и пометок до и после совпали; (5) байты A — 500; (6) свежий F, `--apply`: O, B удалены, A, C помечены, P убрана, F не тронут, байты A — 404, метаданные A — 200 и равны ответу загрузки, история отдаёт A; (7) повтор — только чужой X, код 3; оператор удаляет X — код 0; после grace F удалён; (8) A возвращён теми же байтами — «оригинал вернулся», байты 200 с тем же SHA-256, итоговый dry-run — код 0. Таблица «проверка → ожидаемо → получено» без токенов; код 1 при расхождении, без LB — код 2. ~2 мин. Вывод — `evidence/reconcile/cycle.md` | | `reconcile-stress [--seconds S] [--clients N]` | только стенд с LB: «Сверка под нагрузкой». Предусловие — dry-run с grace 20 с без расхождений (иначе код 2); два объекта без строки и два вложения без объекта; N клиентов (4) S секунд (40, больше grace) загружают PNG ~100 KiB из шума и отправляют сообщения, поток сверки — `--apply` с grace 20 с раз в ~3 с, затем ещё один проход. Итог: загрузки по кодам, сообщения, коды проходов, исправления по классам; проверки — внесённые исправлены (объекты удалены, новые пометки — ровно внесённые), каждое 201 скачивается с тем же SHA-256, каждое сообщение отдаёт своё вложение, ни одного прерванного прохода, повтор dry-run — код 0. Проверка корректности, не замер. Вывод — `evidence/reconcile/stress.md` | | `reconcile-signal` | только не рабочий проект compose (выбор — окружением `COMPOSE_PROJECT_NAME`, `COMPOSE_FILE`, `COMPOSE_ENV_FILES`; `mtusi-lab4` — отказ, код 2): спек `graceful-shutdown`, разовый проход сверки, прерванный сигналом, — код 1 (design change `track2-reconciler`, «Уточнения apply», п. 23). Нужны запущенные `s3` и образ уборщика, LB и реплики не нужны. `docker compose pause s3` → `run -d --no-deps --name <проект>-reconcile-signal cleaner reconcile --apply` → через секунду после «Started cleaner» `docker stop` → код контейнера и журнал → `rm`, `unpause s3` в `finally`. Записи процесса (событие, уровень, операция, `interrupted_by`, `exit_code`) и таблица: код 1, `interrupted_by: stop`, «Stopped cleaner» с `exit_code` 1, записей «Fixed» 0, остановка быстрее 10 с; код 1 при расхождении. ~10 с. Вывод — раздел `evidence/reconcile/service.md` | +| `s3-idle [--rounds 3] [--downloads 10] [--puts 12] [--size-mib 4] [--pause-ms 0.5]` | только стенд с LB: спеки `object-storage` «Вызов после простоя» и `attachments` «Загрузка после простоя S3» (design change `fix-upload-put-flake`, решение 4). Проба клиента S3 в первой работающей реплике `api`: `docker exec -i <реплика> python -` со скриптом из stdin — код, настройки и ключи образа, ключи в драйвер не попадают; uvloop, если есть. Два варианта по очереди, у каждого свой `ObjectStorage` и пул: `image` (как в образе) и `reference` (прежний `read_timeout` aiohttp = `[s3] timeout_seconds`, подменой `AioConfig` при создании клиента). Раунд: `--downloads` одновременных скачиваний объекта `--size-mib` MiB через `open` / `iter_chunks` с паузой `--pause-ms` после блока 64 KiB, простой `[s3] timeout_seconds + 0,5` с, `--puts` PUT по 128 KiB по одному. Таблица по раундам: `read_timeout` клиента, скачивания с тем же SHA-256, соединения пула со взведённым сроком чтения после скачиваний (`armed`) и с сохранённым исключением после простоя (`broken`) — закрытые поля aiohttp `_conns`, `_read_timeout_handle`, `_exception`, нет их — «n/a», тогда судят только по PUT; PUT прошло и упало, у упавших — цепочка исключений и мс; каждый записанный объект читается обратно (размер и SHA-256). Объекты — под `<база>/.s3-idle-probe//` (сверка этот префикс не читает), удаляются в `finally` отдельным клиентом; затем `weed shell fs.tree` — файлов пробы 0. Код 0 — у `image` ни испорченного соединения, ни упавшего PUT, ни расхождения байтов, все раунды пройдены и файлов не осталось; 1 — иначе (эталон может падать: так видно механизм); 2 — нет реплики или консольный процесс драйвера. Пул API не трогает (отдельный процесс), но на время команды берёт ~100 MiB и CPU реплики — без нагрузки на стенд. ~40 с при 3 раундах и `timeout_seconds` 5. Вывод — `evidence/s3/idle-connection.md` | | `lb-upload-timeouts [--config F] [--image ТЕГ]` | без стенда (рабочий стенд и проекты compose не трогает): спек `load-balancing` «Загрузки через балансировщик» и «Ошибки балансировщика в формате контракта» (design change `upload-memory`, решение 7). `haproxy -c` конфигурации F (по умолчанию `infra/haproxy/haproxy.cfg`) в закреплённом образе LB из `docker-compose.yml`, затем временная сеть `mtusi-lbto-<метка>`: заглушка реплики на образе API (по умолчанию `mtusi-messenger:lab4`, asyncio stdlib) под сетевым именем `api` и HAProxy с F и `API_PORT=8080` на свободном `127.0.0.1`; ожидание `UP` заглушки по `/health/ready` через LB. Пять случаев параллельно, у каждого своё соединение и свой `case` в строке запроса: заглушка молчит 12 с до чтения тела загрузки 10 MiB и после него — 201 от заглушки; 12 с на `GET /api/v1/users/me` — 504 LB через ~10 с; 32 с на пути загрузки — 504 LB через ~30 с; клиент отправил половину тела и молчит — 400 LB через ~30 с (`timeout client`). Ошибки LB — `application/json`, ровно `{"error": {"code", "message", "request_id"}}`, `code` по статусу, `request_id` = `X-Request-Id`. Таблица «случай → ожидаемо → получено → время», код 1 при расхождении. Сеть и контейнеры (метка `mtusi.lb-upload-timeouts`) удаляются при любом исходе, в том числе по Ctrl+C, SIGTERM, SIGHUP. ~35 с. На `haproxy.cfg` до change (`git archive f894040 infra/haproxy/haproxy.cfg \| tar -x -C <каталог>`, `--config <каталог>/infra/haproxy/haproxy.cfg`) — код 1: 502 и 504 через 10 с на пути загрузки, 400 в HTML. Вывод — `evidence/uploads/lb-timeouts.md` | | `stop-at-start [--image ТЕГ] [--delays 0.2,0.3,0.4,1.5,5] [--server-start 3]` | спек `graceful-shutdown` «Остановка во время старта»: контейнеры образа (по умолчанию `mtusi-messenger:lab4`) с лимитами реплики (1 CPU / 512 МиБ без swap), без сети и `config.toml`; `docker stop --timeout 10` через паузу после `docker run` и сразу по строке «Started server process». По потоку `docker events` и журналу: «сигнал через», время `docker stop`, «выход после сигнала», код выхода, этап (`import` / `server-start` / `running`), кто остановил (`early` / `uvicorn`). Код 0 — каждая попытка с кодом 0 и `docker stop` ≤ 1 с, есть `import`, остановленный ранним обработчиком, и `running`. Проекты compose не трогает, свои контейнеры удаляет по метке `mtusi.stop-at-start`. Вывод — `evidence/failover/stop-at-start.md` | | `stop` | SIGTERM всей группе; ждёт, пока порт освободится. Чужой сервер и контейнер не трогает | @@ -183,6 +184,7 @@ make reconcile APPLY=1 [MAX_CHANGES=N] # то же с исправлени python3 $D --port 8080 reconcile-cycle # расхождения с обеих сторон: dry-run, --apply, 404/200, повтор = 0, возврат оригинала; ~2 мин python3 $D --port 8080 reconcile-stress # --apply раз в 3 с под загрузками 4 клиентов 40 с: все 201 скачиваются с тем же SHA-256 COMPOSE_PROJECT_NAME=<временный> python3 $D reconcile-signal # pause s3 + docker stop разового --apply: код 1, interrupted_by stop; не на mtusi-lab4 +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), проходы, отказы docker compose run --rm --no-deps cleaner --once # разовый проход уборщика (grace 900 с): код 0 — проход дошёл до конца diff --git a/.claude/skills/run-mtusi-messenger/driver.py b/.claude/skills/run-mtusi-messenger/driver.py index 25fffb5e..ba2f902e 100644 --- a/.claude/skills/run-mtusi-messenger/driver.py +++ b/.claude/skills/run-mtusi-messenger/driver.py @@ -120,6 +120,18 @@ interrupted_by stop, «Stopped cleaner» с exit_code 1, остановка быстрее stop_grace_period 10 с; S3 размораживается в finally; код 1 при расхождении + s3-idle [--rounds 3] [--downloads 10] [--puts 12] [--size-mib 4] + [--pause-ms 0.5] только стенд с LB: спеки object-storage + «Вызов после простоя» и attachments «Загрузка после простоя + S3» — проба клиента S3 в реплике (docker exec -i … python -, + код и ключи образа), варианты «image» и «reference» (прежний + read_timeout aiohttp = [s3] timeout_seconds); раунд — + одновременные медленные скачивания объекта, простой срока + вызова + 0,5 с, PUT по одному; взведённые и испорченные + соединения пула, PUT прошло и упало (цепочка ошибки, мс), + чтение записанного обратно; объекты под + <база>/.s3-idle-probe/ удаляются в finally; код 0 — у образа + ни порчи, ни упавших PUT, 1 — иначе, 2 — нет стенда lb-upload-timeouts [--config F] [--image ТЕГ] без стенда: спек load-balancing «Загрузки через балансировщик» — временная сеть, HAProxy закреплённого образа с конфигурацией F (по @@ -4520,6 +4532,423 @@ def stop_verdict(attempts: list[dict[str, object]]) -> int: return 0 +# s3-idle (change fix-upload-put-flake, design, решение 4): проба клиента +# S3 в реплике стенда. Объекты — под этим префиксом базы: сверка читает +# только `<база>/attachments/`, проба его не трогает +S3_IDLE_PREFIX = ".s3-idle-probe" +S3_IDLE_FILE = re.compile(r"^(source|r\d+-p\d+)$") +S3_IDLE_TIMEOUT_S = 900 +# проба: код и ключи образа, процесс отдельный — пул API она не трогает. +# Счётчики пула — закрытые поля aiohttp (`_conns`, `_read_timeout_handle`, +# `_exception`): диагностика, а не код приложения; нет полей — «n/a». +# Строки без поля `type` — журнал клиента S3 (structlog в stdout) +S3_IDLE_PROBE_PY = r""" +import asyncio +import hashlib +import io +import json +import os +import sys +import time +import uuid + +import aiohttp + +import src.infra.s3.client as client_module +from src.config import settings +from src.core.exceptions import ObjectStorageUnavailable +from src.infra.s3.client import ObjectStorage + +try: + import uvloop +except ImportError: + uvloop = None + +ROUNDS, DOWNLOADS, PUTS, SIZE, PUT_SIZE = (int(v) for v in sys.argv[1:6]) +PAUSE_S = float(sys.argv[6]) +VARIANTS = sys.argv[7].split(",") +S3 = settings.s3 +NAMESPACE = settings.database.name +BASE = f"{NAMESPACE}/.s3-idle-probe/{uuid.uuid4().hex}" +IDLE_S = S3.timeout_seconds + 0.5 +TYPE = "application/octet-stream" +NA = "n/a" + + +def emit(**fields): + print(json.dumps(fields), flush=True) + + +def pool_state(storage): + # соединения в пуле aiohttp: всего, со взведённым сроком чтения и с + # сохранённым исключением (испорченные) + try: + sessions = storage._client._endpoint.http_session._sessions + protos = [ + proto + for session in sessions.values() + for conns in session.connector._conns.values() + for proto, _ in conns + ] + except AttributeError: + return {"pooled": NA, "armed": NA, "broken": NA} + if not all( + hasattr(p, "_read_timeout_handle") and hasattr(p, "_exception") + for p in protos + ): + return {"pooled": len(protos), "armed": NA, "broken": NA} + return { + "pooled": len(protos), + "armed": sum(p._read_timeout_handle is not None for p in protos), + "broken": sum(p._exception is not None for p in protos), + } + + +def chain(error): + names, last, seen = [], error, set() + while error is not None and id(error) not in seen: + seen.add(id(error)) + names.append(type(error).__name__) + last = error + error = error.__cause__ or error.__context__ + return names, str(last)[:80] + + +async def make(variant): + # эталон — прежний срок чтения aiohttp: read_timeout = [s3] timeout + storage = ObjectStorage(S3, namespace=NAMESPACE) + original = client_module.AioConfig + if variant == "reference": + + def config(**kwargs): + kwargs["read_timeout"] = S3.timeout_seconds + return original(**kwargs) + + client_module.AioConfig = config + try: + await storage.start() + finally: + client_module.AioConfig = original + return storage + + +async def download(storage, key): + digest, size = hashlib.sha256(), 0 + async with storage.open(key) as stored: + async for chunk in stored.iter_chunks(): + digest.update(chunk) + size += len(chunk) + await asyncio.sleep(PAUSE_S) + return size, digest.hexdigest() + + +async def run_variant(variant, written): + storage = await make(variant) + emit( + type="variant", + variant=variant, + read_timeout=storage._client.meta.config.read_timeout, + ) + try: + data = os.urandom(SIZE) + source = f"{BASE}/{variant}/source" + written.append(source) + await storage.put( + source, + io.BytesIO(data), + size=SIZE, + content_type=TYPE, + ) + expected = (SIZE, hashlib.sha256(data).hexdigest()) + stored = [] + for number in range(1, ROUNDS + 1): + results = await asyncio.gather( + *(download(storage, source) for _ in range(DOWNLOADS)), + return_exceptions=True, + ) + after_downloads = pool_state(storage) + await asyncio.sleep(IDLE_S) + after_idle = pool_state(storage) + ok, failures = 0, [] + for index in range(1, PUTS + 1): + body = os.urandom(PUT_SIZE) + key = f"{BASE}/{variant}/r{number}-p{index}" + written.append(key) + started = time.monotonic() + try: + await storage.put( + key, + io.BytesIO(body), + size=PUT_SIZE, + content_type=TYPE, + ) + except ObjectStorageUnavailable as error: + names, message = chain(error) + failures.append({ + "put": index, + "ms": round((time.monotonic() - started) * 1000, 1), + "chain": names, + "message": message, + }) + else: + ok += 1 + stored.append((key, hashlib.sha256(body).hexdigest())) + emit( + type="round", + variant=variant, + round=number, + downloads_ok=sum(r == expected for r in results), + armed=after_downloads["armed"], + pooled=after_downloads["pooled"], + broken=after_idle["broken"], + pooled_idle=after_idle["pooled"], + puts_ok=ok, + failures=failures, + ) + intact = 0 + for key, digest in stored: + try: + async with storage.open(key) as obj: + body = await obj.read() + except ObjectStorageUnavailable: + continue + intact += len(body) == PUT_SIZE and ( + hashlib.sha256(body).hexdigest() == digest + ) + emit( + type="readback", + variant=variant, + written=len(stored), + intact=intact, + ) + finally: + await storage.aclose() + + +async def main(): + written = [] + try: + for variant in VARIANTS: + await run_variant(variant, written) + finally: + # свой клиент без скачиваний: в его пуле нечему испортиться + cleaner = await make("image") + removed = 0 + for key in written: + try: + await cleaner.delete(key) + removed += 1 + except ObjectStorageUnavailable: + pass + await cleaner.aclose() + emit(type="cleanup", written=len(written), removed=removed) + + +emit( + type="start", + loop="uvloop" if uvloop else "asyncio", + aiohttp=aiohttp.__version__, + timeout=S3.timeout_seconds, + idle=IDLE_S, + database=NAMESPACE, +) +if uvloop: + uvloop.run(main()) +else: + asyncio.run(main()) +""" + + +def s3_idle_leftovers(bucket: str, database: str) -> int | None: + """Файлы пробы под `<база>/.s3-idle-probe/` по `fs.tree` (каталоги + SeaweedFS убирает позже файлов); `None` — дерево не прочитано.""" + try: + tree = weed_shell( + f"fs.tree /buckets/{bucket}/{database}/{S3_IDLE_PREFIX}", + ) + except RuntimeError: + return None + return sum( + 1 + for line in tree.splitlines() + if (match := UC_TREE_LINE.match(line)) + and S3_IDLE_FILE.match(match.group(2)) + ) + + +def cmd_s3_idle( + port: int, + *, + rounds: int, + downloads: int, + puts: int, + size_mib: int, + pause_ms: float, +) -> int: + """Спек `object-storage`, «Вызов после простоя», и `attachments`, + «Загрузка после простоя S3» (design change `fix-upload-put-flake`, + решение 4): проба клиента S3 в работающей реплике стенда — вариант + образа и эталон с прежним сроком чтения aiohttp. Раунд — одновременные + медленные скачивания объекта, простой `[s3] timeout_seconds + 0,5` с, + PUT по одному; каждый записанный объект читается обратно. Код 0 — у + варианта образа ни одного испорченного соединения и упавшего PUT, 1 — + иначе (эталон может падать: так видно механизм), 2 — нет стенда.""" + if no_lb(port): + return 2 + stand = rc_stand() + try: + replicas = compose("ps", "-q", "--status", "running", "api").split() + except RuntimeError as e: + print(f"FAIL: docker compose ps: {e}") + return 2 + if stand is None or not replicas: + print("FAIL: no running api replica of the stand") + return 2 + bucket, database = stand + replica = replicas[0] + name = ( + subprocess.run( + ["docker", "inspect", "-f", "{{.Name}}", replica], + capture_output=True, + text=True, + check=False, + ) + .stdout.strip() + .lstrip("/") + ) + args = [ + str(rounds), + str(downloads), + str(puts), + str(size_mib * 1024 * 1024), + str(128 * 1024), + str(pause_ms / 1000), + "image,reference", + ] + proc = subprocess.run( + ["docker", "exec", "-i", replica, "python", "-", *args], + input=S3_IDLE_PROBE_PY, + capture_output=True, + text=True, + timeout=S3_IDLE_TIMEOUT_S, + check=False, + ) + records: list[dict[str, object]] = [] + storage_warnings = 0 + for line in proc.stdout.splitlines(): + try: + record = json.loads(line) + except json.JSONDecodeError: + continue + if "type" in record: + records.append(record) + elif record.get("event") == "Object storage is unavailable": + storage_warnings += 1 + by_type: dict[str, list[dict[str, object]]] = {} + for record in records: + by_type.setdefault(str(record["type"]), []).append(record) + if proc.returncode != 0 or "start" not in by_type: + print(f"FAIL: probe exited {proc.returncode}") + print(proc.stderr[-2000:]) + return 1 + start = by_type["start"][0] + print( + f"s3-idle: replica {name}, loop {start['loop']}, aiohttp " + f"{start['aiohttp']}, [s3] timeout_seconds {start['timeout']} s, " + f"database {start['database']}", + ) + print( + f"round: {downloads} concurrent downloads of {size_mib} MiB " + f"({pause_ms} ms pause per 64 KiB block) -> idle {start['idle']} s " + f"-> {puts} PUT of 128 KiB one by one; {rounds} rounds per variant", + ) + timeouts = { + str(r["variant"]): r["read_timeout"] + for r in by_type.get("variant", []) + } + header = ( + f"{'variant':<10} {'read_timeout':>12} {'round':>5} " + f"{'downloads':>9} {'armed/pool':>10} {'broken/pool':>11} " + f"{'PUT ok':>6} {'PUT fail':>8}" + ) + print(header) + totals: dict[str, Counter[str]] = {} + failures: list[str] = [] + for r in by_type.get("round", []): + variant = str(r["variant"]) + total = totals.setdefault(variant, Counter()) + failed: list[dict[str, object]] = list(r["failures"]) + for key in ("armed", "broken"): + value = r[key] + if isinstance(value, int): + total[key] += value + else: + total[f"{key}_na"] += 1 + total["downloads_bad"] += downloads - int(str(r["downloads_ok"])) + total["puts_failed"] += len(failed) + print( + f"{variant:<10} {timeouts.get(variant)!s:>12} {r['round']!s:>5} " + f"{r['downloads_ok']!s:>6}/{downloads:<2} " + f"{r['armed']!s:>5}/{r['pooled']!s:<4} " + f"{r['broken']!s:>6}/{r['pooled_idle']!s:<4} " + f"{r['puts_ok']!s:>6} {len(failed):>8}", + ) + for item in failed: + causes = " <- ".join(str(name) for name in list(item["chain"])) + failures.append( + f" {variant} round {r['round']} PUT {item['put']}: " + f"{item['ms']} ms, {causes}: {item['message']}", + ) + if failures: + print("failed PUT (error and its causes):") + print("\n".join(failures)) + print( + f"'Object storage is unavailable' records of the probe: {storage_warnings}", + ) + readback = {str(r["variant"]): r for r in by_type.get("readback", [])} + for variant, total in totals.items(): + back = readback.get(variant, {}) + na = " (pool counters n/a)" if total["broken_na"] else "" + print( + f"{variant}: armed {total['armed']}, broken {total['broken']}" + f"{na}, PUT failed {total['puts_failed']}, bad downloads " + f"{total['downloads_bad']}, read back {back.get('intact')}/" + f"{back.get('written')} with the same size and SHA-256", + ) + cleanup = (by_type.get("cleanup") or [{}])[0] + leftovers = s3_idle_leftovers(bucket, database) + print( + f"cleanup: deleted {cleanup.get('removed')}/{cleanup.get('written')} " + f"objects; files left under {database}/{S3_IDLE_PREFIX}/: " + f"{'unknown' if leftovers is None else leftovers}", + ) + image = totals.get("image", Counter()) + image_back = readback.get("image", {}) + problems = [] + if image["broken"]: + problems.append(f"image variant: {image['broken']} broken connections") + if image["puts_failed"]: + problems.append(f"image variant: {image['puts_failed']} PUT failed") + if image["downloads_bad"]: + problems.append( + f"image variant: {image['downloads_bad']} bad downloads", + ) + if image_back.get("intact") != image_back.get("written"): + problems.append("image variant: objects read back differ") + if len(by_type.get("round", [])) != 2 * rounds: + problems.append("probe did not finish every round") + if leftovers != 0: + problems.append("probe objects left in the bucket") + if problems: + print("FAIL: " + "; ".join(problems)) + return 1 + print( + "PASS: image client keeps no read timer in the pool; every PUT after " + "the idle passed", + ) + return 0 + + def main() -> int: parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) parser.add_argument("--port", type=int, default=DEFAULT_PORT) @@ -4571,6 +5000,17 @@ def main() -> int: stress.add_argument("--seconds", type=float, default=40) stress.add_argument("--clients", type=int, default=4) sub.add_parser("reconcile-signal") + 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) + idle_s3.add_argument("--puts", type=int, default=12) + idle_s3.add_argument("--size-mib", type=int, default=4) + idle_s3.add_argument( + "--pause-ms", + type=float, + default=0.5, + help="пауза потребителя после блока 64 KiB, мс", + ) lbto = sub.add_parser("lb-upload-timeouts") lbto.add_argument( "--config", @@ -4674,6 +5114,15 @@ def main() -> int: ) if args.cmd == "reconcile-signal": return cmd_reconcile_signal() + if args.cmd == "s3-idle": + return cmd_s3_idle( + port, + rounds=args.rounds, + downloads=args.downloads, + puts=args.puts, + size_mib=args.size_mib, + pause_ms=args.pause_ms, + ) if args.cmd == "lb-upload-timeouts": return cmd_lb_upload_timeouts(args.config, args.image) if args.cmd == "stop-at-start": diff --git a/AGENTS.md b/AGENTS.md index ab7f1d32..52043c18 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -364,6 +364,7 @@ structlog (JSON в stdout), redis-py (клиент Valkey), aiobotocore | `driver.py --port attachment-storage` | схема таблиц вложений, вид `object_key`, объект в bucket, анонимный GET — 403, `docker diff` реплик; доказательство исключения «Байты не в БД и не на диске API» | | `driver.py --port upload-consistency` | согласованность БД и S3 на рабочем стенде (~45 с): загрузка при `pause` S3 и со сбоем фиксации `ready` (триггер на `filename` прогона) — 503, строки `pending` не видны, компенсация удалила объект; `cleaner --once` с grace 30 с убирает обе, объектов без строки нет, готовое вложение цело; `evidence/attachments/consistency.md` | | `driver.py lb-upload-timeouts [--config F]` | сроки LB пути загрузки без стенда (~35 с): `haproxy -c`, временная сеть, HAProxy закреплённого образа с F (по умолчанию `infra/haproxy/haproxy.cfg`) и заглушка реплики `api` на образе API; молчание 12 с до и после тела загрузки — 201, 12 с на другом пути — 504 через ~10 с, 32 с на пути загрузки — 504 через ~30 с, клиент молчит посреди тела — 400 в формате контракта; уборка при любом исходе, код 1 при расхождении; `evidence/uploads/lb-timeouts.md` | +| `driver.py --port s3-idle [--rounds 3]` | клиент S3 после простоя (~40 с, change `fix-upload-put-flake`): проба в реплике стенда (`docker exec -i … python -`, код и ключи образа), варианты «образ» и «эталон» с прежним `read_timeout` aiohttp; раунд — 10 одновременных медленных скачиваний 4 MiB, простой срока вызова + 0,5 с, 12 PUT; взведённые и испорченные соединения пула, PUT прошло и упало (цепочка ошибки, мс), чтение обратно; объекты под `<база>/.s3-idle-probe/` удаляются в `finally`; код 0 — у образа ни порчи, ни упавших PUT, 1 — иначе, 2 — нет стенда; `evidence/s3/idle-connection.md` | | `make reconcile [APPLY=1] [MAX_CHANGES=N]` | разовая сверка bucket и БД в контейнере уборщика (`docker compose run --rm --no-deps cleaner reconcile [--apply] [--max-changes N]`): по умолчанию dry-run — записи «Found storage discrepancy» по классам и итог; `APPLY=1` — исправить; 0 — расхождений нет, 3 — остались (чужие объекты, отказ по пределу), 1 — прервана, 2 — конфигурация | | `driver.py --port reconcile-cycle` | сверка на рабочем стенде (~2 мин): исходный dry-run без расхождений (иначе код 2), расхождения с обеих сторон, dry-run без изменений, 500 → `--apply` → 404 и 200, повтор, удаление чужого объекта, свежий объект после grace, возврат оригинала; `evidence/reconcile/cycle.md` | | `driver.py --port reconcile-stress [--seconds S] [--clients N]` | `--apply` раз в ~3 с под загрузками и отправками N клиентов S секунд (4 × 40 с): внесённое исправлено, каждое 201 скачивается с тем же SHA-256, повтор — 0; `evidence/reconcile/stress.md` | @@ -380,7 +381,7 @@ structlog (JSON в stdout), redis-py (клиент Valkey), aiobotocore | `make wipe_data` | `down -v` — удалить данные стенда (volumes Postgres и S3 называются в запросе) и кэш; только после ввода `yes` | | `make test_isolated [KEEP_TEST_DB=1]` | образ на временной базе `test_` с Valkey и S3 стенда (ключи кэша и объектов разделены именем базы): сборка, миграции, отдельный контейнер API на `TEST_APP_PORT`, `make test` + `make student_test EXPECT_REPLICAS=1` (тесты реплик пропускаются с причиной), уборка при любом исходе — база и объекты под префиксом `test_/` (`student-tests.md`) | | `make student_test [BASE_URL=...] [EXPECT_REPLICAS=...]` | собственные тесты `student-tests/` (pytest) против запущенного сервера, кроме проверок отказов (`-m 'not fault'`); `EXPECT_REPLICAS` (по умолчанию `API_REPLICAS`) — сколько реплик за `BASE_URL`, против одного процесса — 1; сервер недоступен — код 2 и одна строка с адресом | -| `make failure_checks [FAULT_ARGS=...]` | проверки отказов (`pytest -m fault`, ~4 мин) на отдельном стенде: проект `<рабочий>-failures` со своими Postgres, Valkey и S3 (с bootstrap), уборщик (grace 20 с, интервал 1 с), обычный и «тесный» API (срок 2 с, пул 1), hook `student-tests/fault_hook.py`; после тестов — журнал PostgreSQL стенда: сводка (`crash markers`, «too many clients», «administrator command») и ненулевой код при признаках аварийного перезапуска; стенд и его volumes удаляются при любом исходе, рабочий не трогается (`student-tests.md`) | +| `make failure_checks [FAULT_ARGS=...]` | проверки отказов (`pytest -m fault`, ~4 мин) на отдельном стенде: проект `<рабочий>-failures` со своими Postgres, Valkey и S3 (с bootstrap), уборщик (grace 20 с, интервал 1 с), четыре API — обычный, «тесный» (срок 2 с, пул 1), «узкий по загрузкам» и «с коротким сроком S3» (1 с), hook `student-tests/fault_hook.py`; после тестов — журнал PostgreSQL стенда: сводка (`crash markers`, «too many clients», «administrator command») и ненулевой код при признаках аварийного перезапуска; стенд и его volumes удаляются при любом исходе, рабочий не трогается (`student-tests.md`) | | `make bench [BENCH_LABEL=...]` | полная матрица 10k / 100k / 500k читаемого чата плюс 100 000 сообщений в 1 110 фоновых чатах разного размера (~35 мин, оценка по `bench_quick`) на своём проекте compose `mtusi-bench` (HAProxy и одна реплика API, Postgres, Valkey с лимитами, без портов хоста и без `.env` рабочего стенда; k6 ходит через LB); на каждый размер — свежий стенд, `VACUUM (ANALYZE)`, планы запроса истории (`auto_explain`) по уровням чатов с вариантами индекса и запроса, в конце — пробы стоимости записи по вариантам. Результаты в `evidence/bench/<метка>/`, занятая метка — отказ. Перед запуском — подготовка хоста (`bench.md`) | | `make bench_quick` | самопроверка стенда на 1k / 5k / 10k и 3 500 фоновых сообщений (~3 мин), метка `quick-<время>`, в git не идёт | | `make bench_restore [RESTORE_LABEL=...]` | трек 2, восстановление (~20 мин, метка `restore` по умолчанию): тот же стенд и данные, без матрицы прогонов; на каждый размер — `pg_dump` во время записи через HTTP, активность после backup, `pg_restore -j` в новый контейнер Postgres на новом volume, сверка обеих баз построчно, переключение API, проверки через HTTP до и после `FLUSHALL`; время dump / restore / RTO и потерянные сообщения — в `summary.md` | @@ -446,7 +447,7 @@ src/ db/models/ # модели SQLAlchemy (Base с created_at и to_dict); idempotency.py — ключи, FK на сообщение отложен до commit; attachment.py — Attachment (частичный индекс pending по (created_at, id), lost_at — пометка потерянного оригинала) и MessageAttachment (порядок position, FK без каскада) cache/client.py # create_cache (redis-py: повтор только на обрыв, блокирующий пул), Cache: срок на команду, отказ — промах и пропуск cache/instance.py # глобал cache процесса API - s3/client.py # create_object_storage (aiobotocore: path-адресация, без повторов, пул), ObjectStorage: put (поток read/seek/tell и size) / head / open (чтение блоками) / delete / list_page (ListObjectsV2 по префиксу, нет bucket — ошибка), срок на вызов и блок, ошибки → ObjectStorageUnavailable / StoredObjectMissing; StoredObjectInfo (с last_modified), StoredObject, StoredObjectPage + s3/client.py # create_object_storage (aiobotocore: path-адресация, без повторов, пул), ObjectStorage: put (поток read/seek/tell и size) / head / open (чтение блоками) / delete / list_page (ListObjectsV2 по префиксу, нет bucket — ошибка), срок на вызов и блок — единственный срок клиента (read_timeout aiohttp выключен: переживал ответ и портил соединение в пуле, change fix-upload-put-flake), ошибки → ObjectStorageUnavailable / StoredObjectMissing; StoredObjectInfo (с last_modified), StoredObject, StoredObjectPage s3/instance.py # глобал object_storage процесса API, namespace — имя базы; start() и aclose() в lifespan schemas/ dataclasses/.py # DTO между repo → service → api @@ -457,8 +458,8 @@ src/ utc.py # utcnow() (aware UTC), формат RFC 3339 с Z cursor.py # непрозрачный keyset-курсор: кодирование и разбор; поля проверяются по отдельности, незнакомые игнорируются, смена формата — новая CURSOR_VERSION student-tests/ # black-box тесты по HTTP (уровень 4): make student_test - conftest.py # BASE_URL, EXPECT_REPLICAS и фикстура replicas (пропуск против одного процесса), проверка доступности, фикстуры alice/bob/eve/chat и stand/tight_api/uploads_api, сбор маркеров spec, стоп без hook - api_client.py # Api поверх httpx; Actor.headers() — единственное место идентификации; post_message/send_message (с attachment_ids) — с Idempotency-Key; post_attachment/upload, attachment_meta, attachment_content + conftest.py # BASE_URL, EXPECT_REPLICAS и фикстура replicas (пропуск против одного процесса), проверка доступности, фикстуры alice/bob/eve/chat и stand/tight_api/uploads_api/s3_api, сбор маркеров spec, стоп без hook + api_client.py # Api поверх httpx; Actor.headers() — единственное место идентификации; post_message/send_message (с attachment_ids) — с Idempotency-Key; post_attachment/upload, attachment_meta, attachment_content, attachment_content_slowly (потоком с паузой после блока) contract.py # тела по схемам contracts/openapi.json, форматы id, attachment_ids и времени, X-Instance-Id, assert_error (с 413, 415 и 429 — Retry-After положительное целое), assert_errors (статусы всех вариантов запроса разом), assert_content (байты, тип, nosniff, без Location и x-amz-*), assert_replicas images.py # изображения для тестов: PNG на stdlib (любые IHDR, Adam7, точный размер, бомба, огромные размеры, порча байта, шум RGB ~1 MiB от зерна — png_noise), JPEG через Pillow (dev), обрезка и хвост test_attachments.py # спек attachments: загрузка, лимиты, тип и целостность, filename, доступ, метаданные, оригинал, variant, повтор, 10 одновременных загрузок, другая реплика @@ -469,7 +470,7 @@ student-tests/ # black-box тесты по HTTP (уровень 4) test_.py # сценарии основных спеков, маркер @pytest.mark.spec test_failures.py # проверки отказов (маркер fault): только make failure_checks run_isolated.py # make test_isolated: образ на временной базе test_, уборка базы и префикса test_/ в S3 (weed shell fs.rm, затем проверка fs.ls: код 0 weed shell успеха не значит; префикс только из проверенного имени) (stdlib) - run_failures.py # make failure_checks: стенд <рабочий>-failures (Postgres, Valkey, S3 + bootstrap, уборщик с grace 20 с и интервалом 1 с без плановой сверки → FAULT_CLEANER_*, FAULT_RECONCILER_INTERVAL_S; уборщик с плановой сверкой <проект>-cleaner-scheduled убирается вместе с API), три API (обычный, «тесный», «узкий по загрузкам» с UPLOADS_ENV → FAULT_UPLOADS_BASE_URL / FAULT_UPLOADS_ENV), pytest -m fault, журнал PostgreSQL стенда (сводка, признаки аварии — ненулевой код), журналы API и уборщика при падении, уборка (stdlib) + run_failures.py # make failure_checks: стенд <рабочий>-failures (Postgres, Valkey, S3 + bootstrap, уборщик с grace 20 с и интервалом 1 с без плановой сверки → FAULT_CLEANER_*, FAULT_RECONCILER_INTERVAL_S; уборщик с плановой сверкой <проект>-cleaner-scheduled убирается вместе с API), четыре API (обычный, «тесный», «узкий по загрузкам» с UPLOADS_ENV → FAULT_UPLOADS_BASE_URL / FAULT_UPLOADS_ENV, «с коротким сроком S3» с S3_ENV → FAULT_S3_BASE_URL / FAULT_S3_ENV), pytest -m fault, журнал PostgreSQL стенда (сводка, признаки аварии — ненулевой код), журналы API и уборщика при падении, уборка (stdlib) fault_hook.py # hook стенда отказов: stop/start/pause/unpause postgres|valkey|s3, кэш, триггеры сбоя участников, сообщений и вложений (fail-attachments insert|ready|stall|commit|outlive|undeletable: сбой вставки, перевода в ready до и на COMMIT, задержка, строка «старше grace» с ожиданием уборщика, неудаляемая строка), заполнение слотов max_connections, счётчик сессий PostgreSQL db-sessions, attachment-ids, last-pending, object-ids (файлы original по fs.tree), kill-api / start-api; расхождения и сверка (change track2-reconciler): put-object (тело — stdin, botocore в контейнере API его ключами) / delete-object (weed fs.rm) только под <база>/attachments/, delete-row, set-size, age-row, set-key (object_key строки под <база>/), lost-ids, fail-attachments mark, reconcile dry-run|apply [предел] (записи и exit_code=), stop|start cleaner, run-cleaner <с> (stdlib) failures.compose.yml # override стенда отказов: без публикации портов (Postgres, Valkey, S3, LB), уборщик с CLEANER__* 20 / 1, RECONCILER__INTERVAL_SECONDS 0 и restart "no", stop_grace_period 2 с у S3, healthcheck PostgreSQL — на служебную базу postgres (не добавляет сессий в базу приложения), init: true у PostgreSQL (сирот psql из fill-connections подбирает init, а не postmaster) bench/ # нагрузочный стенд на HAProxy + N реплик API + Postgres + Valkey: make bench / bench_quick / bench_restore / bench_failover / bench_rollout / bench_scaling / bench_uploads (с S3) diff --git a/PLAN.md b/PLAN.md index f6eeb0f8..06ab5270 100644 --- a/PLAN.md +++ b/PLAN.md @@ -1363,6 +1363,19 @@ Change вне сводной таблицы, до `track2-reconcile-cost`: ис 7. **Путь PUT не меняется** (решение 5): то же тело, заголовки, соединение и срок. Проба памяти PUT 10 MiB на прототипе — 1,18 тела против 1,19. +Приняты в `/opsx:apply` 2026-10-23 (design, «Уточнения apply»): + +8. Медленное скачивание теста — `Api.attachment_content_slowly`, ответ + проверяет обычный `assert_content`. Оригинал — `png_noise(1024, 1365)` + (~4 MiB), пользователи — фикстуры обычного API: база у API стенда общая. +9. Красный прогон на `4cfaab0`: три из трёх упали уже в раунде 1. +10. `driver.py s3-idle` считает объекты по списку записанных ключей: + списка у ключа API нет. Удаляет их отдельный клиент без скачиваний, + остаток проверяет `weed shell fs.tree` по файлам. Эталон — клиент + проекта с подменённым на время `start()` `AioConfig` + (`read_timeout=[s3] timeout_seconds`). По умолчанию 3 раунда и PUT + по 128 KiB. + #### Вопросы 1. Нужна ли пересъёмка полной метки `make bench_uploads` @@ -1378,3 +1391,7 @@ Change вне сводной таблицы, до `track2-reconcile-cost`: ис работают контейнеры другого проекта. Решение — за пользователем. По умолчанию до ответа — не переснимать, метка `baseline` остаётся. + + **Ответ пользователя 2026-10-23:** полную метку не переснимать, + `evidence/uploads/baseline/` остаётся. В apply — точечная проба памяти + PUT и `make bench_uploads_quick` (tasks 4.4). diff --git a/openspec/changes/fix-upload-put-flake/design.md b/openspec/changes/fix-upload-put-flake/design.md index 0002c1fb..767622fb 100644 --- a/openspec/changes/fix-upload-put-flake/design.md +++ b/openspec/changes/fix-upload-put-flake/design.md @@ -387,4 +387,39 @@ Evidence `evidence/s3/idle-connection.md`: ## Open Questions Нет. Пересъёмка метки `uploads` — вопрос пользователю (решение 5), план -и задачи от ответа не зависят. +и задачи от ответа не зависят. Ответ 2026-10-23: полную метку не +переснимать, `baseline` остаётся; в apply — точечная проба памяти PUT и +`make bench_uploads_quick` (tasks 4.4). + +## Уточнения apply + +1. **Медленное скачивание в тесте** — `Api.attachment_content_slowly` + (`client.stream`, `iter_bytes(64 KiB)`, сон после блока). Он отдаёт + `httpx.Response` с прочитанными байтами в `content`, поэтому байты, + тип, длину и заголовки проверяет тот же `assert_content`, а не своя + копия проверки. +2. **Оригинал теста** — `images.png_noise(1024, 1365)` (~4,0 MiB): RGB-шум + почти не сжимается, размер — около `width × height × 3`. Пользователи + и чат — фикстуры обычного API (`alice`, `chat`): база общая для всех + API стенда, а к S3 обычный API в этом тесте не обращается. +3. **Тест красный уже в первом раунде**: на `4cfaab0` три прогона из трёх + упали в раунде 1 (загрузки 4, 8 и 3). Порча чаще, чем p ≈ 0,28 из + пробы propose. Оценка промаха в докстринге остаётся консервативной. +4. **`driver.py s3-idle`: объекты учитываются по списку записанных + ключей**, а не листингом префикса: у ключа API права на список нет + (bootstrap это проверяет). Удаляет их в `finally` отдельный клиент + без скачиваний: в его пуле нечему испортиться, а пулы обоих вариантов + к этому моменту закрыты. Что ничего не осталось, драйвер проверяет + через `weed shell fs.tree` по файлам `source` и `r<раунд>-p<номер>`: + каталоги SeaweedFS убирает позже файлов. +5. **Эталон `s3-idle`** — `ObjectStorage` проекта, у которого на время + `start()` в модуле клиента подменён `AioConfig` и выставлен + `read_timeout=[s3] timeout_seconds`. Тот же код вызова, пул и перевод + ошибок, а отличается только срок чтения. На образе до правки оба + варианта совпадают (`read_timeout` 5.0 у обоих). +6. **Параметры `s3-idle` по умолчанию**: 3 раунда, PUT по 128 KiB + случайных байт (размер `sample.png` по порядку величины), пауза + 0,5 мс на блок, как в design. Отладочный прогон на рабочем стенде до + правки (1 раунд): образ — 3 взведённых и 3 испорченных соединения, + 3 PUT из 12 упали за 0,7–1,0 мс; эталон — 5 и 5, 5 PUT упали. Записанные + объекты читаются обратно целиком, файлов пробы не осталось. diff --git a/openspec/changes/fix-upload-put-flake/tasks.md b/openspec/changes/fix-upload-put-flake/tasks.md index 273a2b7e..701095a1 100644 --- a/openspec/changes/fix-upload-put-flake/tasks.md +++ b/openspec/changes/fix-upload-put-flake/tasks.md @@ -47,7 +47,7 @@ неизвестный сценарий. Проверка: `make student_test BASE_URL=http://localhost:8090` — сверка покрытия (`test_coverage.py`) зелёная, новый сценарий учтён как проверка отказов. -- [ ] 1.6 Красный прогон до правки: `make failure_checks FAULT_ARGS='-k +- [x] 1.6 Красный прогон до правки: `make failure_checks FAULT_ARGS='-k idle_s3'` три раза подряд на дереве с тестом и без правки 2.1. Каждый — 1 failed: 503 `unavailable` на загрузке после простоя, номер раунда — в выводе. В журнале API стенда — `put_object` `ReadTimeoutError` за ~1 мс. @@ -55,7 +55,7 @@ ## 2. Правка клиента S3 -- [ ] 2.1 `src/infra/s3/client.py`, `_create_client`: `read_timeout=None` +- [x] 2.1 `src/infra/s3/client.py`, `_create_client`: `read_timeout=None` (design, решение 1). Рядом — комментарий: - срок чтения aiohttp переживает ответ и портит соединение в пуле (aiohttp 3.13–3.14.5); @@ -72,7 +72,7 @@ ## 3. Драйвер и evidence механизма -- [ ] 3.1 `driver.py s3-idle` скилла `run-mtusi-messenger` (stdlib, +- [x] 3.1 `driver.py s3-idle` скилла `run-mtusi-messenger` (stdlib, Python 3.9; design, решение 4): - проба через `docker exec -i <реплика api> python -` в работающей реплике стенда, uvloop, если есть; @@ -133,7 +133,7 @@ ## 5. Документы -- [ ] 5.1 `.claude/rules/infra.md`, раздел S3 (design, решение 1): +- [x] 5.1 `.claude/rules/infra.md`, раздел S3 (design, решение 1): - срок — только `asyncio.timeout` вызова и блока; - `read_timeout` aiohttp выключен, почему, и запрет включать без новой пробы; @@ -142,7 +142,7 @@ Проверка: `grep -n read_timeout .claude/rules/infra.md` — только новая формулировка. -- [ ] 5.2 `.claude/rules/student-tests.md`: четвёртый API стенда отказов, +- [x] 5.2 `.claude/rules/student-tests.md`: четвёртый API стенда отказов, `test_upload_after_idle_s3`, красный и зелёный прогоны, время прогона. AGENTS.md: карта кода (`run_failures.py` — четыре API, `client.py` — срок только приложения), таблица команд (`s3-idle`), описание `make diff --git a/src/infra/s3/client.py b/src/infra/s3/client.py index 12e1be5a..9f34ecdd 100644 --- a/src/infra/s3/client.py +++ b/src/infra/s3/client.py @@ -3,8 +3,12 @@ Design change `s3-storage`, решения 6–7. Каждый вызов ограничен `[s3] timeout_seconds` (`asyncio.timeout`), повторов botocore нет (`total_max_attempts=1`): рестарт S3 повтора не требует, таймаут, как у -Valkey, не повторяется, а загрузку повторяет клиент контракта. Ошибки -переводятся в доменные исключения: +Valkey, не повторяется, а загрузку повторяет клиент контракта. Срок — +только у приложения: `asyncio.timeout` на вызов и на каждый блок +потокового чтения; срок чтения сокета aiohttp выключен (`read_timeout` +None): он переживал ответ и портил соединение в пуле (design change +`fix-upload-put-flake`, решение 1). Ошибки переводятся в доменные +исключения: - отказ соединения, обрыв, таймаут, 5xx, отказ в учётных данных или в доступе и отсутствующий bucket — `ObjectStorageUnavailable` (503 @@ -301,7 +305,14 @@ class ObjectStorage: # виртуальные хосты bucket.s3 Docker DNS не разрешает s3={"addressing_style": "path"}, connect_timeout=s3.connect_timeout_seconds, - read_timeout=s3.timeout_seconds, + # срока чтения aiohttp нет: в 3.13–3.14.5 после потокового + # ответа больше буфера `resume_reading()` взводит его уже у + # соединения в пуле, через срок он срабатывает и портит + # соединение, и следующий вызов падает за 1 мс + # (`ReadTimeoutError`, 503). Срок вызова и блока чтения — + # `asyncio.timeout` в `_call` и `_read_chunk` (design change + # `fix-upload-put-flake`, решение 1) + read_timeout=None, # повторов нет: отказ — сразу 503, срок — один на вызов retries={"total_max_attempts": 1}, max_pool_connections=s3.max_connections,