Upload answers 202 after staging, a queued job in PostgreSQL and a broker confirm; a separate worker publishes the original and a thumbnail with bounded retries. Adds the job and variant tables, the broker service, the worker S3 user, cleanup and reconcile support for staging and variants, the failure stand with broker and worker, bench and driver updates. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
492 lines
19 KiB
Python
492 lines
19 KiB
Python
"""`make failure_checks`: проверки отказов на отдельном стенде.
|
||
|
||
Поднимает тот же `docker-compose.yml` под проектом `<рабочий>-failures`
|
||
с override `student-tests/failures.compose.yml`: свои PostgreSQL, Valkey,
|
||
S3 и брокер со своими volumes, порты хранилищ не публикуются. Затем:
|
||
- собирает образ из рабочего дерева, применяет миграции и bootstrap S3;
|
||
- запускает уборщика незавершённых загрузок с grace 20 с и интервалом
|
||
1 с (`failures.compose.yml`; design change `upload-consistency`,
|
||
решение 10) без плановой сверки (design change `track2-reconciler`,
|
||
решение 9) и передаёт значения тестам; уборщика с плановой сверкой
|
||
`<проект>-cleaner-scheduled` запускает hook и убирает этот скрипт;
|
||
- запускает worker с короткими сроками и малым числом попыток (design
|
||
change `async-attachments`, решение 15) и передаёт значения тестам;
|
||
- запускает четыре контейнера API: обычный (с `MAX_UPLOAD_BYTES=1` и
|
||
`MAX_IMAGE_PIXELS=1` в окружении — лимиты вложений от них не зависят),
|
||
«тесный» (сроки сессии и ключа идемпотентности 2 с, пул из одного
|
||
соединения), «узкий по загрузкам» (одно место загрузки, одна в
|
||
очереди, ожидание места 1 с, срок тела 3 с; change `upload-memory`) и
|
||
«с коротким сроком S3» (срок вызова S3 1 с; change
|
||
`fix-upload-put-flake`);
|
||
- прогоняет тесты с маркером `fault` (`pytest -m fault`), передав им hook
|
||
`student-tests/fault_hook.py`; при падении печатает журналы API, уборщика
|
||
и worker;
|
||
- после тестов читает журнал PostgreSQL стенда: печатает сводку и падает
|
||
на признаках аварийного перезапуска (решение 12 design change
|
||
`fix-known-issues`);
|
||
- удаляет стенд вместе с volume при любом исходе, в том числе по Ctrl+C.
|
||
|
||
Рабочий стенд, его база, кэш и хранилище объектов не затрагиваются. Только stdlib. Решения
|
||
1, 2, 5 design change `failure-checks`. Запускается `$(PYTHON)`, а не
|
||
`uv run`, по той же причине, что `run_isolated.py`.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import json
|
||
import os
|
||
import signal
|
||
import socket
|
||
import subprocess
|
||
import sys
|
||
import time
|
||
import urllib.error
|
||
import urllib.request
|
||
from pathlib import Path
|
||
|
||
ROOT = Path(__file__).resolve().parents[1]
|
||
ENV_FILE = ROOT / ".env"
|
||
COMPOSE_FILES = (
|
||
ROOT / "docker-compose.yml",
|
||
ROOT / "student-tests" / "failures.compose.yml",
|
||
)
|
||
FAULT_HOOK = ROOT / "student-tests" / "fault_hook.py"
|
||
PROJECT_SUFFIX = "-failures"
|
||
READY_TIMEOUT_S = 60
|
||
LOG_TAIL_LINES = 50
|
||
# признаки аварийного перезапуска PostgreSQL: postmaster счёл аварией выход
|
||
# неизвестного потомка, завершил все процессы и восстанавливается. Штатные
|
||
# stop / start дают «database system was shut down», обрыв backend — FATAL
|
||
CRASH_MARKERS = (
|
||
"untracked child process",
|
||
"terminating any other active server processes",
|
||
"reinitializing",
|
||
"automatic recovery in progress",
|
||
)
|
||
CRASH_LINES_MAX = 20
|
||
# «тесный» API: короткие сроки сессии и ключа идемпотентности, пул из
|
||
# одного соединения
|
||
TIGHT_ENV = {
|
||
"AUTH__SESSION_TTL_SECONDS": "2",
|
||
"IDEMPOTENCY__TTL_SECONDS": "2",
|
||
"DATABASE__POOL_SIZE": "1",
|
||
"DATABASE__MAX_OVERFLOW": "0",
|
||
"DATABASE__POOL_TIMEOUT_SECONDS": "1",
|
||
"DATABASE__REQUEST_TIMEOUT_SECONDS": "2",
|
||
}
|
||
# обычный API: имена лимитов skeleton с заведомо малыми значениями. Лимиты
|
||
# вложений — константы контракта, и окружение их не меняет (спек
|
||
# `service-configuration`, «Окружение не меняет лимит»): тест грузит
|
||
# `sample.png` и ждёт 201. Те же пары тест получает в
|
||
# `FAULT_LIMITS_ENV` и сверяет, что стенд запущен с ними
|
||
LIMITS_ENV = {
|
||
"MAX_UPLOAD_BYTES": "1",
|
||
"MAX_IMAGE_PIXELS": "1",
|
||
}
|
||
# «узкий по загрузкам» API (change upload-memory, design, решение 11): одно
|
||
# место загрузки, одна загрузка в очереди, ожидание места 1 с, срок тела
|
||
# 3 с: держатель места в test_upload_slots_busy отпускается через ~1,3–1,5 с
|
||
# после того, как занял место (ожидавшая получает 429 через 1 с), и срок
|
||
# тела должен оставить запас (с 2 с он был ~0,5 с; verify, S5). Те же пары
|
||
# тест получает в `FAULT_UPLOADS_ENV` и сверяет, что стенд запущен с ними
|
||
UPLOADS_ENV = {
|
||
"UPLOADS__MAX_CONCURRENT": "1",
|
||
"UPLOADS__MAX_WAITING": "1",
|
||
"UPLOADS__WAIT_TIMEOUT_SECONDS": "1",
|
||
"UPLOADS__BODY_TIMEOUT_SECONDS": "3",
|
||
}
|
||
# API «с коротким сроком S3» (change fix-upload-put-flake, design, решение
|
||
# 3): срок вызова S3 1 с, и простой дольше срока в test_upload_after_idle_s3
|
||
# — 1,5 с, а не 6. Других тестов на нём нет: пул S3 процесса — только от
|
||
# этого теста. Те же пары тест получает в `FAULT_S3_ENV` и сверяет стенд
|
||
S3_ENV = {
|
||
"S3__TIMEOUT_SECONDS": "1",
|
||
}
|
||
|
||
|
||
def say(message: str) -> None:
|
||
print(f"[failure_checks] {message}", flush=True)
|
||
|
||
|
||
def run(
|
||
*args: str,
|
||
check: bool = True,
|
||
quiet: bool = False,
|
||
env: dict[str, str] | None = None,
|
||
) -> subprocess.CompletedProcess[str]:
|
||
"""Команда из корня репозитория; вывод — в терминал, если не quiet."""
|
||
return subprocess.run(
|
||
args,
|
||
cwd=ROOT,
|
||
check=check,
|
||
text=True,
|
||
capture_output=quiet,
|
||
env=env,
|
||
)
|
||
|
||
|
||
def dc(
|
||
project: str,
|
||
*args: str,
|
||
check: bool = True,
|
||
quiet: bool = False,
|
||
) -> subprocess.CompletedProcess[str]:
|
||
"""docker compose проекта отказов; без `-p` не вызывается никогда."""
|
||
files = [arg for path in COMPOSE_FILES for arg in ("-f", str(path))]
|
||
return run(
|
||
"docker",
|
||
"compose",
|
||
"-p",
|
||
project,
|
||
*files,
|
||
*args,
|
||
check=check,
|
||
quiet=quiet,
|
||
)
|
||
|
||
|
||
def working_project() -> str:
|
||
config = run("docker", "compose", "config", "--format", "json", quiet=True)
|
||
return json.loads(config.stdout)["name"]
|
||
|
||
|
||
def app_port() -> str:
|
||
"""`APP__PORT` из `.env`: на нём слушает API внутри контейнера."""
|
||
if ENV_FILE.exists():
|
||
for line in ENV_FILE.read_text(encoding="utf-8").splitlines():
|
||
if line.strip().startswith("APP__PORT="):
|
||
return line.split("=", 1)[1].strip()
|
||
return "8080"
|
||
|
||
|
||
def storage_names(project: str) -> dict[str, str]:
|
||
"""Bucket и имя базы стенда — из окружения сервиса `api` в его
|
||
конфигурации compose: по ним hook считает объекты вложений."""
|
||
config = dc(project, "config", "--format", "json", quiet=True)
|
||
environment = json.loads(config.stdout)["services"]["api"]["environment"]
|
||
return {
|
||
"FAULT_S3_BUCKET": environment["S3__BUCKET"],
|
||
"FAULT_DATABASE": environment["DATABASE__NAME"],
|
||
}
|
||
|
||
|
||
def cleaner_timings(project: str) -> dict[str, str]:
|
||
"""Grace и интервал уборщика стенда — из окружения сервиса `cleaner`
|
||
в конфигурации compose (`failures.compose.yml`): тесты ждут по ним."""
|
||
config = dc(project, "config", "--format", "json", quiet=True)
|
||
environment = json.loads(config.stdout)["services"]["cleaner"][
|
||
"environment"
|
||
]
|
||
return {
|
||
"FAULT_CLEANER_GRACE_S": environment["CLEANER__PENDING_GRACE_SECONDS"],
|
||
"FAULT_CLEANER_INTERVAL_S": environment["CLEANER__INTERVAL_SECONDS"],
|
||
"FAULT_RECONCILER_INTERVAL_S": environment[
|
||
"RECONCILER__INTERVAL_SECONDS"
|
||
],
|
||
}
|
||
|
||
|
||
def worker_timings(project: str) -> dict[str, str]:
|
||
"""Сроки и попытки worker стенда — из конфигурации compose
|
||
(`failures.compose.yml`): тесты ждут по ним."""
|
||
config = dc(project, "config", "--format", "json", quiet=True)
|
||
environment = json.loads(config.stdout)["services"]["worker"][
|
||
"environment"
|
||
]
|
||
return {
|
||
"FAULT_WORKER_MAX_ATTEMPTS": environment["WORKER__MAX_ATTEMPTS"],
|
||
"FAULT_WORKER_RETRY_DELAY_S": environment[
|
||
"WORKER__RETRY_DELAY_SECONDS"
|
||
],
|
||
"FAULT_WORKER_JOB_TIMEOUT_S": environment[
|
||
"WORKER__JOB_TIMEOUT_SECONDS"
|
||
],
|
||
"FAULT_WORKER_GRACEFUL_S": environment[
|
||
"WORKER__GRACEFUL_SHUTDOWN_SECONDS"
|
||
],
|
||
}
|
||
|
||
|
||
def env_pairs(env: dict[str, str]) -> str:
|
||
"""`KEY=value` через пробел: так окружение API получают тесты."""
|
||
return " ".join(f"{key}={value}" for key, value in env.items())
|
||
|
||
|
||
def free_port() -> int:
|
||
with socket.socket() as sock:
|
||
sock.bind(("127.0.0.1", 0))
|
||
return sock.getsockname()[1]
|
||
|
||
|
||
def wait_ready(url: str, container: str) -> None:
|
||
deadline = time.monotonic() + READY_TIMEOUT_S
|
||
while time.monotonic() < deadline:
|
||
try:
|
||
with urllib.request.urlopen(url, timeout=2) as response:
|
||
if response.status == 200:
|
||
return
|
||
except (urllib.error.URLError, OSError):
|
||
pass
|
||
state = run(
|
||
"docker",
|
||
"inspect",
|
||
"-f",
|
||
"{{.State.Running}}",
|
||
container,
|
||
check=False,
|
||
quiet=True,
|
||
)
|
||
if state.stdout.strip() != "true":
|
||
raise RuntimeError(f"container {container} is not running")
|
||
time.sleep(1)
|
||
raise RuntimeError(f"{url} not ready in {READY_TIMEOUT_S}s")
|
||
|
||
|
||
def leftovers(project: str, kind: str) -> str:
|
||
"""Контейнеры (`ps -a`) или volume проекта, которые ещё остались."""
|
||
command = ("ps", "-aq") if kind == "container" else ("volume", "ls", "-q")
|
||
return run(
|
||
"docker",
|
||
*command,
|
||
"--filter",
|
||
f"label=com.docker.compose.project={project}",
|
||
quiet=True,
|
||
check=False,
|
||
).stdout.strip()
|
||
|
||
|
||
def cleanup(project: str, containers: list[str]) -> bool:
|
||
"""Контейнеры API, сервисы и volume проекта отказов; True — чисто."""
|
||
for name in containers:
|
||
run("docker", "rm", "-f", name, check=False, quiet=True)
|
||
down = dc(project, "down", "-v", "--remove-orphans", check=False)
|
||
return (
|
||
down.returncode == 0
|
||
and not leftovers(project, "container")
|
||
and not leftovers(project, "volume")
|
||
)
|
||
|
||
|
||
def postgres_log_check(project: str) -> int:
|
||
"""Журнал PostgreSQL стенда отказов: сводка всегда, признаки аварии —
|
||
строками; 1 — признаки есть или журнал не прочитан. Два счётчика
|
||
FATAL показывают, что заполнение и освобождение слотов правда были."""
|
||
log = dc(
|
||
project,
|
||
"logs",
|
||
"--no-log-prefix",
|
||
"postgres",
|
||
check=False,
|
||
quiet=True,
|
||
)
|
||
if log.returncode != 0:
|
||
# сбой чтения журнала — не сбой подготовки стенда
|
||
tail = log.stderr.strip().splitlines()[-1:] or ["no stderr"]
|
||
say(
|
||
f"postgres log unavailable: docker compose logs exited "
|
||
f"{log.returncode}: {tail[0]}",
|
||
)
|
||
return 1
|
||
lines = (log.stdout + log.stderr).splitlines()
|
||
crashes = [line for line in lines if any(m in line for m in CRASH_MARKERS)]
|
||
too_many = sum("too many clients" in line for line in lines)
|
||
admin = sum("administrator command" in line for line in lines)
|
||
say(
|
||
f"postgres log: {len(lines)} lines, crash markers {len(crashes)}; "
|
||
f'"too many clients" {too_many}, "administrator command" {admin}',
|
||
)
|
||
if not crashes:
|
||
return 0
|
||
say("crash markers in the postgres log:")
|
||
for line in crashes[:CRASH_LINES_MAX]:
|
||
print(line, flush=True)
|
||
return 1
|
||
|
||
|
||
def start_api(
|
||
project: str,
|
||
name: str,
|
||
port: int,
|
||
env: dict[str, str],
|
||
) -> str:
|
||
env_args = [
|
||
arg for key, value in env.items() for arg in ("-e", f"{key}={value}")
|
||
]
|
||
dc(
|
||
project,
|
||
"run",
|
||
"-d",
|
||
"--no-deps",
|
||
"--name",
|
||
name,
|
||
*env_args,
|
||
"-p",
|
||
f"127.0.0.1:{port}:{app_port()}",
|
||
"api",
|
||
quiet=True,
|
||
)
|
||
base_url = f"http://127.0.0.1:{port}"
|
||
wait_ready(f"{base_url}/health/ready", name)
|
||
return base_url
|
||
|
||
|
||
def main() -> int:
|
||
pytest_args = sys.argv[1:]
|
||
working = working_project()
|
||
project = f"{working}{PROJECT_SUFFIX}"
|
||
if project == working or not project.endswith(PROJECT_SUFFIX):
|
||
say(f"refusing to use project {project!r}")
|
||
return 2
|
||
default_name = f"{project}-api"
|
||
tight_name = f"{project}-api-tight"
|
||
uploads_name = f"{project}-api-uploads"
|
||
s3_name = f"{project}-api-s3"
|
||
# уборщик с плановой сверкой — его запускает hook run-cleaner (design
|
||
# change track2-reconciler, решение 11); убирается вместе с API
|
||
scheduled_name = f"{project}-cleaner-scheduled"
|
||
containers = [
|
||
default_name,
|
||
tight_name,
|
||
uploads_name,
|
||
s3_name,
|
||
scheduled_name,
|
||
]
|
||
|
||
say(f"project={project} (working stand: {working})")
|
||
if not cleanup(project, containers):
|
||
say("leftovers of a previous run could not be removed")
|
||
return 1
|
||
|
||
results: dict[str, int] = {}
|
||
failed = True
|
||
try:
|
||
say("build image")
|
||
dc(project, "build", "api")
|
||
say("start postgres, valkey, s3 and rabbitmq")
|
||
dc(
|
||
project,
|
||
"up",
|
||
"-d",
|
||
"--wait",
|
||
"postgres",
|
||
"valkey",
|
||
"s3",
|
||
"rabbitmq",
|
||
)
|
||
say("migrations")
|
||
dc(project, "run", "--rm", "migrate")
|
||
# --wait одноразовый сервис считает готовым уже запущенным: код
|
||
# выхода bootstrap — отдельным up, как make start_s3
|
||
say("s3 bootstrap")
|
||
dc(
|
||
project,
|
||
"up",
|
||
"--no-deps",
|
||
"--exit-code-from",
|
||
"s3-bootstrap",
|
||
"s3-bootstrap",
|
||
)
|
||
timings = cleaner_timings(project)
|
||
say(
|
||
f"start cleaner: grace {timings['FAULT_CLEANER_GRACE_S']} s, "
|
||
f"interval {timings['FAULT_CLEANER_INTERVAL_S']} s, "
|
||
"reconcile interval "
|
||
f"{timings['FAULT_RECONCILER_INTERVAL_S']} s (0 — off)",
|
||
)
|
||
dc(project, "up", "-d", "--no-deps", "cleaner")
|
||
workers = worker_timings(project)
|
||
say(
|
||
f"start worker: attempts {workers['FAULT_WORKER_MAX_ATTEMPTS']}, "
|
||
f"retry delay {workers['FAULT_WORKER_RETRY_DELAY_S']} s, "
|
||
f"job timeout {workers['FAULT_WORKER_JOB_TIMEOUT_S']} s, "
|
||
f"graceful {workers['FAULT_WORKER_GRACEFUL_S']} s",
|
||
)
|
||
dc(project, "up", "-d", "--no-deps", "worker")
|
||
say("start api containers")
|
||
base_url = start_api(project, default_name, free_port(), LIMITS_ENV)
|
||
tight_url = start_api(project, tight_name, free_port(), TIGHT_ENV)
|
||
uploads_url = start_api(
|
||
project,
|
||
uploads_name,
|
||
free_port(),
|
||
UPLOADS_ENV,
|
||
)
|
||
s3_url = start_api(project, s3_name, free_port(), S3_ENV)
|
||
say(
|
||
f"ready: api={base_url} tight={tight_url} uploads={uploads_url} "
|
||
f"s3={s3_url}",
|
||
)
|
||
env = (
|
||
os.environ
|
||
| {
|
||
"BASE_URL": base_url,
|
||
"FAULT_TIGHT_BASE_URL": tight_url,
|
||
"FAULT_UPLOADS_BASE_URL": uploads_url,
|
||
"FAULT_S3_BASE_URL": s3_url,
|
||
"FAULT_HOOK": str(FAULT_HOOK),
|
||
"FAULT_PROJECT": project,
|
||
"FAULT_LIMITS_ENV": env_pairs(LIMITS_ENV),
|
||
"FAULT_UPLOADS_ENV": env_pairs(UPLOADS_ENV),
|
||
"FAULT_S3_ENV": env_pairs(S3_ENV),
|
||
}
|
||
| storage_names(project)
|
||
| timings
|
||
| workers
|
||
)
|
||
say("pytest -m fault")
|
||
results["fault"] = run(
|
||
"uv",
|
||
"run",
|
||
"pytest",
|
||
"-m",
|
||
"fault",
|
||
*pytest_args,
|
||
check=False,
|
||
env=env,
|
||
).returncode
|
||
failed = bool(results["fault"])
|
||
# стенд ещё жив: журнал PostgreSQL до уборки
|
||
results["postgres"] = postgres_log_check(project)
|
||
except KeyboardInterrupt:
|
||
say("interrupted")
|
||
results["interrupted"] = 130
|
||
except (subprocess.CalledProcessError, RuntimeError) as e:
|
||
say(f"setup failed: {e}")
|
||
results["setup"] = 1
|
||
finally:
|
||
# повторный Ctrl+C не должен оборвать уборку на полпути
|
||
signal.signal(signal.SIGINT, signal.SIG_IGN)
|
||
if failed:
|
||
for name in containers:
|
||
say(f"last {LOG_TAIL_LINES} lines of {name}")
|
||
run(
|
||
"docker",
|
||
"logs",
|
||
"--tail",
|
||
str(LOG_TAIL_LINES),
|
||
name,
|
||
check=False,
|
||
)
|
||
for service in ("cleaner", "worker"):
|
||
say(f"last {LOG_TAIL_LINES} lines of {service}")
|
||
dc(
|
||
project,
|
||
"logs",
|
||
"--no-log-prefix",
|
||
"--tail",
|
||
str(LOG_TAIL_LINES),
|
||
service,
|
||
check=False,
|
||
)
|
||
say("cleanup")
|
||
if not cleanup(project, containers):
|
||
say("cleanup failed")
|
||
results["cleanup"] = 1
|
||
|
||
say(f"results: {results}")
|
||
return next((code for code in results.values() if code), 0)
|
||
|
||
|
||
if __name__ == "__main__":
|
||
sys.exit(main())
|