Files
mtusi2026lab2-fork/scripts/dependency_demo.py
T
2026-10-23 14:09:32 +03:00

325 lines
16 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/usr/bin/env python3
"""Сценарий проверки кэша сессий и отказов зависимостей.
python scripts/dependency_demo.py [--output файл]
Показывает настройки Redis и попадания в кэш, отзыв сессии, рестарт и
остановку Redis, остановку PostgreSQL и восстановление. Тома не удаляются,
ключи Redis маскируются. Код возврата 0 -- все проверки прошли.
"""
import argparse
import base64
import hashlib
import json
import re
import subprocess
import sys
import time
import urllib.error
import urllib.request
import uuid
from datetime import datetime, timezone
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
COMPOSE = ["docker", "compose", "--env-file", ".env"]
class Fail(Exception):
"""Проверка не прошла."""
pass
class Log:
"""Вывод на экран с накоплением строк для файла."""
def __init__(self):
"""Пустой листинг."""
self.lines = []
def say(self, text=""):
"""Напечатать строку и добавить её в листинг."""
self.lines.append(text)
print(text, flush=True)
def title(self, text):
"""Напечатать заголовок раздела."""
self.say("")
self.say("=" * 78)
self.say(text)
self.say("=" * 78)
def check(condition, message):
"""Бросить Fail, если условие ложно."""
if not condition:
raise Fail(message)
def mask(text):
"""Скрыть SHA-256 токенов в ключах Redis."""
return re.sub(r"session:[0-9a-f]{64}", "session:<sha256 токена>", text)
def run(log, args, must_succeed=True):
"""Выполнить команду, записать её и вывод в листинг."""
log.say("$ " + mask(" ".join(a if a and " " not in a else '"%s"' % a for a in args)))
done = subprocess.run(args, cwd=str(ROOT), capture_output=True)
output = (done.stdout + done.stderr).decode("utf-8", errors="replace").strip()
if output:
log.say(mask(output))
if must_succeed and done.returncode != 0:
raise Fail("команда завершилась с кодом %d" % done.returncode)
return output
def env_value(name, default):
"""Значение переменной из .env."""
path = ROOT / ".env"
if path.exists():
for line in path.read_text(encoding="utf-8").splitlines():
if line.strip().startswith(name + "="):
return line.split("=", 1)[1].strip()
return default
def psql(log, query):
"""Выполнить запрос в контейнере db."""
user = env_value("POSTGRES_USER", "messenger")
db = env_value("POSTGRES_DB", "messenger")
return run(log, COMPOSE + ["exec", "-T", "db", "psql", "-U", user, "-d", db, "-At", "-c", query])
def redis_cli(log, *args):
"""Выполнить команду redis-cli в контейнере redis."""
return run(log, COMPOSE + ["exec", "-T", "redis", "redis-cli"] + list(args))
def http(base, method, path, body=None, headers=None, timeout=10):
"""HTTP-запрос: (статус, JSON или None, время в мс)."""
data = json.dumps(body).encode() if body is not None else None
request = urllib.request.Request(base + path, data=data, method=method, headers=dict(headers or {}))
if data is not None:
request.add_header("Content-Type", "application/json")
started = time.monotonic()
try:
with urllib.request.urlopen(request, timeout=timeout) as reply:
status, raw = reply.status, reply.read()
except urllib.error.HTTPError as error:
status, raw = error.code, error.read()
elapsed = (time.monotonic() - started) * 1000
return status, (json.loads(raw) if raw else None), elapsed
def call(log, base, method, path, expected, body=None, headers=None, note=""):
"""HTTP-запрос с проверкой статуса и записью в листинг."""
status, payload, elapsed = http(base, method, path, body, headers)
shown = json.dumps(payload, ensure_ascii=False) if payload is not None else "(пусто)"
if isinstance(payload, dict) and "token" in payload:
shown = json.dumps(dict(payload, token="<скрыт>"), ensure_ascii=False)
log.say("%s %s -> %d (%.0f мс)%s" % (method, path, status, elapsed, (" # " + note) if note else ""))
log.say(" " + shown[:300])
check(status == expected, "%s %s: ожидали %d, получили %d" % (method, path, expected, status))
return payload, elapsed
def wait_ready(base, seconds=90):
"""Дождаться /health/ready = 200."""
started = time.monotonic()
while time.monotonic() - started < seconds:
try:
if http(base, "GET", "/health/ready", timeout=3)[0] == 200:
return time.monotonic() - started
except (urllib.error.URLError, OSError):
pass
time.sleep(0.5)
raise Fail("API не стал готов за %d с" % seconds)
def wait_service_healthy(log, service, seconds=60):
"""Дождаться статуса healthy у контейнера сервиса."""
started = time.monotonic()
while time.monotonic() - started < seconds:
done = subprocess.run(
["docker", "inspect", "-f", "{{.State.Health.Status}}", "messenger-" + service],
capture_output=True, text=True,
)
if done.stdout.strip() == "healthy":
log.say("%s healthy через %.1f с" % (service, time.monotonic() - started))
return
time.sleep(0.5)
raise Fail(service + " не стал healthy")
def basic(username, password):
"""Заголовок Basic."""
return {"Authorization": "Basic " + base64.b64encode((username + ":" + password).encode()).decode()}
def bearer(token):
"""Заголовок Bearer."""
return {"Authorization": "Bearer " + token}
def new_user(log, base, name):
"""Зарегистрировать пользователя и войти."""
username = "%s_%s" % (name, uuid.uuid4().hex[:8])
password = "Demo-" + uuid.uuid4().hex
user, _ = call(log, base, "POST", "/api/v1/users", 201,
{"username": username, "display_name": name, "password": password},
note="регистрация")
session, _ = call(log, base, "POST", "/api/v1/auth/sessions", 201,
headers=basic(username, password), note="вход (Basic)")
return user, session["token"]
def key_of(token):
"""Ключ Redis для токена."""
return "session:" + hashlib.sha256(token.encode()).hexdigest()
def sessions_pkey_scans(log):
"""Число чтений индекса sessions_pkey."""
out = psql(log, "SELECT idx_scan FROM pg_stat_user_indexes WHERE indexrelname = 'sessions_pkey'")
return int(out.strip().splitlines()[-1])
def scenario(log, base):
"""Выполнить сценарий проверки."""
log.title("0. Контейнеры")
check(http(base, "GET", "/health/ready")[0] == 200,
"API не готов: docker compose --env-file .env up -d --build")
run(log, COMPOSE + ["ps"])
log.title("1. Redis: версия и настройки (кэш, persistence выключена намеренно)")
run(log, COMPOSE + ["exec", "-T", "redis", "redis-server", "--version"])
redis_cli(log, "CONFIG", "GET", "save")
redis_cli(log, "CONFIG", "GET", "appendonly")
redis_cli(log, "CONFIG", "GET", "maxmemory-policy")
log.title("2. Роль кэша: проверка Bearer-токена без запроса к PostgreSQL")
alice, alice_token = new_user(log, base, "alice")
bob, bob_token = new_user(log, base, "bob")
redis_cli(log, "CONFIG", "RESETSTAT")
time.sleep(1)
scans_before = sessions_pkey_scans(log)
timings = []
for _ in range(50):
status, _, elapsed = http(base, "GET", "/api/v1/users/me", headers=bearer(alice_token))
check(status == 200, "GET /users/me не 200")
timings.append(elapsed)
log.say("50 x GET /api/v1/users/me -> 200; первый %.1f мс, медиана остальных %.1f мс"
% (timings[0], sorted(timings[1:])[len(timings) // 2]))
time.sleep(1)
scans_after = sessions_pkey_scans(log)
log.say("Чтений индекса sessions_pkey в PostgreSQL за 50 запросов: %d" % (scans_after - scans_before))
check(scans_after - scans_before <= 2, "проверка токена ходит в PostgreSQL мимо кэша")
stats = redis_cli(log, "INFO", "stats")
hits = int(re.search(r"keyspace_hits:(\d+)", stats).group(1))
misses = int(re.search(r"keyspace_misses:(\d+)", stats).group(1))
log.say("Redis: keyspace_hits=%d keyspace_misses=%d" % (hits, misses))
check(hits >= 49 and misses >= 1, "ожидали 1 промах и 49 попаданий")
ttl = int(redis_cli(log, "PTTL", key_of(alice_token)).splitlines()[-1])
log.say("TTL ключа сессии: %d мс (<= CACHE_TTL_SECONDS=60 с и <= остатка сессии)" % ttl)
check(0 < ttl <= 60000, "TTL ключа вне ожидаемого диапазона")
redis_cli(log, "GET", key_of(alice_token))
log.title("3. Logout: DELETE в PostgreSQL, затем отметка отзыва в Redis")
_, carol_token = new_user(log, base, "carol")
call(log, base, "GET", "/api/v1/users/me", 200, headers=bearer(carol_token), note="кладёт сессию в кэш")
call(log, base, "DELETE", "/api/v1/auth/sessions/current", 204, headers=bearer(carol_token))
check(redis_cli(log, "GET", key_of(carol_token)).splitlines()[-1] == "revoked", "нет отметки отзыва")
call(log, base, "GET", "/api/v1/users/me", 401, headers=bearer(carol_token), note="отозванный токен")
log.title("4. Рестарт Redis: кэш пуст, сессии живы (источник истины -- PostgreSQL)")
run(log, COMPOSE + ["restart", "redis"])
wait_service_healthy(log, "redis")
redis_cli(log, "DBSIZE")
call(log, base, "GET", "/api/v1/users/me", 200, headers=bearer(alice_token), note="тот же токен")
check(redis_cli(log, "EXISTS", key_of(alice_token)).splitlines()[-1] == "1", "ключ не создан заново")
call(log, base, "GET", "/api/v1/users/me", 401, headers=bearer(carol_token),
note="отозванный токен после потери кэша всё равно 401 (решает PostgreSQL)")
log.title("5. Redis ОСТАНОВЛЕН: API обходит кэш")
run(log, COMPOSE + ["stop", "redis"])
call(log, base, "GET", "/health/live", 200)
call(log, base, "GET", "/health/ready", 200, note="Redis не критичен для обязательного пути")
_, t1 = call(log, base, "GET", "/api/v1/users/me", 200, headers=bearer(alice_token))
chat, t2 = call(log, base, "POST", "/api/v1/chats", 201,
{"title": "без Redis", "member_ids": [alice["id"], bob["id"]]},
headers=bearer(alice_token))
path = "/api/v1/chats/%s/messages" % chat["id"]
message, t3 = call(log, base, "POST", path, 201, {"text": "сообщение при остановленном Redis"},
headers=bearer(alice_token))
page, t4 = call(log, base, "GET", path, 200, headers=bearer(bob_token))
check(page["items"] == [message], "история не совпала")
call(log, base, "GET", "/api/v1/users/me", 401, note="без токена -- 401, не доверяем")
call(log, base, "GET", "/api/v1/users/me", 401, headers=bearer("Z" * 43), note="чужой токен -- 401")
_, dave_token = new_user(log, base, "dave")
call(log, base, "GET", "/api/v1/users/me", 200, headers=bearer(dave_token))
call(log, base, "DELETE", "/api/v1/auth/sessions/current", 204, headers=bearer(dave_token),
note="logout при недоступном Redis")
call(log, base, "GET", "/api/v1/users/me", 401, headers=bearer(dave_token))
log.say("Максимальная задержка запросов без Redis: %.0f мс" % max(t1, t2, t3, t4))
check(max(t1, t2, t3, t4) < 2000, "обход кэша слишком медленный")
run(log, COMPOSE + ["start", "redis"])
wait_service_healthy(log, "redis")
time.sleep(5.5)
call(log, base, "GET", "/api/v1/users/me", 200, headers=bearer(alice_token), note="кэш снова в работе")
call(log, base, "GET", "/api/v1/users/me", 401, headers=bearer(dave_token))
run(log, COMPOSE + ["logs", "--since", "2m", "api"], must_succeed=False)
log.title("6. PostgreSQL ОСТАНОВЛЕН: ограниченная ошибка, никого не пускаем без проверки")
run(log, COMPOSE + ["stop", "db"])
call(log, base, "GET", "/health/live", 200, note="процесс жив")
call(log, base, "GET", "/health/ready", 503, note="обязательная зависимость недоступна")
call(log, base, "GET", "/api/v1/chats", 503, headers=bearer(alice_token), note="данные только в БД")
call(log, base, "POST", path, 503, {"text": "не будет записано"}, headers=bearer(alice_token))
call(log, base, "POST", "/api/v1/users", 503,
{"username": "nodb_" + uuid.uuid4().hex[:6], "display_name": "x", "password": "long-enough-pass"})
call(log, base, "GET", "/api/v1/users/me", 401, note="аноним -- 401")
call(log, base, "GET", "/api/v1/users/me", 503, headers=bearer("Y" * 43),
note="неизвестный токен: проверить нельзя -> 503, не 200")
run(log, COMPOSE + ["start", "db"])
waited = wait_ready(base)
log.say("API снова готов через %.1f с после start db" % waited)
page, _ = call(log, base, "GET", path, 200, headers=bearer(bob_token), note="тот же токен, те же данные")
check(page["items"] == [message], "сообщение пропало")
run(log, COMPOSE + ["ps"])
log.title("ИТОГ")
log.say("ИТОГ: PASS -- Redis кэширует проверку сессий; рестарт/остановка Redis не теряют сессий "
"и не пропускают анонимов; остановка PostgreSQL даёт 503 без деталей и восстанавливается.")
def main():
"""Выполнить сценарий и сохранить листинг."""
parser = argparse.ArgumentParser(description="Роль Redis и отказы зависимостей")
parser.add_argument("--base-url", default="http://localhost:8080")
parser.add_argument("--output", default="evidence/14_dependencies.txt")
args = parser.parse_args()
log = Log()
commit = subprocess.run(["git", "rev-parse", "--short", "HEAD"], cwd=str(ROOT),
capture_output=True, text=True).stdout.strip() or "нет"
log.say("# Дата (UTC): " + datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S"))
log.say("# Commit: " + commit)
log.say("# Команда: python3 scripts/dependency_demo.py")
code = 0
try:
scenario(log, args.base_url.rstrip("/"))
except Fail as error:
log.say("")
log.say("ИТОГ: FAIL -- " + str(error))
code = 1
finally:
for service in ("db", "redis"):
subprocess.run(COMPOSE + ["start", service], cwd=str(ROOT), capture_output=True)
output = ROOT / args.output
output.parent.mkdir(parents=True, exist_ok=True)
output.write_text("\n".join(log.lines) + "\n", encoding="utf-8")
return code
if __name__ == "__main__":
sys.exit(main())