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 <noreply@anthropic.com>
This commit is contained in:
2026-10-23 01:13:36 +03:00
co-authored by Claude Opus 5.5
parent 4cfaab0063
commit b5983f0e35
9 changed files with 579 additions and 21 deletions
+17 -2
View File
@@ -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
+33 -5
View File
@@ -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 с);
@@ -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/<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` |
| `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 — проход дошёл до конца
@@ -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":
+6 -5
View File
@@ -364,6 +364,7 @@ structlog (JSON в stdout), redis-py (клиент Valkey), aiobotocore
| `driver.py --port <LB> attachment-storage` | схема таблиц вложений, вид `object_key`, объект в bucket, анонимный GET — 403, `docker diff` реплик; доказательство исключения «Байты не в БД и не на диске API» |
| `driver.py --port <LB> 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 <LB> 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 <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` |
@@ -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_<db>` с Valkey и S3 стенда (ключи кэша и объектов разделены именем базы): сборка, миграции, отдельный контейнер API на `TEST_APP_PORT`, `make test` + `make student_test EXPECT_REPLICAS=1` (тесты реплик пропускаются с причиной), уборка при любом исходе — база и объекты под префиксом `test_<db>/` (`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/<domain>.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_<capability>.py # сценарии основных спеков, маркер @pytest.mark.spec
test_failures.py # проверки отказов (маркер fault): только make failure_checks
run_isolated.py # make test_isolated: образ на временной базе test_<db>, уборка базы и префикса test_<db>/ в 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)
+17
View File
@@ -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).
@@ -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 упали. Записанные
объекты читаются обратно целиком, файлов пробы не осталось.
@@ -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
+14 -3
View File
@@ -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,