Files
mtusi2026lab6/student-tests/run_failures.py
T
ricoromaandClaude Opus 5.5 9cc6c0c7a6 chore: port lab 5 solution into the lab 6 skeleton
Source: mtusi2026lab5-safronov, solution/bvt2301-safronov, 046ec9e.
Contracts, public tests and evidence of lab 5 are not carried over.
The compose project, image and CI prefix are renamed to lab6; the first
broker start defect is recorded in KNOWN_ISSUES.md; PLAN.md outlines the
OpenSpec changes of lab 6.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 04:46:56 +03:00

573 lines
22 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""`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) и relay с частым опросом и коротким
порогом потерянного сообщения (design change `pipeline-reliability`, решение
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 и relay;
- после тестов читает журнал 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",
}
# проверки копят задания при остановленном worker и под нагрузкой: у четырёх
# API выше предел заданий выключен, иначе он отклонял бы загрузки чужих проверок
# (change track1-queue-overload, design, решение 13)
NO_BACKLOG_ENV = {
"UPLOADS__MAX_UNFINISHED_JOBS": "0",
}
# «узкий по заданиям» API: малый предел, те же пары тест получает в
# `FAULT_BACKLOG_ENV` и сверяет стенд
BACKLOG_ENV = {
"UPLOADS__MAX_UNFINISHED_JOBS": "3",
}
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_CLEANER_STAGING_RETENTION_S": environment[
"CLEANER__STAGING_RETENTION_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_BASE_S": environment[
"WORKER__RETRY_BASE_DELAY_SECONDS"
],
"FAULT_WORKER_RETRY_MAX_S": environment[
"WORKER__RETRY_MAX_DELAY_SECONDS"
],
"FAULT_WORKER_JOB_TIMEOUT_S": environment[
"WORKER__JOB_TIMEOUT_SECONDS"
],
"FAULT_WORKER_LEASE_MARGIN_S": environment[
"WORKER__LEASE_MARGIN_SECONDS"
],
"FAULT_WORKER_RENDER_TIMEOUT_S": environment[
"WORKER__RENDER_TIMEOUT_SECONDS"
],
"FAULT_WORKER_RENDER_CPU_S": environment[
"WORKER__RENDER_CPU_LIMIT_SECONDS"
],
"FAULT_WORKER_GRACEFUL_S": environment[
"WORKER__GRACEFUL_SHUTDOWN_SECONDS"
],
}
def relay_timings(project: str) -> dict[str, str]:
"""Сроки relay стенда — из конфигурации compose: тесты ждут по ним."""
config = dc(project, "config", "--format", "json", quiet=True)
environment = json.loads(config.stdout)["services"]["relay"]["environment"]
return {
"FAULT_RELAY_POLL_S": environment["RELAY__POLL_INTERVAL_SECONDS"],
"FAULT_RELAY_REPUBLISH_S": environment[
"RELAY__REPUBLISH_AFTER_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"
backlog_name = f"{project}-api-backlog"
# уборщик с плановой сверкой — его запускает hook run-cleaner (design
# change track2-reconciler, решение 11); убирается вместе с API
scheduled_name = f"{project}-cleaner-scheduled"
# вторые worker и relay — их запускает hook run-worker и run-relay (design
# change pipeline-reliability, решение 14)
containers = [
default_name,
tight_name,
uploads_name,
s3_name,
backlog_name,
scheduled_name,
f"{project}-worker-extra",
f"{project}-worker-second-extra",
f"{project}-relay-extra",
]
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 {workers['FAULT_WORKER_RETRY_BASE_S']}–"
f"{workers['FAULT_WORKER_RETRY_MAX_S']} s, "
f"job timeout {workers['FAULT_WORKER_JOB_TIMEOUT_S']} s, "
f"lease margin {workers['FAULT_WORKER_LEASE_MARGIN_S']} s, "
f"render {workers['FAULT_WORKER_RENDER_TIMEOUT_S']} s / "
f"{workers['FAULT_WORKER_RENDER_CPU_S']} s CPU, "
f"graceful {workers['FAULT_WORKER_GRACEFUL_S']} s",
)
dc(project, "up", "-d", "--no-deps", "worker")
relays = relay_timings(project)
say(
f"start relay: poll {relays['FAULT_RELAY_POLL_S']} s, "
f"republish after {relays['FAULT_RELAY_REPUBLISH_S']} s",
)
dc(project, "up", "-d", "--no-deps", "relay")
say("start api containers")
base_url = start_api(
project,
default_name,
free_port(),
LIMITS_ENV | NO_BACKLOG_ENV,
)
tight_url = start_api(
project,
tight_name,
free_port(),
TIGHT_ENV | NO_BACKLOG_ENV,
)
uploads_url = start_api(
project,
uploads_name,
free_port(),
UPLOADS_ENV | NO_BACKLOG_ENV,
)
s3_url = start_api(
project,
s3_name,
free_port(),
S3_ENV | NO_BACKLOG_ENV,
)
backlog_url = start_api(
project,
backlog_name,
free_port(),
BACKLOG_ENV,
)
say(
f"ready: api={base_url} tight={tight_url} uploads={uploads_url} "
f"s3={s3_url} backlog={backlog_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_BACKLOG_BASE_URL": backlog_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),
"FAULT_BACKLOG_ENV": env_pairs(BACKLOG_ENV),
}
| storage_names(project)
| timings
| workers
| relays
)
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", "relay"):
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())