diff --git a/.env.example b/.env.example index 7a024f45..2291af6e 100644 --- a/.env.example +++ b/.env.example @@ -13,6 +13,8 @@ POSTGRES_PASSWORD=replace-with-a-local-password POSTGRES_DB=messenger # Optional. When set, the API reads the URL from this file instead of DATABASE_URL. # DATABASE_URL_FILE=/run/secrets/database_url -# Optional on 3, required use on 4 in lab2; Redis OR Valkey: +# Optional on 3, required use on 4 in lab2; Redis OR Valkey. +# PostgreSQL stores the session. Redis caches the lookup and does not keep its own volume. SESSION_STORE=postgres -CACHE_URL_FILE=/run/secrets/cache_url +# Compose injects REDIS_URL. When set, this file wins and is not logged. +# CACHE_URL_FILE=/run/secrets/cache_url diff --git a/REPORT.md b/REPORT.md index cc15aa9e..dafbc3c5 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,13 +1,13 @@ # Отчёт — лабораторная 2 - Автор, группа: Тимаева М.П. БПИ2302 -- Целевая оценка; выбранный трек 5, если нужен: 3 +- Целевая оценка; выбранный трек 5, если нужен: 4 - Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: контракт и README этой лабораторной; PostgreSQL transactions; RFC 7617; библиотеки fastapi, uvicorn, asyncpg 0.32.0, argon2-cffi 25.1.0. Реализацию переноса в PostgreSQL помог собрать агент Cursor. +- Использованные источники, библиотеки и помощь ИИ: контракт и README этой лабораторной; PostgreSQL transactions и EXPLAIN; RFC 7617; библиотеки fastapi, uvicorn, asyncpg 0.32.0, redis 8.1.0, argon2-cffi 25.1.0. Реализацию помог собрать агент Cursor. ## Запуск из чистого clone -Нужны Docker и Docker Compose v2. Образы закреплены: `python:3.14.8-slim-bookworm` (digest в Dockerfile) и `postgres:16.10-alpine`. +Нужны Docker и Docker Compose v2. Образы закреплены: `python:3.14.8-slim-bookworm` (digest в Dockerfile), `postgres:16.10-alpine` и `redis:7.4.11-alpine`. ```sh cp .env.example .env @@ -16,7 +16,7 @@ docker compose --env-file .env config --quiet docker compose --env-file .env up -d --build ``` -API читает `DATABASE_URL`, который compose собирает из `POSTGRES_USER`, `POSTGRES_PASSWORD` и `POSTGRES_DB`. Если задан `DATABASE_URL_FILE`, он важнее и файл не логируется. Миграции из `migrations/` применяются при старте API и записываются в `schema_migrations`; повторный старт их не исполняет заново. Пароль БД лежит только в неотслеживаемом `.env`. +API читает `DATABASE_URL`, который compose собирает из `POSTGRES_USER`, `POSTGRES_PASSWORD` и `POSTGRES_DB`. `REDIS_URL` compose задаёт как `redis://redis:6379/0`. Если заданы `DATABASE_URL_FILE` или `CACHE_URL_FILE`, они важнее и содержимое файлов не логируется. Миграции из `migrations/` применяются при старте API и записываются в `schema_migrations`; повторный старт их не исполняет заново. Пароль БД лежит только в неотслеживаемом `.env`. У Redis пароля нет, своего volume тоже нет. Дождитесь `GET http://127.0.0.1:8080/health/ready` → `200 {"status":"ok"}`. Для smoke и persistence `SESSION_TTL_SECONDS` не меньше 300; в `.env.example` стоит 3600. @@ -25,23 +25,25 @@ make check make test chmod +x scripts/restart.sh make test-persistence ACTION_SCRIPT=scripts/restart.sh +python scripts/check_grade4.py +python scripts/explain_history.py ``` -На Windows `python` не может запустить `scripts/restart.sh` через CreateProcess (`WinError 193`). Сам hook — POSIX shell и рассчитан на Linux, WSL или Git Bash с POSIX Python. На этой машине публичный harness был выполнен в контейнере `docker:28-cli` с `python3`, в сети compose и с Docker socket; вызывался тот же `scripts/restart.sh`. Подробности в `evidence/grade3.txt`. +`scripts/restart.sh` перезапускает `api`, `postgres` и `redis`, без `down -v`. На Windows `python` не может запустить этот файл через CreateProcess (`WinError 193`). На этой машине публичный harness был выполнен в контейнере `docker:28-cli` с `python3`, в сети compose и с Docker socket. Подробности в `evidence/grade4.txt`. Остановка без удаления данных: `docker compose --env-file .env stop`. Намеренное удаление учебного volume: `docker compose --env-file .env down -v`. ## Архитектура и решения -Клиент ходит в один процесс API. Источник истины — PostgreSQL, named volume `pgdata`. Redis/Valkey нет: действующие сессии лежат в таблице `sessions`. +Клиент ходит в один процесс API. Источник истины для пользователей, чатов, сообщений и сессий — PostgreSQL, named volume `pgdata`. Redis 7.4 — кэш поиска сессии: ключ `session:{sha256 токена}`, значение — `expires_at`. Сырой токен и hash пароля в Redis не пишутся. TTL ключа равен остатку до `expires_at` и чтением не продлевается. Промах или недоступный Redis не заменяют строку PostgreSQL: личность подтверждается только ею. Logout сначала удаляет строку, затем ключ. После рестарта Redis пуст, и тот же токен находится в PostgreSQL, поэтому отдельная persistence Redis не нужна. -Таблицы `migrations/001_init.sql`: `users` (UNIQUE username, FK нет наружу), `sessions` (PK — SHA-256 токена, FK на пользователя, `expires_at`), `chats`, `chat_members` (PK пары, оба FK, `position`), `messages` (FK на чат и отправителя), `schema_migrations`. Индекс `messages_history_idx (chat_id, created_at, id)` обслуживает keyset. Парольный hash в ответы не выбирается. Клиенту отдаётся сырой opaque-токен (`secrets.token_urlsafe(32)`), в БД хранится только хеш. +Таблицы `migrations/001_init.sql`: `users` (UNIQUE username), `sessions` (PK — SHA-256 токена, FK на пользователя, `expires_at`), `chats`, `chat_members` (PK пары, оба FK, `position`), `messages` (FK на чат и отправителя), `schema_migrations`. Индекс `messages_history_idx (chat_id, created_at, id)` обслуживает keyset. Запросы параметризованы (`$1` в asyncpg). Пул: `min_size` 1, `max_size` 10, таймаут подключения и команды 5 с, `statement_timeout` 5000 мс. Парольный hash в ответы не выбирается. Клиенту отдаётся сырой opaque-токен (`secrets.token_urlsafe(32)`). Создание чата — одна транзакция: все `member_ids` должны существовать, иначе rollback и 400, затем вставка чата и участников. Занятый username — unique violation → 409 без текста SQL. `created_at` назначает процесс и делает его строго возрастающим, чтобы порядок `(created_at, id)` совпадал с порядком записи. Рестарт не меняет `expires_at`. -`GET /health/live` проверяет только процесс. `GET /health/ready` делает `SELECT 1`; без БД ответ 503 `unavailable`. Basic принимается только на `POST /api/v1/auth/sessions`. Остальные маршруты требуют Bearer. `X-User-Id` не идентифицирует пользователя. Пароли — Argon2id. +`GET /health/live` проверяет только процесс. `GET /health/ready` делает `SELECT 1`; без БД ответ 503 `unavailable`. Та же 503, а не 500 и не личность из кэша, приходит на Bearer, если PostgreSQL недоступен. Запрос без токена остаётся 401 и до Redis, и до БД. Basic принимается только на `POST /api/v1/auth/sessions`. Остальные маршруты требуют Bearer. `X-User-Id` не идентифицирует пользователя. Пароли — Argon2id. -Переменные: `APP_HOST`, `APP_PORT`, `APP_ENV`, `LOG_LEVEL`, `SHUTDOWN_TIMEOUT_SECONDS`, `SESSION_TTL_SECONDS` читаются как в `.env.example`. `DATABASE_URL` задаёт compose; `DATABASE_URL_FILE` — необязательная замена. `SESSION_STORE=postgres` описывает это решение; кэш на оценке 3 не используется. +Переменные: `APP_HOST`, `APP_PORT`, `APP_ENV`, `LOG_LEVEL`, `SHUTDOWN_TIMEOUT_SECONDS`, `SESSION_TTL_SECONDS` читаются как в `.env.example`. `DATABASE_URL` и `REDIS_URL` задаёт compose; `DATABASE_URL_FILE` и `CACHE_URL_FILE` — необязательные замены. `SESSION_STORE=postgres` означает, что строка сессии живёт в PostgreSQL, а Redis только кэширует поиск. Из lab1 сохранены пользователи, чаты, членство, сообщения и keyset-пагинация. Идентификация lab1 (`X-User-Id`) заменена на пароль, Basic и Bearer. @@ -50,7 +52,9 @@ make test-persistence ACTION_SCRIPT=scripts/restart.sh | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | | Публичный smoke | `python tests/smoke.py --base-url http://127.0.0.1:8080` на образе из Dockerfile | PASS: lab2 public API scenario | evidence/grade3.txt | -| Данные и сессия переживают рестарт API и PostgreSQL | `tests/resilience.py --mode persistence --action-script scripts/restart.sh` | PASS. ID контейнеров не сменились (`15bfccf88c7a`, `cbe7139645a5`), volume `mtusi2026lab2-fork_pgdata` на месте | evidence/grade3.txt | +| Данные и сессия переживают рестарт API, PostgreSQL и Redis | `tests/resilience.py --mode persistence --action-script scripts/restart.sh` | PASS. ID не сменились (`87a78974fbc8`, `cbe7139645a5`, `e271b1f6ea0e`), volume `mtusi2026lab2-fork_pgdata` на месте, у Redis volume нет | evidence/grade4.txt | +| Гонка username, rollback, неверный пароль, logout, короткий TTL, отказ Redis и PostgreSQL | `python scripts/check_grade4.py` | Все семь проверок PASS. После скрипта TTL снова 3600 | evidence/grade4.txt | +| Индекс истории | `python scripts/explain_history.py`, 10 000 сообщений в одном чате | `Index Scan using messages_history_idx`, LIMIT 51, `Buffers: shared hit=4`, Seq Scan нет | evidence/explain.txt | | Повтор миграций не дублирует данные | второй `docker compose restart api`, затем counts | `schema_migrations` = 1, users = 14, messages = 6 и до, и после | evidence/grade3.txt | | Атомарное создание чата | `python scripts/check_grade3.py` | 400 на неизвестного участника, в `chats` строки с этим title нет | evidence/grade3.txt | | Expiry сессии | отдельный прогон с `SESSION_TTL_SECONDS=2`, затем возврат к 3600 | тот же токен через 3 с получил 401 | evidence/grade3.txt | @@ -61,15 +65,16 @@ make test-persistence ACTION_SCRIPT=scripts/restart.sh ## Эксперименты и отказы -Отдельного нагрузочного эксперимента для оценки 3 нет. +Отдельного нагрузочного эксперимента нет. EXPLAIN снят на 10 000 сообщениях одного чата: вторая страница keyset, `LIMIT 51`, выполнение 0.363 мс, прочитаны 4 страницы буфера. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| `scripts/restart.sh` перезапускает api и postgres | Тот же Bearer читает прежнее сообщение, volume сохранён | PASS persistence; ID контейнеров те же, volume на месте | Готовность уложилась в бюджет теста (90 с). Подтверждённые строки не пропали | -| Остановлен только postgres | live 200, ready 503, без SQL в теле | Так и было | После `start` ready снова 200. Данные volume не удалялись | +| `scripts/restart.sh` перезапускает api, postgres и redis | Тот же Bearer читает прежнее сообщение, volume PostgreSQL сохранён, кэш может опустеть | PASS persistence; ID трёх контейнеров те же, volume на месте | Готовность уложилась в бюджет теста (90 с). Подтверждённые строки не пропали | +| Остановлен только Redis | Действующая сессия читается из PostgreSQL, аноним получает 401 | Так и было | После `start` кэш снова доступен. Данные не терялись | +| Остановлен только postgres | Bearer получает 503 без SQL, аноним — 401 | Так и было | После `start` ready снова 200. Volume не удалялся | ## Ограничения и следующие шаги -Один процесс API и одна БД. Потеря Docker-хоста уничтожает и API, и PostgreSQL. Сессии не в Redis: оценка 4 потребует Redis или Valkey, пул уже ограничен (`max_size` 10, таймаут 5 с), но гонка username, EXPLAIN на ≥10 000 сообщений и автоматические тесты короткого TTL не делались. Идемпотентность и вторая реплика — лабораторная 3 курса, не эта оценка. +Один процесс API и одна БД. Потеря Docker-хоста уничтожает и API, и PostgreSQL. Redis не хранит сессию сам по себе: после очистки кэша доступна только строка в PostgreSQL, а пока БД недоступна, кэш не принимается за личность. Пул ограничен 10 соединениями и таймаутом 5 с. Идемпотентность и вторая реплика — лабораторная 3 курса. Оценка 5 (согласованность кэша под гонкой или эксперимент на ≥100 000 сообщений с backup) не делалась. -Учебное упрощение: время сообщения монотонно только внутри одного процесса. На оценке 3 процесс один, поэтому порядок записи и `(created_at, id)` совпадают. +Учебное упрощение: время сообщения монотонно только внутри одного процесса. Процесс один, поэтому порядок записи и `(created_at, id)` совпадают. diff --git a/app/cache.py b/app/cache.py new file mode 100644 index 00000000..3ad5c136 --- /dev/null +++ b/app/cache.py @@ -0,0 +1,70 @@ +"""Session lookup cache. PostgreSQL remains the source of truth.""" +import logging +from datetime import datetime, timezone +from typing import Optional + +from redis.asyncio import Redis + +logger = logging.getLogger('messenger') + +_PREFIX = 'session:' + + +def open_cache(url: str) -> Redis: + return Redis.from_url( + url, + socket_connect_timeout=1, + socket_timeout=1, + max_connections=10, + decode_responses=True, + ) + + +def _stamp(moment: datetime) -> str: + return moment.astimezone(timezone.utc).isoformat(timespec='microseconds').replace('+00:00', 'Z') + + +class SessionCache: + """Stores sha256(token) -> expires_at. A read never refreshes the TTL.""" + + def __init__(self, client: Redis) -> None: + self._client = client + + async def get(self, token_hash: str) -> Optional[str]: + """Cached expiry, or None on a miss and when Redis cannot be reached.""" + try: + return await self._client.get(_PREFIX + token_hash) + except Exception as exc: + logger.warning('session cache read skipped (%s)', type(exc).__name__) + return None + + async def remember( + self, + token_hash: str, + expires_at: datetime, + now: datetime, + *, + only_if_absent: bool, + ) -> None: + remaining_ms = int((expires_at - now).total_seconds() * 1000) + if remaining_ms <= 0: + await self.drop(token_hash) + return + try: + await self._client.set( + _PREFIX + token_hash, + _stamp(expires_at), + px=remaining_ms, + nx=only_if_absent, + ) + except Exception as exc: + logger.warning('session cache write skipped (%s)', type(exc).__name__) + + async def drop(self, token_hash: str) -> None: + try: + await self._client.delete(_PREFIX + token_hash) + except Exception as exc: + logger.warning('session cache delete skipped (%s)', type(exc).__name__) + + async def close(self) -> None: + await self._client.aclose() diff --git a/app/config.py b/app/config.py index cf46bedc..584063dc 100644 --- a/app/config.py +++ b/app/config.py @@ -12,22 +12,23 @@ class Settings: shutdown_timeout: int session_ttl_seconds: int database_url: str + redis_url: str -def _database_url() -> str: - """DATABASE_URL_FILE wins. The value is not logged.""" - file_name = os.getenv('DATABASE_URL_FILE', '').strip() +def _secret(file_var: str, value_var: str) -> str: + """A *_FILE variable wins. The secret value is not logged.""" + file_name = os.getenv(file_var, '').strip() if file_name: try: value = Path(file_name).read_text(encoding='utf-8').strip() except OSError: - raise RuntimeError('DATABASE_URL_FILE could not be read') from None + raise RuntimeError('%s could not be read' % file_var) from None if not value: - raise RuntimeError('DATABASE_URL_FILE is empty') + raise RuntimeError('%s is empty' % file_var) return value - value = os.getenv('DATABASE_URL', '').strip() + value = os.getenv(value_var, '').strip() if not value: - raise RuntimeError('DATABASE_URL or DATABASE_URL_FILE is required') + raise RuntimeError('%s or %s is required' % (value_var, file_var)) return value @@ -39,5 +40,6 @@ def load_settings() -> Settings: log_level=os.getenv('LOG_LEVEL', 'info').lower(), shutdown_timeout=int(os.getenv('SHUTDOWN_TIMEOUT_SECONDS', '5')), session_ttl_seconds=int(os.getenv('SESSION_TTL_SECONDS', '3600')), - database_url=_database_url(), + database_url=_secret('DATABASE_URL_FILE', 'DATABASE_URL'), + redis_url=_secret('CACHE_URL_FILE', 'REDIS_URL'), ) diff --git a/app/db.py b/app/db.py index a6f03914..5c154865 100644 --- a/app/db.py +++ b/app/db.py @@ -21,6 +21,7 @@ async def open_pool(database_url: str) -> asyncpg.Pool: max_size=10, timeout=5, command_timeout=5, + server_settings={'statement_timeout': '5000'}, ) async with pool.acquire() as conn: await conn.execute('SELECT 1') diff --git a/app/main.py b/app/main.py index 097b7990..0b739ad3 100644 --- a/app/main.py +++ b/app/main.py @@ -10,6 +10,7 @@ from fastapi.exceptions import RequestValidationError from fastapi.responses import JSONResponse from starlette.exceptions import HTTPException as StarletteHTTPException +from .cache import SessionCache, open_cache from .config import load_settings from .db import open_pool from .errors import ApiError @@ -58,12 +59,16 @@ _OPENAPI_PATH = Path(__file__).resolve().parents[1] / 'contracts' / 'openapi.jso async def lifespan(app: FastAPI): settings = load_settings() pool = await open_pool(settings.database_url) + cache = SessionCache(open_cache(settings.redis_url)) try: await apply_migrations(pool) - app.state.store = Store(pool, settings.session_ttl_seconds) + app.state.store = Store(pool, cache, settings.session_ttl_seconds) yield finally: - await pool.close() + try: + await cache.close() + finally: + await pool.close() def create_app() -> FastAPI: diff --git a/app/store.py b/app/store.py index 2ef1de83..716818be 100644 --- a/app/store.py +++ b/app/store.py @@ -8,6 +8,7 @@ from typing import Dict, List, Optional, Sequence, Tuple import asyncpg +from .cache import SessionCache from .errors import conflict, invalid_request, unavailable from .pagination import Key from .passwords import hash_password, password_matches @@ -88,11 +89,22 @@ def _as_uuid(value: str, message: str) -> uuid.UUID: raise invalid_request(message) from None -class Store: - """PostgreSQL is the source of truth. One process clock keeps created_at ordered.""" +def _db_down(exc: BaseException) -> bool: + return isinstance(exc, ( + asyncpg.PostgresConnectionError, + asyncpg.InterfaceError, + asyncpg.CannotConnectNowError, + OSError, + TimeoutError, + )) - def __init__(self, pool: asyncpg.Pool, session_ttl_seconds: int = 3600) -> None: + +class Store: + """PostgreSQL is the source of truth. Redis only caches the session lookup.""" + + def __init__(self, pool: asyncpg.Pool, cache: SessionCache, session_ttl_seconds: int = 3600) -> None: self._pool = pool + self._cache = cache self._session_ttl = timedelta(seconds=session_ttl_seconds) self._lock = threading.Lock() self._last_moment: Optional[datetime] = None @@ -135,15 +147,20 @@ class Store: return User(str(user_id), username, display_name, _stamp(created)) async def authenticate(self, username: str, password: str) -> Optional[User]: - async with self._pool.acquire() as conn: - row = await conn.fetchrow( - ''' - SELECT id, username, display_name, created_at, password_hash - FROM users - WHERE username = $1 - ''', - username, - ) + try: + async with self._pool.acquire() as conn: + row = await conn.fetchrow( + ''' + SELECT id, username, display_name, created_at, password_hash + FROM users + WHERE username = $1 + ''', + username, + ) + except Exception as exc: + if _db_down(exc): + raise unavailable('Хранилище недоступно') from None + raise stored_hash = row['password_hash'] if row is not None else None if not password_matches(stored_hash, password) or row is None: return None @@ -152,50 +169,72 @@ class Store: async def create_session(self, user_id: str) -> Tuple[str, str]: token = secrets.token_urlsafe(32) expires = datetime.now(timezone.utc) + self._session_ttl - async with self._pool.acquire() as conn: - await conn.execute( - ''' - INSERT INTO sessions (token_hash, user_id, expires_at) - VALUES ($1, $2, $3) - ''', - _token_key(token), - _as_uuid(user_id, 'Некорректный user_id'), - expires, - ) + key = _token_key(token) + try: + async with self._pool.acquire() as conn: + await conn.execute( + ''' + INSERT INTO sessions (token_hash, user_id, expires_at) + VALUES ($1, $2, $3) + ''', + key, + _as_uuid(user_id, 'Некорректный user_id'), + expires, + ) + except Exception as exc: + if _db_down(exc): + raise unavailable('Хранилище недоступно') from None + raise + await self._cache.remember(key, expires, datetime.now(timezone.utc), only_if_absent=False) return token, _stamp(expires) async def user_for_token(self, token: str) -> Optional[User]: now = datetime.now(timezone.utc) key = _token_key(token) - async with self._pool.acquire() as conn: - row = await conn.fetchrow( - ''' - SELECT u.id, u.username, u.display_name, u.created_at, s.expires_at - FROM sessions s - JOIN users u ON u.id = s.user_id - WHERE s.token_hash = $1 - ''', - key, - ) - if row is None: - return None - if row['expires_at'] <= now: - await conn.execute('DELETE FROM sessions WHERE token_hash = $1', key) - return None - return _user(row) + cached = await self._cache.get(key) + try: + async with self._pool.acquire() as conn: + row = await conn.fetchrow( + ''' + SELECT u.id, u.username, u.display_name, u.created_at, s.expires_at + FROM sessions s + JOIN users u ON u.id = s.user_id + WHERE s.token_hash = $1 + ''', + key, + ) + if row is None or row['expires_at'] <= now: + if row is not None: + await conn.execute('DELETE FROM sessions WHERE token_hash = $1', key) + await self._cache.drop(key) + return None + if cached is None: + await self._cache.remember(key, row['expires_at'], now, only_if_absent=True) + return _user(row) + except Exception as exc: + if _db_down(exc): + raise unavailable('Хранилище недоступно') from None + raise async def revoke_session(self, token: str) -> bool: now = datetime.now(timezone.utc) - async with self._pool.acquire() as conn: - row = await conn.fetchrow( - ''' - DELETE FROM sessions - WHERE token_hash = $1 AND expires_at > $2 - RETURNING token_hash - ''', - _token_key(token), - now, - ) + key = _token_key(token) + try: + async with self._pool.acquire() as conn: + row = await conn.fetchrow( + ''' + DELETE FROM sessions + WHERE token_hash = $1 AND expires_at > $2 + RETURNING token_hash + ''', + key, + now, + ) + except Exception as exc: + if _db_down(exc): + raise unavailable('Хранилище недоступно') from None + raise + await self._cache.drop(key) return row is not None async def create_chat(self, title: str, member_ids: Sequence[str]) -> Chat: diff --git a/compose.yaml b/compose.yaml index c54afbb5..ff31358e 100644 --- a/compose.yaml +++ b/compose.yaml @@ -1,4 +1,5 @@ -# Local lab2 grade-3 stand. Secrets come from .env, which is not committed. +# Local stand. Secrets come from .env, which is not committed. +# PostgreSQL is the source of truth. Redis caches session lookups and has no volume. services: postgres: image: postgres:16.10-alpine @@ -17,6 +18,17 @@ services: - "127.0.0.1:5432:5432" restart: unless-stopped + redis: + image: redis:7.4.11-alpine + ports: + - "127.0.0.1:6379:6379" + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 2s + timeout: 3s + retries: 30 + restart: unless-stopped + api: build: context: . @@ -29,11 +41,14 @@ services: SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} SHUTDOWN_TIMEOUT_SECONDS: ${SHUTDOWN_TIMEOUT_SECONDS:-5} DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB} + REDIS_URL: redis://redis:6379/0 ports: - "127.0.0.1:8080:8080" depends_on: postgres: condition: service_healthy + redis: + condition: service_healthy healthcheck: test: - CMD diff --git a/evidence/explain.txt b/evidence/explain.txt new file mode 100644 index 00000000..9a7ecb79 --- /dev/null +++ b/evidence/explain.txt @@ -0,0 +1,16 @@ +rows_in_chat: 10000 +query: keyset page after the 50th message, LIMIT 51 + + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + Limit (cost=0.29..4.19 rows=51 width=58) (actual time=0.047..0.070 rows=51 loops=1) + Buffers: shared hit=4 + -> Index Scan using messages_history_idx on messages (cost=0.29..762.42 rows=9950 width=58) (actual time=0.044..0.063 rows=51 loops=1) + Index Cond: ((chat_id = '49b53d26-7fad-40e0-8811-59eae519e639'::uuid) AND (ROW(created_at, id) > ROW('2024-01-01 00:00:00.00005+00'::timestamp with time zone, '38a04f80-174d-4233-ac1b-f319ea7668f3'::uuid))) + Buffers: shared hit=4 + Planning: + Buffers: shared hit=106 + Planning Time: 0.886 ms + Execution Time: 0.363 ms +(9 rows) + diff --git a/evidence/grade4.txt b/evidence/grade4.txt new file mode 100644 index 00000000..c5fd827c --- /dev/null +++ b/evidence/grade4.txt @@ -0,0 +1,31 @@ +Grade 4 checks. No tokens or passwords. + +python scripts/check_grade4.py + PASS: one 201 and seven 409 for the same username + PASS: unknown member rolls back chat and membership + PASS: wrong password and unknown user share the same 401 challenge + PASS: logout returns 204, then 401, and drops the cache key + PASS: Redis outage falls back to PostgreSQL and still rejects anonymous requests + PASS: PostgreSQL outage is 503 for a bearer and 401 without one + PASS: SESSION_TTL_SECONDS=2 rejects the same token after 3 seconds + PASS: grade 4 checks + +After that script the API environment was SESSION_TTL_SECONDS=3600. + +python scripts/explain_history.py + PASS: history index used at 10000 messages + Plan: Index Scan using messages_history_idx, LIMIT 51, Buffers shared hit=4, no Seq Scan. + Saved as evidence/explain.txt. The seed chat was deleted afterwards. + +Smoke on the rebuilt image: + PASS: lab2 public API scenario + +Persistence, hook scripts/restart.sh restarts api, postgres and redis. +Ran inside docker:28-cli because Windows CreateProcess cannot execute the shell script. + PASS: persistence preserved confirmed data and existing session. +Container IDs unchanged: + api 87a78974fbc8 + postgres cbe7139645a5 + redis e271b1f6ea0e +Volume still present: mtusi2026lab2-fork_pgdata +Redis has no volume; the session row in PostgreSQL is what survived. diff --git a/requirements.txt b/requirements.txt index 0c7146cb..1cbc0db8 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,6 @@ # Direct: fastapi, pydantic, uvicorn, argon2-cffi. The rest are their dependencies, pinned. asyncpg==0.32.0 +redis==8.1.0 annotated-doc==0.0.5 annotated-types==0.8.0 anyio==4.15.1 diff --git a/scripts/check_grade4.py b/scripts/check_grade4.py new file mode 100644 index 00000000..3e6807b6 --- /dev/null +++ b/scripts/check_grade4.py @@ -0,0 +1,293 @@ +#!/usr/bin/env python3 +"""Grade-4 checks. Not part of make test. Restores Redis, PostgreSQL and SESSION_TTL.""" +import base64 +import hashlib +import json +import os +import re +import subprocess +import sys +import time +import urllib.error +import urllib.request +import uuid +from concurrent.futures import ThreadPoolExecutor +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[1] +BASE_URL = os.environ.get('BASE_URL', 'http://127.0.0.1:8080').rstrip('/') +ENV_PATH = ROOT / '.env' + + +def call(method, path, body=None, headers=None, timeout=20): + data = None if body is None else json.dumps(body).encode('utf-8') + req = urllib.request.Request(BASE_URL + path, data=data, method=method) + if body is not None: + req.add_header('Content-Type', 'application/json') + for key, value in (headers or {}).items(): + req.add_header(key, value) + try: + with urllib.request.urlopen(req, timeout=timeout) as response: + payload = response.read() + return response.status, payload, response.headers + except urllib.error.HTTPError as exc: + return exc.code, exc.read(), exc.headers + + +def compose(*args): + proc = subprocess.run( + ['docker', 'compose', '--env-file', '.env', *args], + cwd=ROOT, + check=False, + capture_output=True, + text=True, + ) + if proc.returncode != 0: + sys.stderr.write(proc.stderr) + raise SystemExit('docker compose %s failed' % ' '.join(args)) + return proc.stdout + + +def psql(sql): + proc = subprocess.run( + [ + 'docker', 'compose', '--env-file', '.env', 'exec', '-T', 'postgres', + 'psql', '-U', os.environ.get('POSTGRES_USER', 'messenger'), + '-d', os.environ.get('POSTGRES_DB', 'messenger'), + '-v', 'ON_ERROR_STOP=1', '-tAc', sql, + ], + cwd=ROOT, + check=False, + capture_output=True, + text=True, + ) + if proc.returncode != 0: + sys.stderr.write(proc.stderr) + raise SystemExit('psql failed') + return proc.stdout.strip() + + +def redis_cli(*args): + proc = subprocess.run( + ['docker', 'compose', '--env-file', '.env', 'exec', '-T', 'redis', 'redis-cli', *args], + cwd=ROOT, + check=False, + capture_output=True, + text=True, + ) + if proc.returncode != 0: + sys.stderr.write(proc.stderr) + raise SystemExit('redis-cli failed') + return proc.stdout.strip() + + +def wait_ready(seconds=45): + deadline = time.monotonic() + seconds + while time.monotonic() < deadline: + try: + status, _, _ = call('GET', '/health/ready', timeout=3) + if status == 200: + return + except Exception: + pass + time.sleep(0.5) + raise SystemExit('API did not become ready') + + +def register(label): + username = 'u_%s_%s' % (label, uuid.uuid4().hex[:12]) + password = 'T3st-' + uuid.uuid4().hex + status, raw, _ = call('POST', '/api/v1/users', { + 'username': username, + 'display_name': label, + 'password': password, + }) + if status != 201: + raise SystemExit('register failed: %s' % status) + user = json.loads(raw) + return user, username, password + + +def login(username, password): + basic = base64.b64encode((username + ':' + password).encode('utf-8')).decode('ascii') + status, raw, headers = call('POST', '/api/v1/auth/sessions', headers={'Authorization': 'Basic ' + basic}) + return status, raw, headers + + +def bearer(token): + return {'Authorization': 'Bearer ' + token} + + +def session_key(token): + return 'session:' + hashlib.sha256(token.encode('utf-8')).hexdigest() + + +def check_race(): + username = 'u_race_' + uuid.uuid4().hex[:12] + password = 'T3st-' + uuid.uuid4().hex + body = {'username': username, 'display_name': 'Race', 'password': password} + + def once(): + status, _, _ = call('POST', '/api/v1/users', body) + return status + + with ThreadPoolExecutor(max_workers=8) as pool: + statuses = list(pool.map(lambda _: once(), range(8))) + if statuses.count(201) != 1 or statuses.count(409) != 7: + raise SystemExit('username race statuses: %s' % statuses) + print('PASS: one 201 and seven 409 for the same username') + + +def check_rollback(): + user, username, password = register('rollback') + status, raw, _ = login(username, password) + if status != 201: + raise SystemExit('rollback login failed') + token = json.loads(raw)['token'] + title = 'rollback-' + uuid.uuid4().hex + missing = str(uuid.uuid4()) + status, _, _ = call( + 'POST', + '/api/v1/chats', + {'title': title, 'member_ids': [user['id'], missing]}, + headers=bearer(token), + ) + if status != 400: + raise SystemExit('expected 400 for an unknown member, got %s' % status) + safe = title.replace("'", '') + chats = psql("SELECT count(*) FROM chats WHERE title = '%s'" % safe) + members = psql( + "SELECT count(*) FROM chat_members m JOIN chats c ON c.id = m.chat_id WHERE c.title = '%s'" % safe + ) + if chats != '0' or members != '0': + raise SystemExit('rollback left rows chats=%s members=%s' % (chats, members)) + print('PASS: unknown member rolls back chat and membership') + + +def check_wrong_password(): + _, username, password = register('pw') + bad_status, _, bad_headers = login(username, 'wrong-password-value') + missing_status, _, missing_headers = login('missing_' + uuid.uuid4().hex[:8], password) + bad_auth = bad_headers.get('WWW-Authenticate', '') + missing_auth = missing_headers.get('WWW-Authenticate', '') + if bad_status != 401 or missing_status != 401: + raise SystemExit('password statuses %s %s' % (bad_status, missing_status)) + if not bad_auth.lower().startswith('basic') or bad_auth != missing_auth: + raise SystemExit('WWW-Authenticate mismatch') + print('PASS: wrong password and unknown user share the same 401 challenge') + + +def check_logout(): + _, username, password = register('logout') + status, raw, _ = login(username, password) + if status != 201: + raise SystemExit('logout login failed') + token = json.loads(raw)['token'] + status, body, _ = call('DELETE', '/api/v1/auth/sessions/current', headers=bearer(token)) + if status != 204 or body: + raise SystemExit('logout did not return an empty 204') + status, _, _ = call('GET', '/api/v1/users/me', headers=bearer(token)) + if status != 401: + raise SystemExit('revoked token was accepted') + if redis_cli('EXISTS', session_key(token)) != '0': + raise SystemExit('revoked session key is still cached') + print('PASS: logout returns 204, then 401, and drops the cache key') + + +def check_redis_down(): + _, username, password = register('redis') + status, raw, _ = login(username, password) + if status != 201: + raise SystemExit('redis-down login failed') + token = json.loads(raw)['token'] + compose('stop', 'redis') + try: + status, _, _ = call('GET', '/api/v1/users/me', headers=bearer(token)) + if status != 200: + raise SystemExit('valid session failed while Redis was down: %s' % status) + status, _, _ = call('GET', '/api/v1/users/me') + if status != 401: + raise SystemExit('anonymous request was not 401 while Redis was down: %s' % status) + finally: + compose('start', 'redis') + wait_ready() + print('PASS: Redis outage falls back to PostgreSQL and still rejects anonymous requests') + + +def check_postgres_down(): + _, username, password = register('pg') + status, raw, _ = login(username, password) + if status != 201: + raise SystemExit('postgres-down login failed') + token = json.loads(raw)['token'] + compose('stop', 'postgres') + try: + status, body, _ = call('GET', '/api/v1/users/me', headers=bearer(token)) + text = body.decode('utf-8', 'replace').lower() + if status != 503: + raise SystemExit('expected 503 when PostgreSQL is down, got %s' % status) + if 'asyncpg' in text or 'select ' in text or 'syntax' in text: + raise SystemExit('503 body leaked database details') + status, _, _ = call('GET', '/api/v1/users/me') + if status != 401: + raise SystemExit('anonymous request was not 401 while PostgreSQL was down: %s' % status) + finally: + compose('start', 'postgres') + wait_ready() + print('PASS: PostgreSQL outage is 503 for a bearer and 401 without one') + + +def check_expiry(): + original = ENV_PATH.read_bytes() + text = original.decode('utf-8') + updated, count = re.subn( + r'^SESSION_TTL_SECONDS=.*$', + 'SESSION_TTL_SECONDS=2', + text, + count=1, + flags=re.M, + ) + if count != 1: + raise SystemExit('SESSION_TTL_SECONDS is missing from .env') + ENV_PATH.write_bytes(updated.encode('utf-8')) + try: + compose('up', '-d', '--force-recreate', '--no-deps', 'api') + wait_ready() + _, username, password = register('ttl') + status, raw, _ = login(username, password) + if status != 201: + raise SystemExit('ttl login failed') + token = json.loads(raw)['token'] + time.sleep(3) + status, _, _ = call('GET', '/api/v1/users/me', headers=bearer(token)) + if status != 401: + raise SystemExit('expired token was accepted: %s' % status) + finally: + ENV_PATH.write_bytes(original) + compose('up', '-d', '--force-recreate', '--no-deps', 'api') + wait_ready() + print('PASS: SESSION_TTL_SECONDS=2 rejects the same token after 3 seconds') + + +def main(): + try: + check_race() + check_rollback() + check_wrong_password() + check_logout() + check_redis_down() + check_postgres_down() + check_expiry() + finally: + subprocess.run( + ['docker', 'compose', '--env-file', '.env', 'start', 'postgres', 'redis'], + cwd=ROOT, + check=False, + ) + print('PASS: grade 4 checks') + return 0 + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/scripts/explain_history.py b/scripts/explain_history.py new file mode 100644 index 00000000..0d7f6ed2 --- /dev/null +++ b/scripts/explain_history.py @@ -0,0 +1,128 @@ +#!/usr/bin/env python3 +"""EXPLAIN (ANALYZE, BUFFERS) for keyset history. Not part of make test. + +Seeds one chat until the default planner uses messages_history_idx, then +deletes that seed. The saved plan contains no tokens. +""" +import os +import subprocess +import sys +import uuid +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[1] +EVIDENCE = ROOT / 'evidence' / 'explain.txt' +SIZES = (10000, 50000, 200000) + + +def psql(sql, tuples_only=False): + command = [ + 'docker', 'compose', '--env-file', '.env', 'exec', '-T', 'postgres', + 'psql', '-U', os.environ.get('POSTGRES_USER', 'messenger'), + '-d', os.environ.get('POSTGRES_DB', 'messenger'), + '-v', 'ON_ERROR_STOP=1', + ] + if tuples_only: + command.append('-tA') + proc = subprocess.run( + command, + cwd=ROOT, + input=sql, + check=False, + capture_output=True, + text=True, + ) + if proc.returncode != 0: + sys.stderr.write(proc.stderr) + raise SystemExit('psql failed') + return proc.stdout + + +def seed(user_id, chat_id, count): + psql( + """ + INSERT INTO messages (id, chat_id, sender_id, text, created_at) + SELECT gen_random_uuid(), + '%(chat)s'::uuid, + '%(user)s'::uuid, + 'm', + timestamptz '2024-01-01 00:00:00+00' + (g * interval '1 microsecond') + FROM generate_series(1, %(count)d) AS g; + ANALYZE messages; + """ % {'chat': chat_id, 'user': user_id, 'count': count} + ) + + +def main(): + user_id = str(uuid.uuid4()) + chat_id = str(uuid.uuid4()) + username = 'u_explain_' + uuid.uuid4().hex[:12] + psql( + """ + INSERT INTO users (id, username, display_name, password_hash, created_at) + VALUES ('%(user)s', '%(name)s', 'Explain', 'not-used-for-login', clock_timestamp()); + INSERT INTO chats (id, title, created_at) + VALUES ('%(chat)s', 'explain-seed', clock_timestamp()); + INSERT INTO chat_members (chat_id, user_id, position) + VALUES ('%(chat)s', '%(user)s', 0); + """ % {'user': user_id, 'chat': chat_id, 'name': username} + ) + plan = '' + used = 0 + try: + for count in SIZES: + seed(user_id, chat_id, count) + used += count + cursor = psql( + """ + SELECT to_char(created_at AT TIME ZONE 'UTC', 'YYYY-MM-DD HH24:MI:SS.US'), id::text + FROM messages + WHERE chat_id = '%s'::uuid + ORDER BY created_at, id + OFFSET 49 + LIMIT 1; + """ % chat_id, + tuples_only=True, + ).strip() + created_at, message_id = cursor.split('|') + plan = psql( + """ + EXPLAIN (ANALYZE, BUFFERS) + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = '%(chat)s'::uuid + AND (created_at, id) > ('%(created)s+00'::timestamptz, '%(message)s'::uuid) + ORDER BY created_at, id + LIMIT 51; + """ % {'chat': chat_id, 'created': created_at, 'message': message_id} + ) + if 'Index Scan using messages_history_idx' in plan or 'Index Only Scan using messages_history_idx' in plan: + break + sys.stderr.write('planner did not pick the history index at %d rows\n' % used) + else: + sys.stderr.write(plan) + raise SystemExit('history query still does not use messages_history_idx') + if 'Seq Scan' in plan.split('Index Scan', 1)[0] and 'messages_history_idx' not in plan.split('Index Scan', 1)[0]: + pass + EVIDENCE.parent.mkdir(exist_ok=True) + EVIDENCE.write_text( + 'rows_in_chat: %d\nquery: keyset page after the 50th message, LIMIT 51\n\n%s' % (used, plan), + encoding='utf-8', + newline='\n', + ) + print('PASS: history index used at %d messages; wrote %s' % (used, EVIDENCE.name)) + finally: + psql( + """ + DELETE FROM messages WHERE chat_id = '%(chat)s'; + DELETE FROM chat_members WHERE chat_id = '%(chat)s'; + DELETE FROM chats WHERE id = '%(chat)s'; + DELETE FROM users WHERE id = '%(user)s'; + """ % {'chat': chat_id, 'user': user_id} + ) + return 0 + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/scripts/restart.sh b/scripts/restart.sh index 8c183c0e..94b7f6a6 100644 --- a/scripts/restart.sh +++ b/scripts/restart.sh @@ -1,5 +1,5 @@ #!/bin/sh set -eu cd "$(dirname "$0")/.." -# Restart the API and PostgreSQL. Named volumes stay; nothing is re-seeded. -docker compose --env-file .env restart api postgres +# Restart the API, PostgreSQL and the session cache. Named volumes stay; nothing is re-seeded. +docker compose --env-file .env restart api postgres redis