Files
mtusi2026lab5/student-tests/ops.py
T
2026-10-25 21:43:03 +03:00

176 lines
8.2 KiB
Python

"""lab5: управление стендом для собственных проверок — всё, что делается через Docker.
Тесты останавливают и запускают сервисы, ставят worker на паузу, включают точки отказа
(src/messenger/faults.py) и смотрят в PostgreSQL и RabbitMQ только через этот модуль.
Так в самих тестах видно, ЧТО делается со стендом, а не КАК вызвать docker.
Точка отказа включается файлом /tmp/faults/<имя> внутри контейнера (docker exec). Процесс
сам удаляет файл, когда точка сработала, поэтому после перезапуска он работает нормально.
Секреты не печатаются: код внутри контейнеров сам читает их из /run/secrets.
"""
import json
import re
import subprocess
import time
from helpers import ROOT, check
_NAME = re.compile(r"^[a-z_]{1,40}$")
_VALUE = re.compile(r"^[0-9.]{1,10}$")
def _run(args, stdin: bytes | None = None, check_exit: bool = True) -> str:
result = subprocess.run(args, cwd=ROOT, input=stdin, capture_output=True)
if check_exit and result.returncode != 0:
last = (result.stderr.decode("utf-8", "replace").strip().splitlines() or [""])[-1]
check(False, f"`{' '.join(args[:4])} ...` failed: {last[:300]}")
return result.stdout.decode("utf-8", "replace").strip()
def compose(*args, stdin: bytes | None = None, check_exit: bool = True) -> str:
return _run(["docker", "compose", *args], stdin, check_exit)
def docker(*args, check_exit: bool = True) -> str:
return _run(["docker", *args], None, check_exit)
# ---------- сервисы и контейнеры ----------
def containers(service: str, include_stopped: bool = False) -> list[str]:
"""Полные ID контейнеров сервиса (по умолчанию только запущенные)."""
args = ["ps", "-q", "-a", service] if include_stopped else ["ps", "-q", service]
return sorted(compose(*args).split())
def stop(*services: str) -> None:
compose("stop", *services)
def start(*services: str) -> None:
compose("start", *services)
def restart(*services: str) -> None:
compose("restart", *services)
def pause(container: str) -> None:
docker("pause", container)
def unpause(container: str) -> None:
docker("unpause", container)
def scale(service: str, replicas: int) -> None:
"""Число контейнеров сервиса; существующие не пересоздаются."""
compose("up", "-d", "--no-recreate", "--scale", f"{service}={replicas}", service)
def restarts(container: str) -> int:
"""Сколько раз Docker перезапускал контейнер (restart: unless-stopped после падения)."""
return int(docker("inspect", "-f", "{{.RestartCount}}", container) or 0)
def health(container: str) -> str:
return docker("inspect", "-f", "{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}",
container, check_exit=False)
def wait_healthy(service: str, count: int, seconds: float = 120) -> list[str]:
"""Дождаться count запущенных и healthy контейнеров сервиса."""
deadline = time.monotonic() + seconds
while True:
running = containers(service)
ready = [c for c in running if health(c) == "healthy"]
if len(ready) >= count:
return ready
check(time.monotonic() < deadline, f"{service}: {len(ready)} healthy of {count} after {seconds} s")
time.sleep(1)
def logs(service: str, since: str = "10m") -> str:
return compose("logs", "--no-color", "--since", since, service, check_exit=False)
# ---------- точки отказа ----------
def arm(service: str, point: str, value: str = "1", container: str | None = None) -> list[str]:
"""Включить точку отказа во всех контейнерах сервиса (или в одном). Возвращает ID контейнеров."""
check(bool(_NAME.match(point)) and bool(_VALUE.match(value)), "bad fault point")
targets = [container] if container else containers(service)
for target in targets:
docker("exec", target, "sh", "-c", f"mkdir -p /tmp/faults && printf '%s' {value} > /tmp/faults/{point}")
return targets
def disarm(service: str, point: str) -> None:
check(bool(_NAME.match(point)), "bad fault point")
for target in containers(service):
docker("exec", target, "rm", "-f", f"/tmp/faults/{point}", check_exit=False)
def armed(container: str, point: str) -> bool:
check(bool(_NAME.match(point)), "bad fault point")
return docker("exec", container, "sh", "-c", f"test -e /tmp/faults/{point} && echo yes || echo no",
check_exit=False) == "yes"
# ---------- код и данные внутри стенда ----------
def python(service: str, code: str, container: str | None = None) -> str:
"""Python-код внутри контейнера (модули messenger и секреты есть только там). Возвращает stdout."""
target = container or containers(service)[0]
return _run(["docker", "exec", "-i", target, "python", "-"], code.encode("utf-8"))
def cli(service: str, *args: str) -> dict:
"""python -m <модуль> ... внутри контейнера, последний вывод — одна строка JSON."""
out = _run(["docker", "compose", "exec", "-T", service, "python", "-m", *args])
lines = [line for line in out.splitlines() if line.startswith("{") or line.startswith("[")]
check(bool(lines), f"no JSON from {' '.join(args)}")
return json.loads(lines[-1])
def job(attachment_id: str, service: str = "api") -> dict:
"""Состояние задания, журнал, строки outbox и варианты (python -m messenger.jobs show)."""
return cli(service, "messenger.jobs", "show", attachment_id)
def replay(attachment_id: str) -> dict:
return cli("api", "messenger.jobs", "replay", attachment_id, "--actor", "student-test")
def psql(sql: str) -> str:
"""SQL в PostgreSQL стенда (значения в SQL — проверенные UUID и числа)."""
return compose("exec", "-T", "postgres", "psql", "-X", "-q", "-t", "-A", "-U", "messenger", "-d", "messenger",
"-v", "ON_ERROR_STOP=1", "-c", sql)
def queues() -> dict:
"""{очередь: (готовых к выдаче, выдано и не подтверждено)} — rabbitmqctl внутри контейнера брокера."""
out = compose("exec", "-T", "broker", "rabbitmqctl", "-q", "list_queues", "-p", "messenger",
"name", "messages_ready", "messages_unacknowledged", "--formatter", "json")
return {q["name"]: (int(q["messages_ready"]), int(q["messages_unacknowledged"])) for q in json.loads(out or "[]")}
def objects(prefix: str) -> list[str]:
"""Ключи объектов S3 под префиксом (список из контейнера API его ключами)."""
out = python("api", "import json\nfrom messenger import objects\n"
f"print(json.dumps([k for k, _ in objects.list_objects({prefix!r})]))")
return json.loads(out.splitlines()[-1])
def publish(message: dict) -> None:
"""Отправить сообщение в очередь заданий напрямую (имитация повторной доставки)."""
python("api", "import json\nfrom messenger import broker\n"
f"p = broker.Publisher('student-test')\np.publish(json.loads({json.dumps(message)!r}))\np.close()")
def publish_raw(body: bytes) -> None:
"""Отправить в очередь произвольное тело (проверка, что worker отвергает чужой формат)."""
python("api", "import pika\nfrom messenger import broker\n"
"c = broker.connect('student-test'); ch = c.channel(); ch.confirm_delivery()\n"
f"ch.basic_publish(broker.EXCHANGE, broker.ROUTING_KEY, {body!r}, mandatory=True)\nc.close()")