380 lines
18 KiB
Python
380 lines
18 KiB
Python
#!/usr/bin/env python3
|
||
"""Сценарий проверки сохранности данных при пересоздании контейнеров.
|
||
|
||
python scripts/storage_demo.py [--mode down|stop] [--output файл]
|
||
|
||
Создаёт данные через API, показывает их в PostgreSQL, выключает и снова
|
||
включает контейнеры (тома не удаляются) и проверяет те же данные прежними
|
||
токенами. Пароли и токены в листинг не попадают. Код возврата 0 -- успех.
|
||
"""
|
||
|
||
import argparse
|
||
import base64
|
||
import json
|
||
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"]
|
||
|
||
INTRO = """\
|
||
Приложение -- мессенджер: HTTP API (FastAPI), PostgreSQL и Redis (кэш сессий).
|
||
* Сам API состояния не хранит: пользователи, чаты, участники, сообщения и сессии
|
||
лежат в PostgreSQL (таблицы users, chats, chat_members, messages, sessions).
|
||
* Файлы PostgreSQL лежат не в контейнере, а в именованном томе Docker (pgdata).
|
||
Контейнеры api и db временные, том постоянный.
|
||
* Пароль хранится как scrypt-хеш, у сессии в БД лежит только SHA-256 токена,
|
||
срок сессии считает сама БД -- перезапуск его не продлевает и не сбрасывает.
|
||
* Redis только кэширует проверку токена (без persistence): после перезапуска
|
||
кэш пуст, и сессии читаются из PostgreSQL.
|
||
Ожидание: пока том не удалён (команда down -v здесь НЕ используется), после
|
||
%(what)s
|
||
те же пользователи, чат, сообщение и тот же токен продолжают работать.
|
||
План: (1) создать данные через API, (2) показать их в БД, (3) выключить,
|
||
(4) включить, (5) проверить, что данные и токены прежние.
|
||
"""
|
||
|
||
|
||
class Fail(Exception):
|
||
"""Проверка не прошла."""
|
||
|
||
|
||
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 show(args):
|
||
"""Команда одной строкой для листинга."""
|
||
parts = []
|
||
for arg in args:
|
||
if arg == "" or " " in arg:
|
||
quote = "'" if '"' in arg else '"'
|
||
parts.append(quote + arg + quote)
|
||
else:
|
||
parts.append(arg)
|
||
return " ".join(parts)
|
||
|
||
|
||
def run(log, args, must_succeed=True):
|
||
"""Выполнить команду, записать её и вывод в листинг."""
|
||
log.say("$ " + show(args))
|
||
try:
|
||
done = subprocess.run(args, cwd=str(ROOT), capture_output=True)
|
||
except FileNotFoundError:
|
||
raise Fail("команда не найдена: %s (установлен ли Docker Desktop?)" % args[0])
|
||
output = (done.stdout + done.stderr).decode("utf-8", errors="replace").strip()
|
||
if output:
|
||
log.say(output)
|
||
if must_succeed and done.returncode != 0:
|
||
raise Fail("команда завершилась с кодом %d" % done.returncode)
|
||
return output
|
||
|
||
|
||
def read_env():
|
||
"""Прочитать .env в словарь."""
|
||
values = {}
|
||
path = ROOT / ".env"
|
||
if path.exists():
|
||
for line in path.read_text(encoding="utf-8").splitlines():
|
||
line = line.strip()
|
||
if line and not line.startswith("#") and "=" in line:
|
||
key, _, value = line.partition("=")
|
||
values[key.strip()] = value.strip()
|
||
return values
|
||
|
||
|
||
def sql(log, query):
|
||
"""Выполнить SELECT в контейнере db."""
|
||
env = read_env()
|
||
user = env.get("POSTGRES_USER", "messenger")
|
||
database = env.get("POSTGRES_DB", "messenger")
|
||
return run(log, COMPOSE + ["exec", "-T", "db", "psql", "-U", user, "-d", database, "-c", query])
|
||
|
||
|
||
def http(base, method, path, body=None, headers=None, timeout=10):
|
||
"""HTTP-запрос к API: (статус, JSON или None)."""
|
||
data = json.dumps(body, ensure_ascii=False).encode("utf-8") if body is not None else None
|
||
request_headers = {"Accept": "application/json"}
|
||
if body is not None:
|
||
request_headers["Content-Type"] = "application/json"
|
||
request_headers.update(headers or {})
|
||
request = urllib.request.Request(base + path, data=data, method=method, headers=request_headers)
|
||
try:
|
||
response = urllib.request.urlopen(request, timeout=timeout)
|
||
status, payload = response.status, response.read()
|
||
except urllib.error.HTTPError as error:
|
||
status, payload = error.code, error.read()
|
||
return status, (json.loads(payload) if payload else None)
|
||
|
||
|
||
def masked(value):
|
||
"""Копия ответа со скрытым токеном."""
|
||
if isinstance(value, dict):
|
||
return {
|
||
key: ("<скрыт, %d симв.>" % len(item) if key == "token" and isinstance(item, str) else masked(item))
|
||
for key, item in value.items()
|
||
}
|
||
if isinstance(value, list):
|
||
return [masked(item) for item in value]
|
||
return value
|
||
|
||
|
||
def call(log, base, method, path, expected, body=None, headers=None, note=""):
|
||
"""HTTP-запрос с проверкой статуса и записью в листинг."""
|
||
status, payload = http(base, method, path, body, headers)
|
||
shown = dict(body) if isinstance(body, dict) else body
|
||
if isinstance(shown, dict) and "password" in shown:
|
||
shown["password"] = "***"
|
||
log.say("$ %s %s %s" % (method, path, (" # " + note) if note else ""))
|
||
if shown is not None:
|
||
log.say(" тело запроса: " + json.dumps(shown, ensure_ascii=False))
|
||
log.say(" ответ: %d %s" % (status, json.dumps(masked(payload), ensure_ascii=False)))
|
||
if status != expected:
|
||
raise Fail("%s %s: ожидали %d, получили %d" % (method, path, expected, status))
|
||
return payload
|
||
|
||
|
||
def wait_ready(base, seconds):
|
||
"""Дождаться /health/ready = 200 и вернуть время ожидания."""
|
||
started = time.monotonic()
|
||
while time.monotonic() - started < seconds:
|
||
try:
|
||
status, _ = http(base, "GET", "/health/ready", timeout=3)
|
||
if status == 200:
|
||
return time.monotonic() - started
|
||
except (urllib.error.URLError, OSError, ValueError):
|
||
pass
|
||
time.sleep(1)
|
||
raise Fail("API не стал готовым за %d с" % seconds)
|
||
|
||
|
||
def is_down(base):
|
||
"""True, если API не отвечает."""
|
||
try:
|
||
http(base, "GET", "/health/live", timeout=3)
|
||
return False
|
||
except (urllib.error.URLError, OSError, ValueError):
|
||
return True
|
||
|
||
|
||
def volume_name(log):
|
||
"""Имя тома pgdata."""
|
||
out = run(log, ["docker", "volume", "ls", "--filter", "name=pgdata", "--format", "{{.Name}}"])
|
||
names = [line.strip() for line in out.splitlines() if line.strip()]
|
||
if not names:
|
||
raise Fail("том pgdata не найден: приложение не запускали? (docker compose --env-file .env up -d --build)")
|
||
return names[0]
|
||
|
||
|
||
def volume_info(log, name):
|
||
"""Имя и дата создания тома."""
|
||
return run(log, ["docker", "volume", "inspect", name, "--format", "{{.Name}} создан: {{.CreatedAt}}"])
|
||
|
||
|
||
def basic(username, password):
|
||
"""Заголовок Basic."""
|
||
raw = (username + ":" + password).encode("utf-8")
|
||
return {"Authorization": "Basic " + base64.b64encode(raw).decode()}
|
||
|
||
|
||
def bearer(token):
|
||
"""Заголовок Bearer."""
|
||
return {"Authorization": "Bearer " + token}
|
||
|
||
|
||
def scenario(log, args):
|
||
"""Выполнить сценарий проверки."""
|
||
base = args.base_url.rstrip("/")
|
||
down_mode = args.mode == "down"
|
||
what = (
|
||
"удаления и повторного создания контейнеров (docker compose down, затем up -d)"
|
||
if down_mode
|
||
else "остановки и повторного запуска контейнеров (docker compose stop, затем start)"
|
||
)
|
||
|
||
log.title("1. Как устроено приложение")
|
||
log.say(INTRO % {"what": what})
|
||
|
||
log.title("2. Состояние до начала")
|
||
try:
|
||
status, _ = http(base, "GET", "/health/ready")
|
||
except (urllib.error.URLError, OSError, ValueError):
|
||
status = 0
|
||
if status != 200:
|
||
raise Fail("API не отвечает на %s. Запустите приложение: docker compose --env-file .env up -d --build" % base)
|
||
run(log, COMPOSE + ["ps"])
|
||
volume = volume_name(log)
|
||
volume_before = volume_info(log, volume)
|
||
|
||
log.title("3. Запись данных через API (создаём пользователей, чат, сообщение)")
|
||
suffix = uuid.uuid4().hex[:8]
|
||
alice_name, bob_name = "demo_a_" + suffix, "demo_b_" + suffix
|
||
alice_pass, bob_pass = "Storage-" + uuid.uuid4().hex, "Storage-" + uuid.uuid4().hex
|
||
alice = call(log, base, "POST", "/api/v1/users", 201,
|
||
{"username": alice_name, "display_name": "Алиса", "password": alice_pass},
|
||
note="регистрация Алисы")
|
||
bob = call(log, base, "POST", "/api/v1/users", 201,
|
||
{"username": bob_name, "display_name": "Боб", "password": bob_pass},
|
||
note="регистрация Боба")
|
||
alice_token = call(log, base, "POST", "/api/v1/auth/sessions", 201,
|
||
headers=basic(alice_name, alice_pass), note="вход Алисы (Basic)")["token"]
|
||
bob_token = call(log, base, "POST", "/api/v1/auth/sessions", 201,
|
||
headers=basic(bob_name, bob_pass), note="вход Боба (Basic)")["token"]
|
||
chat = call(log, base, "POST", "/api/v1/chats", 201,
|
||
{"title": "Проверка сохранности " + suffix, "member_ids": [alice["id"], bob["id"]]},
|
||
headers=bearer(alice_token), note="чат Алисы и Боба (Bearer)")
|
||
message = call(log, base, "POST", "/api/v1/chats/%s/messages" % chat["id"], 201,
|
||
{"text": "Это сообщение должно пережить перезапуск " + suffix},
|
||
headers=bearer(alice_token), note="сообщение Алисы")
|
||
|
||
log.title("4. Что лежит в PostgreSQL ДО выключения (SELECT внутри контейнера db)")
|
||
queries = {
|
||
"пользователи (пароль -- только префикс хеша)":
|
||
"SELECT username, display_name, left(password_hash, 7) AS password_prefix, created_at "
|
||
"FROM users WHERE username IN ('%s', '%s') ORDER BY username" % (alice_name, bob_name),
|
||
"чат и число участников":
|
||
"SELECT c.title, count(m.user_id) AS members FROM chats c "
|
||
"JOIN chat_members m ON m.chat_id = c.id WHERE c.id = '%s' GROUP BY c.title" % chat["id"],
|
||
"сообщение":
|
||
"SELECT id, sender_id, text, created_at FROM messages WHERE chat_id = '%s'" % chat["id"],
|
||
"действующие сессии (токены не показываем)":
|
||
"SELECT count(*) AS live_sessions FROM sessions s JOIN users u ON u.id = s.user_id "
|
||
"WHERE u.username IN ('%s', '%s') AND s.expires_at > now()" % (alice_name, bob_name),
|
||
}
|
||
before = {}
|
||
for title, query in queries.items():
|
||
log.say("-- " + title)
|
||
before[title] = sql(log, query)
|
||
|
||
log.title("5. Выключаем приложение" + (" (контейнеры УДАЛЯЮТСЯ, том остаётся)" if down_mode else ""))
|
||
if down_mode:
|
||
run(log, COMPOSE + ["down"])
|
||
run(log, COMPOSE + ["ps", "-a"], must_succeed=False)
|
||
else:
|
||
run(log, COMPOSE + ["stop", "api", "redis", "db"])
|
||
run(log, COMPOSE + ["ps", "-a"])
|
||
if not is_down(base):
|
||
raise Fail("после выключения API всё ещё отвечает")
|
||
log.say("API на %s не отвечает -- приложение выключено (так и должно быть)." % base)
|
||
log.say("-- том с данными на месте:")
|
||
run(log, ["docker", "volume", "ls", "--filter", "name=pgdata"])
|
||
|
||
log.title("6. Включаем снова")
|
||
if down_mode:
|
||
run(log, COMPOSE + ["up", "-d"])
|
||
else:
|
||
run(log, COMPOSE + ["start", "db", "redis", "api"])
|
||
waited = wait_ready(base, args.wait)
|
||
log.say("API снова готов (/health/ready = 200) через %.0f с." % waited)
|
||
run(log, COMPOSE + ["ps"])
|
||
|
||
log.title("7. Проверка ПОСЛЕ перезапуска: те же данные и те же токены")
|
||
me = call(log, base, "GET", "/api/v1/users/me", 200, headers=bearer(alice_token),
|
||
note="старый токен Алисы, повторный вход НЕ делали")
|
||
if me != alice:
|
||
raise Fail("пользователь после перезапуска отличается: %r != %r" % (me, alice))
|
||
log.say(" OK: тот же пользователь (id, username, created_at совпали).")
|
||
page = call(log, base, "GET", "/api/v1/chats/%s/messages" % chat["id"], 200,
|
||
headers=bearer(bob_token), note="старый токен Боба читает историю чата")
|
||
if page["items"] != [message]:
|
||
raise Fail("история чата отличается от записанной до перезапуска")
|
||
log.say(" OK: то же сообщение (id, text, created_at совпали).")
|
||
listed = call(log, base, "GET", "/api/v1/chats?limit=100", 200, headers=bearer(alice_token),
|
||
note="список чатов Алисы")
|
||
if not any(item["id"] == chat["id"] for item in listed["items"]):
|
||
raise Fail("чат пропал из списка")
|
||
log.say(" OK: чат в списке.")
|
||
|
||
log.say("")
|
||
log.say("Те же SELECT после перезапуска (сравниваем с выводом из пункта 4):")
|
||
for title, query in queries.items():
|
||
log.say("-- " + title)
|
||
after = sql(log, query)
|
||
if after != before[title]:
|
||
raise Fail("результат SELECT изменился: " + title)
|
||
log.say(" OK: вывод идентичен выводу до перезапуска.")
|
||
|
||
log.say("")
|
||
log.say("-- том тот же (дата создания не изменилась):")
|
||
volume_after = volume_info(log, volume)
|
||
if volume_after != volume_before:
|
||
raise Fail("том изменился: был «%s», стал «%s»" % (volume_before, volume_after))
|
||
log.say(" OK: том не пересоздавался.")
|
||
|
||
log.title("ИТОГ")
|
||
log.say("ИТОГ: PASS -- пользователи, чат, сообщение и действующие сессии сохранились после "
|
||
+ what + ".")
|
||
|
||
|
||
def commit_hash():
|
||
"""Короткий hash текущего коммита."""
|
||
try:
|
||
done = subprocess.run(["git", "rev-parse", "--short", "HEAD"], cwd=str(ROOT),
|
||
capture_output=True, text=True, timeout=5)
|
||
return done.stdout.strip() if done.returncode == 0 and done.stdout.strip() else "нет"
|
||
except Exception:
|
||
return "нет"
|
||
|
||
|
||
def main():
|
||
"""Разобрать аргументы, выполнить сценарий и сохранить листинг."""
|
||
parser = argparse.ArgumentParser(description="Доказательство сохранности данных после перезапуска")
|
||
parser.add_argument("--base-url", default="http://localhost:8080")
|
||
parser.add_argument("--output", default="evidence/13_storage.txt")
|
||
parser.add_argument("--mode", choices=["down", "stop"], default="down",
|
||
help="down: удалить и создать контейнеры (по умолчанию); stop: остановить и запустить")
|
||
parser.add_argument("--wait", type=int, default=90, help="сколько секунд ждать готовности API")
|
||
args = parser.parse_args()
|
||
|
||
if hasattr(sys.stdout, "reconfigure"):
|
||
sys.stdout.reconfigure(encoding="utf-8", errors="replace")
|
||
|
||
log = Log()
|
||
code = 0
|
||
try:
|
||
scenario(log, args)
|
||
except Fail as error:
|
||
log.say("")
|
||
log.say("ИТОГ: FAIL -- " + str(error))
|
||
code = 1
|
||
|
||
header = [
|
||
"# Дата (UTC): " + datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S"),
|
||
"# Commit: " + commit_hash(),
|
||
"# Команда: python scripts/storage_demo.py --mode " + args.mode,
|
||
"",
|
||
]
|
||
target = Path(args.output)
|
||
if not target.is_absolute():
|
||
target = ROOT / target
|
||
target.parent.mkdir(parents=True, exist_ok=True)
|
||
target.write_text("\n".join(header + log.lines) + "\n", encoding="utf-8")
|
||
print("\n[сохранено в %s]" % target)
|
||
return code
|
||
|
||
|
||
if __name__ == "__main__":
|
||
sys.exit(main())
|