solution
This commit is contained in:
@@ -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())
|
||||
@@ -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
|
||||
@@ -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())
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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())
|
||||
@@ -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())
|
||||
Reference in New Issue
Block a user