diff --git a/Makefile b/Makefile index 114060ee..25abafc1 100644 --- a/Makefile +++ b/Makefile @@ -4,7 +4,7 @@ CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence test-unit up down +.PHONY: help check validate test load test-persistence test-unit test-expiry test-deps seed-history up down help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" @@ -28,6 +28,15 @@ test-persistence: test-unit: $(PYTHON) tests/test_unit.py --base-url $(BASE_URL) +test-expiry: + $(PYTHON) tests/test_expiry.py --base-url $(BASE_URL) + +test-deps: + $(PYTHON) tests/test_dependency_failure.py --base-url $(BASE_URL) + +seed-history: + $(PYTHON) scripts/seed_history.py --base-url $(BASE_URL) --count 10000 --output evidence/explain.txt + up: docker compose --env-file .env up -d --build diff --git a/REPORT.md b/REPORT.md index 86697b38..de27cc62 100644 --- a/REPORT.md +++ b/REPORT.md @@ -16,8 +16,14 @@ docker compose --env-file .env up -d --build # дождаться /health/ready (healthcheck в compose) make test BASE_URL=http://localhost:8080 make test-unit BASE_URL=http://localhost:8080 -chmod +x scripts/restart.sh +chmod +x scripts/restart.sh scripts/stop-redis.sh scripts/start-redis.sh scripts/stop-postgres.sh scripts/start-postgres.sh make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://localhost:8080 +make test-deps BASE_URL=http://localhost:8080 +make seed-history BASE_URL=http://localhost:8080 +# Expiry — отдельный стенд с коротким TTL: +SESSION_TTL_SECONDS=2 docker compose --env-file .env up -d api +make test-expiry BASE_URL=http://localhost:8080 +docker compose --env-file .env up -d api # вернуть TTL=3600 ``` Версии образов закреплены: `postgres:16.4-alpine`, `redis:7.4-alpine`, `python:3.12-slim`. Миграции применяются автоматически при старте API (`app/db.py::apply_migrations`), идемпотентно через таблицу `schema_migrations`. @@ -47,12 +53,13 @@ make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://localhost | Ограниченный пул и таймауты | `app/db.py`, `app/main.py` | `DB_POOL_MAX`, `DB_CONNECT_TIMEOUT`, `REDIS_SOCKET_TIMEOUT` | исходники | | Гонка регистрации username | `tests/test_unit.py::test_duplicate_username` | 201 + 409 | `make test-unit` | | Rollback составной операции | `app/store.py::create_chat` — `conn.transaction()` | при ошибке вставки участника чат не создаётся | исходники | -| Индекс истории + EXPLAIN | `psql "$DATABASE_URL" -f scripts/explain_history.sql` | Index Scan по `messages_chat_created_idx` | вывод EXPLAIN | -| Expiry при коротком TTL | `SESSION_TTL_SECONDS=2 docker compose up -d api` + `make test-unit` | 401 после истечения | вывод консоли | +| Индекс истории + EXPLAIN | `make seed-history` (10 000 сообщений) | Index Scan по `messages_chat_created_idx` | `evidence/explain.txt` | +| Expiry при коротком TTL | `SESSION_TTL_SECONDS=2 docker compose up -d api` + `make test-expiry` | 401 после истечения, повторный вход работает | `tests/test_expiry.py` | | Logout | `tests/test_unit.py::test_logout_revokes_session` | 204, затем 401 | `make test-unit` | | Неверный пароль | `tests/test_unit.py::test_wrong_password_returns_401` | 401 | `make test-unit` | -| Недоступность Redis | `docker compose stop redis` + `make test` | smoke проходит (fallback на БД) | вывод консоли | -| Недоступность БД | `docker compose stop postgres` + `curl /health/ready` | 503 `unavailable` | вывод консоли | +| Недоступность Redis | `make test-deps` (тест `test_redis_down_falls_back_to_db`) | валидный токен 200, аноним 401, `/health/ready` 200 | `tests/test_dependency_failure.py` | +| Недоступность БД | `make test-deps` (тест `test_postgres_down_returns_503`) | `/health/ready` 503 `unavailable`, бизнес-запрос 500/503 без утечек | `tests/test_dependency_failure.py` | +| EXPLAIN на ≥10 000 сообщений | `make seed-history` | Index Scan по `messages_chat_created_idx` | `evidence/explain.txt` | ## Эксперименты и отказы @@ -65,7 +72,8 @@ Hardware: локальная машина разработчика (Windows 11, | `docker compose restart api postgres redis` (volumes сохранены) | данные и сессии сохранены | PASS persistence | ~5–10 с, потерь нет | | `docker compose stop redis` | API работает, сессии из БД | smoke PASS | восстановление после `start redis` | | `docker compose stop postgres` | `/health/ready` → 503 | 503 `unavailable` | после `start postgres` — 200 | -| `SESSION_TTL_SECONDS=2` | сессия истекает | 401 после истечения | — | +| `SESSION_TTL_SECONDS=2` | сессия истекает | 401 после истечения, повторный вход работает | — | +| `make seed-history` (10 000 сообщений) | Index Scan, без Seq Scan | Index Scan по `messages_chat_created_idx` | — | ## Ограничения и следующие шаги diff --git a/app/__init__.py b/app/__init__.py index 5ee79cfb..1aab4e3b 100644 --- a/app/__init__.py +++ b/app/__init__.py @@ -1 +1 @@ -"""MTUSI Messenger — лабораторная 2.""" +"""MTUSI Messenger — лабораторная 2: PostgreSQL, сессии и Redis-кэш.""" diff --git a/app/handlers.py b/app/handlers.py index 542b4a4d..29f76eea 100644 --- a/app/handlers.py +++ b/app/handlers.py @@ -23,6 +23,8 @@ from .validation import ( router = APIRouter() +logger = logging.getLogger("messenger.handlers") + BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"' BEARER_CHALLENGE = 'Bearer realm="messenger"' @@ -81,8 +83,7 @@ def health_ready(request: Request) -> JSONResponse: cur.execute("SELECT 1") cur.fetchone() except Exception as exc: # noqa: BLE001 - logger_ready = logging.getLogger("messenger.ready") - logger_ready.warning("readiness failed: %s", type(exc).__name__) + logger.warning("readiness failed: %s", type(exc).__name__) raise ApiError(503, "unavailable", "Зависимость недоступна") return JSONResponse({"status": "ok"}) diff --git a/compose.yaml b/compose.yaml index 601ceb4e..53bccc36 100644 --- a/compose.yaml +++ b/compose.yaml @@ -29,7 +29,7 @@ services: environment: APP_HOST: 0.0.0.0 APP_PORT: "8080" - SESSION_TTL_SECONDS: "3600" + SESSION_TTL_SECONDS: "${SESSION_TTL_SECONDS:-3600}" DATABASE_URL: postgresql://messenger:messenger@postgres:5432/messenger CACHE_URL: redis://redis:6379/0 ports: diff --git a/scripts/seed_history.py b/scripts/seed_history.py new file mode 100644 index 00000000..1a38d234 --- /dev/null +++ b/scripts/seed_history.py @@ -0,0 +1,100 @@ +#!/usr/bin/env python3 +"""Создаёт >=10 000 сообщений и снимает EXPLAIN (ANALYZE, BUFFERS). + +Запуск: python3 scripts/seed_history.py --count 10000 --output evidence/explain.txt +Требует запущенный API (BASE_URL) и доступ к psql через docker compose exec. +""" +import argparse +import base64 +import json +import os +import subprocess +import sys +import time +import urllib.error +import urllib.request +import uuid +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] + + +def request(base, method, path, body=None, token=None, basic=None): + headers = {"Accept": "application/json"} + if token: + headers["Authorization"] = "Bearer " + token + if basic: + headers["Authorization"] = "Basic " + basic + data = None + if body is not None: + data = json.dumps(body, ensure_ascii=False).encode("utf-8") + headers["Content-Type"] = "application/json" + req = urllib.request.Request(base + path, data=data, headers=headers, method=method) + try: + with urllib.request.urlopen(req, timeout=30) as resp: + payload = resp.read() + return resp.status, json.loads(payload) if payload else None + except urllib.error.HTTPError as err: + payload = err.read() + return err.code, json.loads(payload) if payload else None + + +def main(): + p = argparse.ArgumentParser(description="Seed history and run EXPLAIN") + p.add_argument("--base-url", default=os.environ.get("BASE_URL", "http://localhost:8080")) + p.add_argument("--count", type=int, default=10000) + p.add_argument("--output", default="evidence/explain.txt") + p.add_argument("--psql", default="docker compose exec -T postgres psql -U messenger -d messenger") + args = p.parse_args() + base = args.base_url.rstrip("/") + + username = "u_seed_" + uuid.uuid4().hex[:10] + password = "T3st-" + uuid.uuid4().hex + status, alice = request(base, "POST", "/api/v1/users", + {"username": username, "display_name": "Seed", "password": password}) + assert status == 201, (status, alice) + basic = base64.b64encode((username + ":" + password).encode()).decode() + status, session = request(base, "POST", "/api/v1/auth/sessions", basic=basic) + assert status == 201, (status, session) + token = session["token"] + + status, chat = request(base, "POST", "/api/v1/chats", + {"title": "Seed history", "member_ids": [alice["id"]]}, token=token) + assert status == 201, (status, chat) + chat_id = chat["id"] + + started = time.monotonic() + for i in range(args.count): + status, _ = request(base, "POST", "/api/v1/chats/" + chat_id + "/messages", + {"text": "seed-%d" % i}, token=token) + if status != 201: + raise SystemExit("failed to insert message %d: %s" % (i, status)) + if (i + 1) % 1000 == 0: + print("inserted %d/%d" % (i + 1, args.count), file=sys.stderr) + elapsed = time.monotonic() - started + print("inserted %d messages in %.1fs" % (args.count, elapsed), file=sys.stderr) + + sql = ( + "EXPLAIN (ANALYZE, BUFFERS) " + "SELECT id, chat_id, sender_id, text, created_at FROM messages " + "WHERE chat_id = '%s' " + "AND (created_at, id) > ('1970-01-01T00:00:00Z', '00000000-0000-0000-0000-000000000000') " + "ORDER BY created_at, id LIMIT 51;" % chat_id + ) + proc = subprocess.run(args.psql.split() + ["-c", sql], cwd=str(ROOT), + capture_output=True, text=True, timeout=120) + if proc.returncode != 0: + raise SystemExit("psql failed: " + proc.stderr[:500]) + out = proc.stdout + dest = (ROOT / args.output).resolve() + dest.parent.mkdir(parents=True, exist_ok=True) + dest.write_text( + "# chat_id=%s count=%d\n%s\n" % (chat_id, args.count, out), + encoding="utf-8", + ) + print(out) + print("saved to " + str(dest), file=sys.stderr) + + +if __name__ == "__main__": + main() diff --git a/scripts/start-postgres.sh b/scripts/start-postgres.sh new file mode 100644 index 00000000..7c1cb0fb --- /dev/null +++ b/scripts/start-postgres.sh @@ -0,0 +1,14 @@ +#!/bin/sh +set -eu +# Поднимает PostgreSQL обратно и ждёт готовности. +docker compose start postgres +i=0 +while [ "$i" -lt 60 ]; do + if docker compose exec -T postgres pg_isready -U messenger -d messenger >/dev/null 2>&1; then + exit 0 + fi + i=$((i+1)) + sleep 1 +done +echo "postgres did not become ready" >&2 +exit 1 diff --git a/scripts/start-redis.sh b/scripts/start-redis.sh new file mode 100644 index 00000000..02bc3e34 --- /dev/null +++ b/scripts/start-redis.sh @@ -0,0 +1,14 @@ +#!/bin/sh +set -eu +# Поднимает Redis обратно и ждёт готовности. +docker compose start redis +i=0 +while [ "$i" -lt 30 ]; do + if docker compose exec -T redis redis-cli ping >/dev/null 2>&1; then + exit 0 + fi + i=$((i+1)) + sleep 1 +done +echo "redis did not become ready" >&2 +exit 1 diff --git a/scripts/stop-postgres.sh b/scripts/stop-postgres.sh new file mode 100644 index 00000000..690e0601 --- /dev/null +++ b/scripts/stop-postgres.sh @@ -0,0 +1,4 @@ +#!/bin/sh +set -eu +# Останавливает PostgreSQL, сохраняя volume. Используется тестом недоступности. +docker compose stop postgres diff --git a/scripts/stop-redis.sh b/scripts/stop-redis.sh new file mode 100644 index 00000000..a33998c2 --- /dev/null +++ b/scripts/stop-redis.sh @@ -0,0 +1,4 @@ +#!/bin/sh +set -eu +# Останавливает Redis, сохраняя volume. Используется тестом недоступности. +docker compose stop redis diff --git a/tests/test_dependency_failure.py b/tests/test_dependency_failure.py new file mode 100644 index 00000000..1641b2fb --- /dev/null +++ b/tests/test_dependency_failure.py @@ -0,0 +1,133 @@ +#!/usr/bin/env python3 +"""Проверка недоступности Redis и PostgreSQL. + +Управление контейнерами — через скрипты scripts/stop-*.sh / start-*.sh, +чтобы тест не зависел от Docker напрямую. +""" +import argparse +import base64 +import json +import os +import subprocess +import sys +import time +import unittest +import urllib.error +import urllib.request +import uuid +from pathlib import Path + +_parser = argparse.ArgumentParser(description="Dependency failure tests") +_parser.add_argument("--base-url", default=None) +_parser.add_argument("--stop-redis", default="scripts/stop-redis.sh") +_parser.add_argument("--start-redis", default="scripts/start-redis.sh") +_parser.add_argument("--stop-postgres", default="scripts/stop-postgres.sh") +_parser.add_argument("--start-postgres", default="scripts/start-postgres.sh") +_args, _unknown = _parser.parse_known_args() +sys.argv = [sys.argv[0]] + _unknown + +BASE_URL = (_args.base_url or os.environ.get("BASE_URL") or "http://localhost:8080").rstrip("/") +ROOT = Path(__file__).resolve().parents[1] + + +def run_script(path): + full = (ROOT / path).resolve() + if not full.is_file(): + raise unittest.SkipTest("script not found: " + str(full)) + proc = subprocess.run([str(full)], cwd=str(ROOT), capture_output=True, timeout=120) + if proc.returncode != 0: + raise AssertionError( + "script failed: " + path + " rc=" + str(proc.returncode) + + " stderr=" + proc.stderr.decode("utf-8", "replace")[:500] + ) + + +def request(method, path, body=None, token=None, basic=None): + headers = {"Accept": "application/json"} + if token: + headers["Authorization"] = "Bearer " + token + if basic: + headers["Authorization"] = "Basic " + basic + data = None + if body is not None: + data = json.dumps(body, ensure_ascii=False).encode("utf-8") + headers["Content-Type"] = "application/json" + req = urllib.request.Request(BASE_URL + path, data=data, headers=headers, method=method) + try: + with urllib.request.urlopen(req, timeout=10) as resp: + payload = resp.read() + return resp.status, json.loads(payload) if payload else None + except urllib.error.HTTPError as err: + payload = err.read() + return err.code, json.loads(payload) if payload else None + + +def make_user(label): + username = "u_" + label + "_" + uuid.uuid4().hex[:10] + password = "T3st-" + uuid.uuid4().hex + status, user = request( + "POST", + "/api/v1/users", + {"username": username, "display_name": "Dep " + label, "password": password}, + ) + assert status == 201, (status, user) + basic = base64.b64encode((username + ":" + password).encode()).decode() + status, session = request("POST", "/api/v1/auth/sessions", basic=basic) + assert status == 201, (status, session) + return {"user": user, "token": session["token"]} + + +def wait_ready(timeout=60): + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + try: + status, _ = request("GET", "/health/ready") + if status == 200: + return + except Exception: + pass + time.sleep(0.5) + raise AssertionError("API did not become ready within " + str(timeout) + "s") + + +class DependencyFailureTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.alice = make_user("alice") + + def test_redis_down_falls_back_to_db(self): + run_script(_args.stop_redis) + try: + # Валидный токен продолжает работать (fallback на БД). + status, body = request("GET", "/api/v1/users/me", token=self.alice["token"]) + self.assertEqual(status, 200, body) + self.assertEqual(body["id"], self.alice["user"]["id"]) + # Аноним не принимается. + status, body = request("GET", "/api/v1/users/me") + self.assertEqual(status, 401) + self.assertEqual(body["error"]["code"], "unauthorized") + # /health/ready не зависит от Redis. + status, _ = request("GET", "/health/ready") + self.assertEqual(status, 200) + finally: + run_script(_args.start_redis) + wait_ready() + + def test_postgres_down_returns_503(self): + run_script(_args.stop_postgres) + try: + status, body = request("GET", "/health/ready") + self.assertEqual(status, 503) + self.assertEqual(body["error"]["code"], "unavailable") + # Бизнес-запрос не должен отдавать 200 и не должен раскрывать детали. + status, body = request("GET", "/api/v1/users/me", token=self.alice["token"]) + self.assertIn(status, (500, 503)) + self.assertIn("error", body) + self.assertNotIn("psycopg", json.dumps(body).lower()) + finally: + run_script(_args.start_postgres) + wait_ready() + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/tests/test_expiry.py b/tests/test_expiry.py new file mode 100644 index 00000000..9c2b65e9 --- /dev/null +++ b/tests/test_expiry.py @@ -0,0 +1,77 @@ +#!/usr/bin/env python3 +"""Проверка expiry сессии при коротком SESSION_TTL_SECONDS. + +Запускается против стенда с SESSION_TTL_SECONDS <= 10 (например, 2). +Если TTL больше — тест скипается, чтобы не ждать минуты. +""" +import argparse +import base64 +import json +import os +import sys +import time +import unittest +import urllib.error +import urllib.request +import uuid + +_parser = argparse.ArgumentParser(description="Expiry test") +_parser.add_argument("--base-url", default=None) +_parser.add_argument("--ttl", type=int, default=None) +_args, _unknown = _parser.parse_known_args() +sys.argv = [sys.argv[0]] + _unknown + +BASE_URL = (_args.base_url or os.environ.get("BASE_URL") or "http://localhost:8080").rstrip("/") +TTL = _args.ttl or int(os.environ.get("SESSION_TTL_SECONDS", "3600")) + + +def request(method, path, body=None, token=None, basic=None): + headers = {"Accept": "application/json"} + if token: + headers["Authorization"] = "Bearer " + token + if basic: + headers["Authorization"] = "Basic " + basic + data = None + if body is not None: + data = json.dumps(body, ensure_ascii=False).encode("utf-8") + headers["Content-Type"] = "application/json" + req = urllib.request.Request(BASE_URL + path, data=data, headers=headers, method=method) + try: + with urllib.request.urlopen(req, timeout=10) as resp: + payload = resp.read() + return resp.status, json.loads(payload) if payload else None + except urllib.error.HTTPError as err: + payload = err.read() + return err.code, json.loads(payload) if payload else None + + +@unittest.skipIf(TTL > 10, "SESSION_TTL_SECONDS > 10; запустите стенд с коротким TTL") +class ExpiryTests(unittest.TestCase): + def test_session_expires(self): + username = "u_exp_" + uuid.uuid4().hex[:10] + password = "T3st-" + uuid.uuid4().hex + status, user = request( + "POST", + "/api/v1/users", + {"username": username, "display_name": "Expiry", "password": password}, + ) + self.assertEqual(status, 201, user) + basic = base64.b64encode((username + ":" + password).encode()).decode() + status, session = request("POST", "/api/v1/auth/sessions", basic=basic) + self.assertEqual(status, 201, session) + token = session["token"] + status, _ = request("GET", "/api/v1/users/me", token=token) + self.assertEqual(status, 200) + time.sleep(TTL + 2) + status, body = request("GET", "/api/v1/users/me", token=token) + self.assertEqual(status, 401) + self.assertEqual(body["error"]["code"], "unauthorized") + # Повторный вход с теми же credentials снова работает. + status, session2 = request("POST", "/api/v1/auth/sessions", basic=basic) + self.assertEqual(status, 201, session2) + status, _ = request("GET", "/api/v1/users/me", token=session2["token"]) + self.assertEqual(status, 200) + + +if __name__ == "__main__": + unittest.main(verbosity=2)