"""`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())