325 lines
16 KiB
Python
325 lines
16 KiB
Python
#!/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())
|