forked from mtusi2026/mtusi2026lab5
176 lines
8.2 KiB
Python
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()")
|