forked from mtusi2026/mtusi2026lab5
197 lines
9.4 KiB
Python
197 lines
9.4 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 cli_in(container: str, *args: str) -> dict:
|
||
"""То же, что cli(), но в конкретном контейнере (там, где включена точка-пауза)."""
|
||
out = _run(["docker", "exec", "-i", container, "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(seconds: float = 30) -> dict:
|
||
"""{очередь: (готовых к выдаче, выдано и не подтверждено)} — rabbitmqctl внутри контейнера брокера.
|
||
|
||
Сразу после перезапуска брокер уже отвечает на ping, но quorum-очереди ещё восстанавливаются
|
||
с диска, и list_queues может один раз не ответить: тогда повторяем до seconds секунд.
|
||
"""
|
||
args = ("exec", "-T", "broker", "rabbitmqctl", "-q", "list_queues", "-p", "messenger",
|
||
"name", "messages_ready", "messages_unacknowledged", "--formatter", "json")
|
||
deadline = time.monotonic() + seconds
|
||
while True:
|
||
out = compose(*args, check_exit=False) # при ошибке rabbitmqctl печатает справку, не JSON
|
||
try:
|
||
rows = json.loads(out or "[]")
|
||
return {q["name"]: (int(q["messages_ready"]), int(q["messages_unacknowledged"])) for q in rows}
|
||
except (ValueError, KeyError, TypeError):
|
||
pass
|
||
check(time.monotonic() < deadline, "rabbitmqctl list_queues: the broker does not answer")
|
||
time.sleep(1)
|
||
|
||
|
||
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()")
|