305 lines
15 KiB
Python
305 lines
15 KiB
Python
#!/usr/bin/env python3
|
||
"""Инфраструктурные проверки стенда лабораторной 2; код возврата 0 — только если всё прошло.
|
||
|
||
python student-tests/verify_stack.py
|
||
|
||
Проверяет то, чего не видно через HTTP: пользователя внутри контейнера, отсутствие
|
||
публикации PostgreSQL и Valkey, файловые секреты и их отсутствие в выводе
|
||
`docker compose config`, настройки долговечности Valkey, соответствие схемы
|
||
миграциям и наличие ровно тех индексов и ограничений, на которые опираются
|
||
запросы. Требуется запущенный Docker и поднятый стенд.
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
import argparse
|
||
import hashlib
|
||
import os
|
||
import platform
|
||
import subprocess
|
||
import sys
|
||
import time
|
||
from pathlib import Path
|
||
|
||
HERE = Path(__file__).resolve().parent
|
||
if str(HERE) not in sys.path:
|
||
sys.path.insert(0, str(HERE))
|
||
|
||
import harness # noqa: E402 (путь добавлен выше)
|
||
|
||
ROOT = harness.ROOT
|
||
DEFAULT_BASE_URL = "http://127.0.0.1:8080"
|
||
API_CONTAINER = harness.API_CONTAINER
|
||
POSTGRES_CONTAINER = harness.POSTGRES_CONTAINER
|
||
VALKEY_CONTAINER = harness.VALKEY_CONTAINER
|
||
MIGRATE_CONTAINER = "mtusi2026lab2-migrate-1"
|
||
APP_UID = "10001"
|
||
EXPECTED_INDEXES = (
|
||
"ix_messages_chat_id_created_at_id",
|
||
"ix_chat_members_user_id_chat_id",
|
||
"uq_users_username",
|
||
)
|
||
EXPECTED_CHECKS = (
|
||
"users:ck_users_username_format",
|
||
"users:ck_users_display_name_length",
|
||
"chats:ck_chats_title_length",
|
||
"messages:ck_messages_text_length",
|
||
)
|
||
|
||
PASSED: list[str] = []
|
||
FAILED: list[str] = []
|
||
|
||
|
||
def say(message: str = "") -> None:
|
||
print(message, flush=True)
|
||
|
||
|
||
def section(title: str) -> None:
|
||
say()
|
||
say("=" * 72)
|
||
say(title)
|
||
say("=" * 72)
|
||
|
||
|
||
def record(ok: bool, what: str, detail: str = "") -> bool:
|
||
(PASSED if ok else FAILED).append(what)
|
||
say(" [%s] %s%s" % ("OK" if ok else "FAIL", what, (" — " + detail) if detail else ""))
|
||
return ok
|
||
|
||
|
||
def docker(*arguments: str) -> subprocess.CompletedProcess:
|
||
"""`docker ...` с окружением, в котором docker CLI находит свои плагины."""
|
||
say("$ docker " + " ".join(arguments))
|
||
result = subprocess.run(
|
||
["docker", *arguments], cwd=str(ROOT), capture_output=True, text=True,
|
||
encoding="utf-8", errors="replace", env=harness.docker_env(), timeout=120,
|
||
)
|
||
if result.stdout.strip():
|
||
say(result.stdout.strip())
|
||
if result.stderr.strip():
|
||
say(result.stderr.strip())
|
||
return result
|
||
|
||
|
||
def compose(*arguments: str) -> subprocess.CompletedProcess:
|
||
say("$ docker compose " + " ".join(arguments))
|
||
result = harness.compose(*arguments)
|
||
if result.stdout.strip():
|
||
say(result.stdout.strip())
|
||
if result.stderr.strip():
|
||
say(result.stderr.strip())
|
||
return result
|
||
|
||
|
||
def compose_field(*arguments: str) -> str:
|
||
"""Тот же compose, но без печати вывода: для проверок вида «верни одно значение»."""
|
||
return harness.compose(*arguments).stdout.strip()
|
||
|
||
|
||
def valkey_config(name: str) -> str:
|
||
"""Значение CONFIG GET: пустое значение — это когда второй строки нет."""
|
||
lines = harness.valkey("CONFIG", "GET", name).splitlines()
|
||
return lines[1].strip() if len(lines) > 1 else ""
|
||
|
||
|
||
def container_state(name: str, template: str) -> str:
|
||
result = subprocess.run(
|
||
["docker", "inspect", "--format", template, name], cwd=str(ROOT),
|
||
capture_output=True, text=True, encoding="utf-8", errors="replace",
|
||
env=harness.docker_env(), timeout=60,
|
||
)
|
||
return result.stdout.strip()
|
||
|
||
|
||
def main() -> int:
|
||
parser = argparse.ArgumentParser(description="Проверка стенда лабораторной 2")
|
||
parser.add_argument("--base-url",
|
||
default=os.environ.get("BASE_URL", DEFAULT_BASE_URL))
|
||
arguments = parser.parse_args()
|
||
|
||
section("Аппаратура и версии")
|
||
say(" хост: %s %s (%s)" % (platform.system(), platform.release(), platform.machine()))
|
||
say(" python: %s" % platform.python_version())
|
||
say(" стенд: %s" % ROOT)
|
||
|
||
section("0. Docker и Compose доступны")
|
||
if not record(harness.docker_available(), "docker compose отвечает"):
|
||
say("Запустите Docker Desktop и повторите.")
|
||
return 1
|
||
say(" docker: %s" % compose_field("version", "--short"))
|
||
say(" compose: %s" % compose_field("version", "--format", "{{.Version}}"))
|
||
|
||
section("1. Состав стенда")
|
||
compose("ps", "--all")
|
||
running = compose_field("ps", "--status", "running", "--services").split()
|
||
for service in ("api", "postgres", "valkey"):
|
||
record(service in running, "сервис %s запущен" % service)
|
||
migrate_exit = container_state(MIGRATE_CONTAINER, "{{.State.ExitCode}}")
|
||
record(migrate_exit == "0", "одноразовая миграция завершилась с кодом %s" % migrate_exit)
|
||
config = harness.compose("config").stdout
|
||
pinned = [line.strip() for line in config.splitlines() if "image:" in line and "@sha256:" in line]
|
||
for line in pinned:
|
||
say(" %s" % line)
|
||
record(len(pinned) >= 2, "образы postgres и valkey закреплены по digest", "%d строк" % len(pinned))
|
||
|
||
section("2. Непривилегированный пользователь")
|
||
identity = compose_field("exec", "-T", "api", "id")
|
||
say(" $ docker compose exec -T api id -> %s" % identity)
|
||
record("uid=%s" % APP_UID in identity, "процесс работает под uid %s" % APP_UID)
|
||
configured_user = container_state(API_CONTAINER, "{{.Config.User}}")
|
||
record(configured_user.startswith(APP_UID),
|
||
"USER образа равен %s" % APP_UID, configured_user)
|
||
status = harness.compose("exec", "-T", "api", "cat", "/proc/1/status").stdout
|
||
uid_line = [line for line in status.splitlines() if line.startswith("Uid:")]
|
||
record(bool(uid_line) and uid_line[0].split()[1] == APP_UID,
|
||
"PID 1 работает не от root", uid_line[0].strip() if uid_line else "нет строки Uid")
|
||
caps = container_state(API_CONTAINER, "{{.HostConfig.CapDrop}} {{.HostConfig.Privileged}}")
|
||
say(" CapDrop/Privileged: %s" % caps)
|
||
|
||
section("3. Сеть: что и куда публикуется")
|
||
for name, service in ((POSTGRES_CONTAINER, "postgres"), (VALKEY_CONTAINER, "valkey")):
|
||
bindings = container_state(name, "{{json .HostConfig.PortBindings}}")
|
||
record(bindings in ("", "null", "{}"), "%s не публикует порты" % service, bindings)
|
||
api_bindings = container_state(API_CONTAINER, "{{json .HostConfig.PortBindings}}")
|
||
say(" api: %s" % api_bindings)
|
||
record("127.0.0.1" in api_bindings and "0.0.0.0" not in api_bindings,
|
||
"API опубликован только на loopback")
|
||
|
||
section("4. Секреты")
|
||
secrets_dir = ROOT / "secrets"
|
||
names = sorted(path.name for path in secrets_dir.glob("*") if path.is_file())
|
||
say(" файлы: %s" % ", ".join(names))
|
||
record(bool(names), "каталог secrets/ заполнен")
|
||
ignored = subprocess.run(
|
||
["git", "check-ignore", *[str(secrets_dir / name) for name in names], ".env"],
|
||
cwd=str(ROOT), capture_output=True, text=True, encoding="utf-8", errors="replace",
|
||
)
|
||
record(ignored.returncode == 0, "secrets/ и .env вне Git (git check-ignore)")
|
||
tracked = subprocess.run(
|
||
["git", "ls-files", "secrets"], cwd=str(ROOT), capture_output=True, text=True,
|
||
encoding="utf-8", errors="replace",
|
||
).stdout.strip()
|
||
record(not tracked, "в индексе Git нет файлов secrets/")
|
||
password = (secrets_dir / "postgres_password").read_text(encoding="utf-8").strip()
|
||
record(bool(password) and password not in harness.compose("config").stdout,
|
||
"docker compose config не печатает пароль PostgreSQL")
|
||
database_url = (secrets_dir / "database_url").read_text(encoding="utf-8").strip()
|
||
record(password in database_url and database_url not in harness.compose("config").stdout,
|
||
"database_url с паролем тоже не попадает в вывод compose")
|
||
seen = harness.compose("exec", "-T", "api", "ls", "-l", "/run/secrets").stdout
|
||
say(" /run/secrets:\n%s" % seen.rstrip())
|
||
record("database_url" in seen and "cache_url" in seen,
|
||
"секреты смонтированы файлами в /run/secrets")
|
||
environment = harness.compose("exec", "-T", "api", "env").stdout
|
||
record("DATABASE_URL_FILE=/run/secrets/database_url" in environment,
|
||
"контейнер получает *_FILE, а не значение")
|
||
record(password not in environment and database_url not in environment,
|
||
"значений секретов нет в окружении процесса")
|
||
|
||
section("5. Valkey: долговечность сессий")
|
||
for name, expected in (("appendonly", "yes"), ("appendfsync", "everysec"), ("save", "")):
|
||
actual = valkey_config(name)
|
||
record(actual == expected, "CONFIG GET %s = %r" % (name, expected), "получено %r" % actual)
|
||
persistence = harness.valkey("INFO", "persistence")
|
||
aof_enabled = [line for line in persistence.splitlines() if line.startswith("aof_enabled:")]
|
||
record(aof_enabled[:1] == ["aof_enabled:1"], "INFO persistence подтверждает AOF",
|
||
aof_enabled[0] if aof_enabled else "нет строки aof_enabled")
|
||
volume = container_state(VALKEY_CONTAINER, "{{range .Mounts}}{{.Destination}} {{end}}")
|
||
record("/data" in volume, "данные лежат в именованном томе", volume.strip())
|
||
|
||
section("6. PostgreSQL: схема, миграции, индексы")
|
||
version = harness.psql("SELECT version();").strip()
|
||
say(" %s" % version.split(" on ")[0])
|
||
record("PostgreSQL 16" in version, "версия PostgreSQL соответствует compose")
|
||
current = compose_field("run", "--rm", "migrate", "alembic", "current")
|
||
record("(head)" in current, "схема находится на head", current.splitlines()[-1].strip())
|
||
first = harness.compose("run", "--rm", "migrate")
|
||
second = harness.compose("run", "--rm", "migrate")
|
||
record(first.returncode == 0 and second.returncode == 0,
|
||
"alembic upgrade head проходит повторно без ошибок")
|
||
record("Running upgrade" not in second.stdout + second.stderr,
|
||
"повторный прогон миграции ничего не меняет (нет Running upgrade)")
|
||
check = harness.compose("run", "--rm", "migrate", "alembic", "check")
|
||
record("No new upgrade operations detected" in check.stdout + check.stderr,
|
||
"alembic check: миграция совпадает с моделями SQLAlchemy")
|
||
indexes = dict(
|
||
line.split(" :: ", 1)
|
||
for line in harness.psql(
|
||
"SELECT indexname || ' :: ' || indexdef FROM pg_indexes WHERE schemaname = 'public';"
|
||
).splitlines()
|
||
if " :: " in line
|
||
)
|
||
for name in EXPECTED_INDEXES:
|
||
record(name in indexes, "индекс %s существует" % name, indexes.get(name, "нет"))
|
||
checks = set()
|
||
for line in harness.psql(
|
||
"SELECT conrelid::regclass || ' : ' || conname FROM pg_constraint "
|
||
"WHERE connamespace = 'public'::regnamespace AND contype = 'c';"
|
||
).splitlines():
|
||
if " : " in line:
|
||
left, right = line.split(" : ", 1)
|
||
checks.add("%s:%s" % (left.strip(), right.strip()))
|
||
for name in EXPECTED_CHECKS:
|
||
record(name in checks, "CHECK-ограничение %s существует" % name)
|
||
say(" все ограничения: %s" % ", ".join(sorted(checks)))
|
||
|
||
section("7. Сквозная проверка через HTTP")
|
||
api = harness.client()
|
||
username = harness.unique("stack")
|
||
secret = harness.fresh_password()
|
||
user = harness.register(api, username, secret)
|
||
session = harness.login(api, username, secret)
|
||
record(bool(session["token"]) and len(session["token"]) >= 32,
|
||
"вход выдаёт opaque-токен длиной %d" % len(session["token"]))
|
||
actor = {"token": session["token"], "id": user["id"], "username": username, "password": secret}
|
||
me = api.call("GET", "/api/v1/users/me", 200, actor=actor, schema="User")["json"]
|
||
record(me["id"] == user["id"], "/users/me возвращает владельца сессии")
|
||
record("password" not in me and "password_hash" not in me,
|
||
"в ответе нет ни пароля, ни его хэша")
|
||
key = harness.SESSION_KEY_PREFIX + hashlib.sha256(session["token"].encode()).hexdigest()
|
||
record(harness.valkey("EXISTS", key) == "1", "сессия лежит в Valkey")
|
||
record(session["token"] not in key, "ключ — sha256 токена, а не сам токен")
|
||
ttl = int(harness.valkey("TTL", key))
|
||
record(0 < ttl <= 3600, "у ключа положительный TTL", "%d s" % ttl)
|
||
record(harness.valkey("KEYS", harness.SESSION_KEY_PREFIX + session["token"] + "*") == "",
|
||
"сырой токен не встречается ни в одном имени ключа")
|
||
|
||
section("8. Логи не содержат секретов")
|
||
logs = harness.compose("logs", "--no-color", "api")
|
||
text = logs.stdout + logs.stderr
|
||
say(" всего строк лога: %d" % len(text.splitlines()))
|
||
for label, needle in (("пароль", secret), ("токен", session["token"]),
|
||
("ключ сессии", key)):
|
||
record(needle not in text, "во всём логе нет %s" % label)
|
||
record("cursor=" not in text, "во всём логе нет query-строки с курсором")
|
||
record("Authorization" not in text and "Basic " not in text,
|
||
"во всём логе нет заголовка авторизации")
|
||
|
||
section("9. Ограничения ресурсов и политика перезапуска")
|
||
for name, service in ((API_CONTAINER, "api"), (POSTGRES_CONTAINER, "postgres"),
|
||
(VALKEY_CONTAINER, "valkey")):
|
||
memory = container_state(name, "{{.HostConfig.Memory}}")
|
||
policy = container_state(name, "{{.HostConfig.RestartPolicy.Name}}")
|
||
record(memory not in ("", "0") and policy == "unless-stopped",
|
||
"%s: память %s Б, restart=%s" % (service, memory, policy))
|
||
|
||
section("Итог")
|
||
say(" успешно: %d" % len(PASSED))
|
||
for what in FAILED:
|
||
say(" провалено: %s" % what)
|
||
say()
|
||
say("РЕЗУЛЬТАТ: %s" % ("PASS" if not FAILED else "FAIL"))
|
||
return 0 if not FAILED else 1
|
||
|
||
|
||
if __name__ == "__main__":
|
||
started = time.monotonic()
|
||
try:
|
||
raise SystemExit(main())
|
||
except SystemExit:
|
||
raise
|
||
except Exception as error: # noqa: BLE001
|
||
say()
|
||
say("НЕОЖИДАННАЯ ОШИБКА через %.1f s: %s: %s"
|
||
% (time.monotonic() - started, type(error).__name__, error))
|
||
raise SystemExit(1) from error
|