This commit is contained in:
k00kzaAntonovaIra
2026-10-23 14:09:32 +03:00
parent 65003b6119
commit 840907cf2b
79 changed files with 6656 additions and 20 deletions
+90
View File
@@ -0,0 +1,90 @@
#!/usr/bin/env python3
"""Проверка срока жизни сессии, выхода и неверного пароля на запущенном API.
python scripts/check_expiry.py --base-url http://localhost:8081 --ttl 3
API должен работать с SESSION_TTL_SECONDS, равным --ttl.
"""
import argparse
import base64
import json
import sys
import time
import urllib.error
import urllib.request
import uuid
from datetime import datetime, timezone
def http(base, method, path, body=None, headers=None):
"""HTTP-запрос: (статус, заголовки, тело)."""
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")
try:
with urllib.request.urlopen(request, timeout=10) as reply:
return reply.status, reply.headers, reply.read()
except urllib.error.HTTPError as error:
return error.code, error.headers, error.read()
def step(text, ok):
"""Напечатать результат шага; при неудаче завершить с кодом 1."""
print(("OK " if ok else "FAIL ") + text, flush=True)
if not ok:
sys.exit(1)
def main():
"""Выполнить проверку."""
parser = argparse.ArgumentParser()
parser.add_argument("--base-url", default="http://localhost:8081")
parser.add_argument("--ttl", type=float, default=3)
args = parser.parse_args()
base = args.base_url.rstrip("/")
username, password = "ttl_" + uuid.uuid4().hex[:8], "Expiry-" + uuid.uuid4().hex
basic = {"Authorization": "Basic " + base64.b64encode((username + ":" + password).encode()).decode()}
status, _, _ = http(base, "POST", "/api/v1/users",
{"username": username, "display_name": "TTL", "password": password})
step("регистрация -> %d" % status, status == 201)
status, _, raw = http(base, "POST", "/api/v1/auth/sessions", headers=basic)
session = json.loads(raw)
expires = datetime.fromisoformat(session["expires_at"].replace("Z", "+00:00"))
left = (expires - datetime.now(timezone.utc)).total_seconds()
step("вход -> %d, expires_at через %.1f с (TTL=%g)" % (status, left, args.ttl),
status == 201 and 0 < left <= args.ttl + 1)
bearer = {"Authorization": "Bearer " + session["token"]}
for n in range(3):
status, _, _ = http(base, "GET", "/api/v1/users/me", headers=bearer)
step("GET /users/me #%d до истечения -> %d" % (n + 1, status), status == 200)
time.sleep(args.ttl + 1)
status, headers, raw = http(base, "GET", "/api/v1/users/me", headers=bearer)
step("GET /users/me после TTL+1 с -> %d, WWW-Authenticate: %s, code=%s"
% (status, headers.get("WWW-Authenticate"), json.loads(raw)["error"]["code"]),
status == 401 and headers.get("WWW-Authenticate") == 'Bearer realm="messenger"')
status, _, raw = http(base, "POST", "/api/v1/auth/sessions", headers=basic)
bearer = {"Authorization": "Bearer " + json.loads(raw)["token"]}
step("новый вход -> %d" % status, status == 201)
status, _, _ = http(base, "DELETE", "/api/v1/auth/sessions/current", headers=bearer)
step("logout -> %d" % status, status == 204)
status, _, _ = http(base, "GET", "/api/v1/users/me", headers=bearer)
step("GET /users/me после logout -> %d" % status, status == 401)
status, _, _ = http(base, "DELETE", "/api/v1/auth/sessions/current", headers=bearer)
step("повторный logout -> %d" % status, status == 401)
wrong = {"Authorization": "Basic " + base64.b64encode((username + ":wrong-password-123").encode()).decode()}
status, headers, _ = http(base, "POST", "/api/v1/auth/sessions", headers=wrong)
step("вход с неверным паролем -> %d, WWW-Authenticate: %s" % (status, headers.get("WWW-Authenticate")),
status == 401 and headers.get("WWW-Authenticate", "").startswith("Basic"))
print("PASS: expiry (TTL=%g с), logout и неверный пароль на запущенном API" % args.ttl)
return 0
if __name__ == "__main__":
sys.exit(main())
+63
View File
@@ -0,0 +1,63 @@
#!/bin/sh
set -u
cd "$(dirname "$0")/.."
R="python3 scripts/run_and_save.py"
DC="docker compose --env-file .env"
PGUSER=$(sed -n 's/^POSTGRES_USER=//p' .env)
PGDB=$(sed -n 's/^POSTGRES_DB=//p' .env)
PSQL="$DC exec -T db psql -U ${PGUSER:-messenger} -d ${PGDB:-messenger}"
VOLUME=mtusi-messenger_pgdata
VOLFMT='{{.Name}} created={{.CreatedAt}}'
STEPS=${*:-"01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16"}
wait_ready() {
for _ in $(seq 1 90); do
curl -sf http://localhost:8080/health/ready >/dev/null && return 0
sleep 1
done
echo "API не готов" >&2
return 1
}
for step in $STEPS; do
echo "=== $step"
case $step in
01) $R evidence/01_check_contract.txt -- python3 scripts/check_contract.py ;;
02) $R evidence/02_smoke.txt -- make test ;;
03) $R evidence/03_ps_before.txt -- $DC ps
$R evidence/03_volume_before.txt -- docker volume inspect $VOLUME --format "$VOLFMT" ;;
04) $R evidence/04_persistence.txt -- make test-persistence ACTION_SCRIPT=scripts/restart.sh ;;
05) $R evidence/05_ps_after.txt -- $DC ps
$R evidence/05_volume_after.txt -- docker volume inspect $VOLUME --format "$VOLFMT" ;;
06) $R evidence/06_schema.txt -- $PSQL -c '\d users' -c '\d chats' -c '\d chat_members' \
-c '\d messages' -c '\d sessions' ;;
07) $R evidence/07_migrations.txt -- $DC exec -T api python -m app.migrate
$R evidence/07_migrations_table.txt -- $PSQL -c 'SELECT * FROM schema_migrations' ;;
08) $R evidence/08_hashes.txt -- $PSQL \
-c "SELECT username, left(password_hash, 7) AS password_prefix, length(password_hash) AS len FROM users WHERE password_hash LIKE 'scrypt\$%' LIMIT 3" \
-c 'SELECT length(token_hash) AS token_hash_len, expires_at FROM sessions LIMIT 3' ;;
09) $R evidence/09_auth_tests.txt -- $DC --profile test run --rm tests python -m pytest -v --no-header -p no:cacheprovider \
student-tests/test_auth.py student-tests/test_session_expiry.py ;;
10) $R evidence/10_database_tests.txt -- $DC --profile test run --rm tests python -m pytest -v --no-header -p no:cacheprovider \
student-tests/test_database.py student-tests/test_db_failure.py student-tests/test_transactions.py \
student-tests/test_duplicate_username.py ;;
11) $R evidence/11_all_tests.txt -- $DC --profile test run --rm tests ;;
12) $R evidence/12_git_secrets.txt -- git check-ignore -v .env
$R evidence/12_git_files.txt -- git ls-files --cached --others --exclude-standard
$R evidence/12_compose_no_secrets.txt -- grep -n -i 'password\|secret' compose.yaml ;;
13) python3 scripts/storage_demo.py --output evidence/13_storage.txt
wait_ready ;;
14) python3 scripts/dependency_demo.py --output evidence/14_dependencies.txt
wait_ready ;;
15) $R evidence/15_explain.txt -- $DC exec -T api python -m app.explain
$R evidence/15_explain_tests.txt -- $DC --profile test run --rm tests python -m pytest -v --no-header -p no:cacheprovider \
student-tests/test_explain.py ;;
16) $DC --profile expiry up -d api-ttl
for _ in $(seq 1 60); do curl -sf http://localhost:8081/health/ready >/dev/null && break; sleep 1; done
$R evidence/16_expiry_live.txt -- python3 scripts/check_expiry.py --base-url http://localhost:8081 --ttl 3
$DC --profile expiry stop api-ttl
$DC --profile expiry rm -f api-ttl ;;
*) echo "неизвестный пункт $step" >&2 ;;
esac
done
+324
View File
@@ -0,0 +1,324 @@
#!/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())
+5
View File
@@ -0,0 +1,5 @@
@echo off
cd /d "%~dp0.."
docker compose --env-file .env stop api redis db || exit /b 1
docker compose --env-file .env start db redis api || exit /b 1
exit /b 0
+5
View File
@@ -0,0 +1,5 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
docker compose --env-file .env stop api redis db
docker compose --env-file .env start db redis api
+64
View File
@@ -0,0 +1,64 @@
#!/usr/bin/env python3
"""Выполнить команду и сохранить её вывод в файл вместе с датой, коммитом и кодом возврата.
python scripts/run_and_save.py evidence/01.txt -- python scripts/check_contract.py
"""
import os
import subprocess
import sys
import time
from datetime import datetime, timezone
from pathlib import Path
def git_commit(root: Path) -> str:
"""Короткий hash текущего коммита или пояснение, почему его нет."""
try:
out = subprocess.run(["git", "rev-parse", "--short", "HEAD"], cwd=str(root), capture_output=True,
text=True, timeout=5)
return out.stdout.strip() if out.returncode == 0 and out.stdout.strip() else "нет (git не используется)"
except Exception:
return "нет (git не найден)"
def main() -> int:
"""Выполнить команду после --, записать отчёт и вернуть её код возврата."""
argv = sys.argv[1:]
if len(argv) < 3 or argv[1] != "--":
print(__doc__)
return 2
target = Path(argv[0])
command = argv[2:]
root = Path(__file__).resolve().parents[1]
env = dict(os.environ, PYTHONIOENCODING="utf-8", PYTHONUTF8="1")
started = time.monotonic()
try:
done = subprocess.run(command, capture_output=True, env=env, cwd=str(root))
output = (done.stdout + done.stderr).decode("utf-8", errors="replace")
code = done.returncode
except FileNotFoundError:
output = "Команда не найдена: %s\n" % command[0]
code = 127
elapsed = time.monotonic() - started
text = "\n".join([
"# Дата (UTC): " + datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S"),
"# Commit: " + git_commit(root),
"# Команда: " + " ".join(command),
"# ---------------------------------------- вывод ----------------------------------------",
output.rstrip(),
"# ---------------------------------------------------------------------------------------",
"# Код возврата: %d" % code,
"# Время выполнения: %.2f с" % elapsed,
"",
])
target.parent.mkdir(parents=True, exist_ok=True)
target.write_text(text, encoding="utf-8")
sys.stdout.buffer.write(text.encode("utf-8", errors="replace"))
print("\n[сохранено в %s]" % target)
return code
if __name__ == "__main__":
sys.exit(main())
+379
View File
@@ -0,0 +1,379 @@
#!/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())