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:
+17
-2
@@ -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
|
||||
|
||||
@@ -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":
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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
@@ -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,
|
||||
|
||||
Reference in New Issue
Block a user