diff --git a/REPORT.md b/REPORT.md index dcde1263..a63b1a21 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,169 +1,86 @@ ## Лабораторная 2 - Автор, группа: Савин Александр БВТ2303 -- Целевая оценка: 5; выбранный трек: 1 -- Commit/PR: локальный рабочий результат в текущем clone, подготовленный к пушу в Gitea -- Использованные источники, библиотеки и помощь ИИ: README проекта, OpenAPI-контракт, FastAPI, Uvicorn, PostgreSQL, Valkey/Redis client, Python 3.13 +- Целевая оценка: 5; выбранный трек: 1 (cache consistency) +- Статус: верифицировано на Colima-backed Docker; smoke, cache consistency и persistence check успешно прошли +- Использованные источники, библиотеки и помощь ИИ: README проекта, OpenAPI-контракт, FastAPI, Uvicorn, PostgreSQL, Valkey/Redis client, Python 3.13, Colima -## Запуск из чистого окружения +## Что исправлено + +- добавлена версия миграции для начальной схемы PostgreSQL; +- кэш и сессии теперь сравниваются с актуальным состоянием в БД, чтобы stale Valkey-entry не считался доверенным токеном; +- пагинация работает по `(created_at, id)` и сохраняет записи при одинаковой временной метке; +- пустые строки после `strip()` запрещены для `display_name`, `title` и `text`; +- добавлены SQL таймауты и миграционная таблица `schema_migrations`; +- добавлен и проверен сценарий короткого TTL recovery после истечения кэша. + +## Проверки, выполненные с Colima ```bash +colima start cd /Users/alexander/Documents/вп/mtusi2026lab2 docker-compose up -d db valkey -``` - -Запуск API в отдельной вкладке терминала: - -```bash -cd /Users/alexander/Documents/вп/mtusi2026lab2 . .venv/bin/activate +DATABASE_URL=postgresql://messenger:messenger@localhost:5432/messenger \ CACHE_URL=redis://localhost:6379/0 \ SESSION_STORE=valkey \ -DATABASE_URL=postgresql://messenger:messenger@localhost:5432/messenger \ SESSION_TTL_SECONDS=3600 \ uvicorn app:app --host 0.0.0.0 --port 8080 -``` - -Проверка: - -```bash +make check +make validate make test +make cache-consistency +ACTION_SCRIPT=scripts/restart.sh make test-persistence ``` -Для очистки состояния и повторного запуска: - -```bash -docker-compose down -v -``` - -Важный момент: API и тесты исполняются в разных терминальных вкладках. При конфликте порта 8080 нужно сначала остановить старый `uvicorn`. - -## Архитектура и решения - -- Источник истины — PostgreSQL. В БД хранятся пользователи, чаты, сообщения и сессии. -- Кэш — Valkey. В кэше держится `session:` с TTL. Это делает cache layer контролируемым и временным, а не единственным хранилищем. -- Пароли хранятся в виде Argon2 hash. -- Basic auth используется для входа и создания токена сессии. -- Bearer auth используется для доступа к защищённым endpoint. -- При logout токен отзывается, а кэшовая запись удаляется. -- Ожидание stale cache: если кэш указывает на устаревший или поддельный токен, приложение не должно доверять ему и должно отклонить запрос или проверить источник истины. -- API-слой оформлен в соответствии с OpenAPI 3.1 и JSON Schema. -- Реализация покрывает весь минимальный уровень lab2 и дополнительно выбранный трек 1 по согласованности кэша. - -## Доказательства критериев - -| Критерий README | Команда / сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Public smoke test | `make test` | PASS: лабораторный сценарий успешно пройден | stdout команды `make test` | -| OpenAPI validation | `make validate` | PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested | stdout команды `make validate` | -| Cache consistency | `make cache-consistency` | `cache_key_exists=True`, `ttl_seconds=3599`, `stale_cache_rejected=True`, `logout_revokes_cache=True` | stdout команды `make cache-consistency` | -| Источник истины и кэш | PostgreSQL + Valkey | Данные живут в БД, кэш хранит только временные session snapshots | лог запуска и тесты | - -## Проверки и свежие результаты - -### 1. Smoke test - -Команда: - -```bash -cd /Users/alexander/Documents/вп/mtusi2026lab2 && . .venv/bin/activate && make test -``` - -Вывод: +Результат smoke: ```text python3 tests/smoke.py --base-url "http://localhost:8080" PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. ``` -### 2. OpenAPI validation - -Команда: - -```bash -cd /Users/alexander/Documents/вп/mtusi2026lab2 && . .venv/bin/activate && make validate -``` - -Вывод: - -```text -python3 scripts/validate_openapi.py -PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested. -``` - -### 3. Cache consistency proof - -Команда: - -```bash -cd /Users/alexander/Documents/вп/mtusi2026lab2 && . .venv/bin/activate && make cache-consistency -``` - -Вывод: +Результат cache consistency: ```text python3 tests/cache_consistency.py cache_key_exists=True ttl_seconds=3599 -avg_latency_ms=11.44 -p95_latency_ms=12.35 +avg_latency_ms=15.33 +p95_latency_ms=15.63 stale_cache_rejected=True +short_ttl_recovers_from_db=True logout_revokes_cache=True ``` -## Таблица результатов по уровню 5 +Результат persistence: -| Проверка | Ожидание | Факт | Статус | -| --- | --- | --- | --- | -| В кеше существует session key | есть запись для токена | `cache_key_exists=True` | PASS | -| TTL работает | запись истекает по таймауту | `ttl_seconds=3599` | PASS | -| Stale cache не принимается | старые данные не должны использоваться | `stale_cache_rejected=True` | PASS | -| Logout отменяет сессию | запись удаляется и запросы с токеном отклоняются | `logout_revokes_cache=True` | PASS | -| Latency | запросы выполняются быстро | `avg_latency_ms=11.44`, `p95_latency_ms=12.35` | PASS | - -## Эксперимент и вывод по треку 1 (cache consistency) - -### Гипотеза -Если в Valkey лежит stale или поддельный payload, сервис не должен доверять кэшу и должен либо отозвать сессию, либо проверить источник истины в PostgreSQL. - -### Методика -1. Создать пользователя и получить Bearer токен. -2. Проверить, что токен сохраняется в Valkey с TTL. -3. Сымитировать stale payload. -4. Выполнить запрос к защищённому endpoint и проверить отклонение. -5. Выполнить logout и убедиться, что кэш-ключ удалён. -6. Подтвердить, что запросы с отозванным токеном возвращают 401. - -### Результат - -Проверка подтверждает, что stale cache и logout корректно обрабатываются. Это соответствует требованиям уровня 5 и обеспечивает устойчивость аутентификации при падении/конфликте кэша. - -Дополнительно была исправлена пагинация сообщений: курсор теперь корректно работает по `(created_at, id)` и связан с конкретным чатом, что закрывает публичный smoke test и устраняет повторяющуюся ошибку "second page must finish history". - -## Ограничения - -- PostgreSQL остаётся источником истины; Valkey выполняет роль кэша, а не единственного хранилища. -- Полный stress benchmark на очень большие объёмы не выполнялся; здесь подтверждён корректный и проверяемый уровень 5, а не большой production benchmark. - -## Вывод - -Лабораторная работа 2 выполнена в полном объёме: PostgreSQL задействован как реальный источник данных, Valkey используется как TTL-кэш сессий, аутентификация реализована по Basic/Bearer, а выбранный трек 1 по cache consistency подтверждён на живом стенде. Все ключевые проверки проходят: public smoke test, OpenAPI validation и проверка корректности кэша. - -```bash -lsof -t -i :8080 | xargs kill -9 +```text +python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080" +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. ``` +## SQL evidence по индексу и пагинации + +Команда: + ```bash cd /Users/alexander/Documents/вп/mtusi2026lab2 . .venv/bin/activate -CACHE_URL=redis://localhost:6379/0 \ -SESSION_STORE=valkey \ -DATABASE_URL=postgresql://messenger:messenger@localhost:5432/messenger \ -SESSION_TTL_SECONDS=3600 \ -uvicorn app:app --host 0.0.0.0 --port 8080 +python3 scripts/explain_pagination.py | head -n 40 ``` -```bash -curl -s http://localhost:8080/health/live -curl -s http://localhost:8080/health/ready +Фрагмент вывода: + +```text +Limit (cost=0.29..4.59 rows=1 width=88) (actual time=0.005..0.005 rows=0 loops=1) + Buffers: shared hit=2 + -> Index Scan using idx_messages_chat_created on messages (cost=0.29..60.56 rows=14 width=88) (actual time=0.005..0.005 rows=0 loops=1) + Index Cond: ((chat_id = '...'::uuid) AND (ROW(created_at, id) > ROW('2100-01-01 00:00:00+00'::timestamp with time zone, '...'::uuid))) ``` + +Это подтверждает, что запрос идёт через индекс по `(chat_id, created_at, id)`, а не через полный scan всей истории чата. + +## Вывод + +На Colima-backed Docker инфраструктуре фактический жизненный сценарий приложения подтверждён: public smoke test, проверка stale cache/logout, короткий TTL recovery и persistence restart успешно прошли. Это подтверждает корректность PostgreSQL-backed persistence, Valkey TTL-кэша и аутентификации в рамках требований лабораторной работы 2. diff --git a/app.py b/app.py index 50b47b1e..370c4333 100644 --- a/app.py +++ b/app.py @@ -6,6 +6,7 @@ import os import secrets import uuid from datetime import datetime, timedelta, timezone +from pathlib import Path from typing import Any, Dict, List, Optional, Tuple import psycopg @@ -120,7 +121,12 @@ class Store: return os.getenv("DEFAULT_CACHE_URL", "redis://localhost:6379/0") def connect(self): - return psycopg.connect(self.connection_url, connect_timeout=5, autocommit=False) + return psycopg.connect( + self.connection_url, + connect_timeout=5, + autocommit=False, + options="-c statement_timeout=5000 -c lock_timeout=500", + ) def cache_client(self): return redis.Redis.from_url(self.cache_url, decode_responses=True, socket_connect_timeout=2, socket_timeout=2) @@ -142,7 +148,7 @@ class Store: except redis.RedisError: return - def get_cached_session(self, token: str) -> Optional[Dict[str, Any]]: + def get_cached_session(self, token: str, *, conn=None) -> Optional[Dict[str, Any]]: if self.session_store != "valkey": return None try: @@ -161,6 +167,14 @@ class Store: if not self.is_session_valid(session): client.delete(f"session:{token}") return None + if conn is None: + with self.connect() as db_conn: + db_session = self.fetch_session_by_token(token, db_conn) + else: + db_session = self.fetch_session_by_token(token, conn) + if db_session is None or not self.is_session_valid(db_session): + client.delete(f"session:{token}") + return None return session except (redis.RedisError, TypeError, ValueError): return None @@ -182,79 +196,40 @@ class Store: raise ValueError("invalid session expiry") def init(self) -> None: + migration_dir = Path(__file__).resolve().parent / "migrations" with self.connect() as conn: with conn.cursor() as cur: cur.execute( """ - CREATE TABLE IF NOT EXISTS users ( - id UUID PRIMARY KEY, - username TEXT NOT NULL UNIQUE, - display_name TEXT NOT NULL, - password_hash TEXT NOT NULL, - created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() + CREATE TABLE IF NOT EXISTS schema_migrations ( + version TEXT PRIMARY KEY, + applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW() ); """ ) - cur.execute( - """ - CREATE TABLE IF NOT EXISTS chats ( - id UUID PRIMARY KEY, - title TEXT NOT NULL, - created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() - ); - """ - ) - cur.execute( - """ - CREATE TABLE IF NOT EXISTS chat_members ( - chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, - user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, - PRIMARY KEY (chat_id, user_id) - ); - """ - ) - cur.execute( - """ - CREATE TABLE IF NOT EXISTS messages ( - id UUID PRIMARY KEY, - chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, - sender_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, - text TEXT NOT NULL, - created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() - ); - """ - ) - cur.execute( - """ - CREATE TABLE IF NOT EXISTS sessions ( - id UUID PRIMARY KEY, - token TEXT NOT NULL UNIQUE, - user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, - expires_at TIMESTAMPTZ NOT NULL, - revoked_at TIMESTAMPTZ, - created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() - ); - """ - ) - cur.execute( - "CREATE INDEX IF NOT EXISTS idx_messages_chat_created ON messages(chat_id, created_at, id);" - ) - cur.execute( - "CREATE INDEX IF NOT EXISTS idx_chat_members_user ON chat_members(user_id, chat_id);" - ) - cur.execute( - "CREATE INDEX IF NOT EXISTS idx_chats_created ON chats(created_at, id);" - ) - cur.execute( - "CREATE INDEX IF NOT EXISTS idx_sessions_user ON sessions(user_id, expires_at);" - ) + + applied = set() + cur.execute("SELECT version FROM schema_migrations") + for (version,) in cur.fetchall(): + applied.add(version) + + for migration_path in sorted(migration_dir.glob("*.sql")): + version = migration_path.stem + if version in applied: + continue + sql = migration_path.read_text(encoding="utf-8") + cur.execute(sql) + cur.execute( + "INSERT INTO schema_migrations(version, applied_at) VALUES (%s, %s)", + (version, self.utc_now()), + ) conn.commit() def utc_now(self) -> datetime: return datetime.now(timezone.utc) def isoformat_utc(self, value: datetime) -> str: - return value.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ") + return value.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z") def hash_password(self, password: str) -> str: return self.password_hasher.hash(password) @@ -293,6 +268,28 @@ class Store: "created_at": self.isoformat_utc(row[3]), } + def fetch_session_by_token(self, token: str, conn): + with conn.cursor() as cur: + cur.execute( + "SELECT s.token, s.user_id, s.expires_at, s.revoked_at, u.id, u.username, u.display_name, u.created_at FROM sessions s JOIN users u ON u.id = s.user_id WHERE s.token = %s", + (token,), + ) + row = cur.fetchone() + if row is None: + return None + return { + "token": row[0], + "user_id": str(row[1]), + "expires_at": self.isoformat_utc(row[2]), + "revoked_at": row[3], + "user": { + "id": str(row[4]), + "username": row[5], + "display_name": row[6], + "created_at": self.isoformat_utc(row[7]), + }, + } + def list_member_ids(self, chat_id: str, conn) -> List[str]: with conn.cursor() as cur: cur.execute("SELECT user_id FROM chat_members WHERE chat_id = %s ORDER BY user_id", (chat_id,)) @@ -383,19 +380,40 @@ class Store: "created_at": self.isoformat_utc(now), } + @staticmethod + def cursor_uuid_key(value: str) -> int: + try: + return uuid.UUID(value).int + except (ValueError, TypeError): + return 0 + def list_chats_for_user(self, user_id: str, limit: int, cursor: Optional[str]): with self.connect() as conn: with conn.cursor() as cur: - cur.execute( - """ + query = """ SELECT c.id, c.title, c.created_at FROM chats c JOIN chat_members cm ON cm.chat_id = c.id WHERE cm.user_id = %s - ORDER BY c.created_at ASC, c.id ASC - """, - (user_id,), - ) + """ + params: List[Any] = [user_id] + if cursor: + prefix = f"user:{user_id}|" + if not cursor.startswith(prefix): + raise ApiError(400, "invalid_request", "cursor does not match user chat list") + remainder = cursor[len(prefix):] + if not remainder: + raise ApiError(400, "invalid_request", "invalid cursor") + try: + cursor_ts_raw, cursor_id = remainder.split("|", 1) + cursor_dt = datetime.fromisoformat(cursor_ts_raw.replace("Z", "+00:00")).astimezone(timezone.utc) + except ValueError as exc: + raise ApiError(400, "invalid_request", "invalid cursor") from exc + query += " AND (c.created_at > %s OR (c.created_at = %s AND c.id > %s::uuid))" + params.extend([cursor_dt, cursor_dt, cursor_id]) + query += " ORDER BY c.created_at ASC, c.id ASC LIMIT %s" + params.append(limit + 1) + cur.execute(query, tuple(params)) rows = cur.fetchall() items = [ { @@ -407,42 +425,36 @@ class Store: for row in rows ] - start_index = 0 - if cursor: - prefix = f"user:{user_id}|" - if not cursor.startswith(prefix): - raise ApiError(400, "invalid_request", "cursor does not match user chat list") - remainder = cursor[len(prefix):] - if not remainder: - raise ApiError(400, "invalid_request", "invalid cursor") - try: - cursor_ts_raw, cursor_id = remainder.split("|", 1) - cursor_dt = datetime.fromisoformat(cursor_ts_raw.replace("Z", "+00:00")) - except ValueError as exc: - raise ApiError(400, "invalid_request", "invalid cursor") from exc - for idx, item in enumerate(items): - item_dt = datetime.fromisoformat(item["created_at"].replace("Z", "+00:00")) - if (item_dt, item["id"]) > (cursor_dt.astimezone(timezone.utc), cursor_id): - start_index = idx - break - else: - start_index = len(items) - - page = items[start_index:start_index + limit] next_cursor = None - if start_index + limit < len(items): - last_item = page[-1] + if len(items) > limit: + last_item = items[limit - 1] next_cursor = f"user:{user_id}|{last_item['created_at']}|{last_item['id']}" + items = items[:limit] - return {"items": page, "next_cursor": next_cursor} + return {"items": items, "next_cursor": next_cursor} def list_messages_for_chat(self, chat_id: str, limit: int, cursor: Optional[str]): with self.connect() as conn: with conn.cursor() as cur: - cur.execute( - "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = %s ORDER BY created_at ASC, id ASC", - (chat_id,), - ) + query = "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = %s" + params: List[Any] = [chat_id] + if cursor: + prefix = f"chat:{chat_id}|" + if not cursor.startswith(prefix): + raise ApiError(400, "invalid_request", "cursor does not match chat") + remainder = cursor[len(prefix):] + if not remainder: + raise ApiError(400, "invalid_request", "invalid cursor") + try: + cursor_ts_raw, cursor_id = remainder.split("|", 1) + cursor_dt = datetime.fromisoformat(cursor_ts_raw.replace("Z", "+00:00")).astimezone(timezone.utc) + except ValueError as exc: + raise ApiError(400, "invalid_request", "invalid cursor") from exc + query += " AND (created_at > %s OR (created_at = %s AND id > %s::uuid))" + params.extend([cursor_dt, cursor_dt, cursor_id]) + query += " ORDER BY created_at ASC, id ASC LIMIT %s" + params.append(limit + 1) + cur.execute(query, tuple(params)) rows = cur.fetchall() items = [{ @@ -453,34 +465,13 @@ class Store: "created_at": self.isoformat_utc(row[4]), } for row in rows] - start_index = 0 - if cursor: - prefix = f"chat:{chat_id}|" - if not cursor.startswith(prefix): - raise ApiError(400, "invalid_request", "cursor does not match chat") - remainder = cursor[len(prefix):] - if not remainder: - raise ApiError(400, "invalid_request", "invalid cursor") - try: - cursor_ts_raw, cursor_id = remainder.split("|", 1) - cursor_dt = datetime.fromisoformat(cursor_ts_raw.replace("Z", "+00:00")) - except ValueError as exc: - raise ApiError(400, "invalid_request", "invalid cursor") from exc - for idx, item in enumerate(items): - item_dt = datetime.fromisoformat(item["created_at"].replace("Z", "+00:00")) - if (item_dt, item["id"]) > (cursor_dt.astimezone(timezone.utc), cursor_id): - start_index = idx - break - else: - start_index = len(items) - - page = items[start_index:start_index + limit] next_cursor = None - if start_index + limit < len(items): - last_item = page[-1] + if len(items) > limit: + last_item = items[limit - 1] next_cursor = f"chat:{chat_id}|{last_item['created_at']}|{last_item['id']}" + items = items[:limit] - return {"items": page, "next_cursor": next_cursor} + return {"items": items, "next_cursor": next_cursor} def create_session(self, user_id: str, username: str): token = secrets.token_urlsafe(32) @@ -511,37 +502,18 @@ class Store: } def get_session_by_token(self, token: str, conn=None): - cached = self.get_cached_session(token) - if cached is not None: - return cached - should_close = conn is None conn = conn or self.connect() try: - with conn.cursor() as cur: - cur.execute( - "SELECT s.token, s.user_id, s.expires_at, s.revoked_at, u.id, u.username, u.display_name, u.created_at FROM sessions s JOIN users u ON u.id = s.user_id WHERE s.token = %s", - (token,), - ) - row = cur.fetchone() - if row is None: + db_session = self.fetch_session_by_token(token, conn) + if db_session is None or not self.is_session_valid(db_session): + self.delete_cached_session(token) return None - session = { - "token": row[0], - "user_id": str(row[1]), - "expires_at": self.isoformat_utc(row[2]), - "revoked_at": row[3], - "user": { - "id": str(row[4]), - "username": row[5], - "display_name": row[6], - "created_at": self.isoformat_utc(row[7]), - }, - } - if not self.is_session_valid(session): - return None - self.cache_session(session) - return session + cached = self.get_cached_session(token, conn=conn) + if cached is not None: + return cached + self.cache_session(db_session) + return db_session finally: if should_close: conn.close() @@ -669,8 +641,9 @@ async def create_user_endpoint(request: Request): payload = CreateUserIn.model_validate(body) except ValidationError as exc: raise ApiError(400, "invalid_request", "invalid user payload") from exc - if not payload.username or not payload.display_name: + if not payload.username or not payload.display_name.strip(): raise ApiError(400, "invalid_request", "invalid request") + payload.display_name = payload.display_name.strip() try: user = store.insert_user(payload.username, payload.display_name, payload.password) return UserOut.model_validate(user) @@ -741,6 +714,9 @@ async def create_chat_endpoint(request: Request): raise ApiError(400, "invalid_request", "invalid chat payload") from exc if len(payload.member_ids) < 1 or len(payload.member_ids) > 100: raise ApiError(400, "invalid_request", "invalid member_ids") + title = payload.title.strip() + if not title: + raise ApiError(400, "invalid_request", "invalid title") normalized = [] seen = set() for member_id in payload.member_ids: @@ -761,7 +737,7 @@ async def create_chat_endpoint(request: Request): cur.execute("SELECT id FROM users WHERE id = %s", (member_id,)) if cur.fetchone() is None: raise ApiError(400, "invalid_request", "unknown member") - chat = store.insert_chat(payload.title.strip(), normalized, session["user_id"]) + chat = store.insert_chat(title, normalized, session["user_id"]) return ChatOut.model_validate(chat) except ApiError: raise @@ -817,6 +793,7 @@ async def create_message(request: Request, chat_id: str): raise ApiError(400, "invalid_request", "invalid message payload") from exc if not payload.text.strip(): raise ApiError(400, "invalid_request", "invalid text") + payload.text = payload.text.strip() with store.connect() as conn: chat = store.fetch_chat(chat_id, conn) if chat is None or not store.fetch_chat_membership(chat_id, session["user_id"], conn): diff --git a/migrations/001_initial_schema.sql b/migrations/001_initial_schema.sql new file mode 100644 index 00000000..74371785 --- /dev/null +++ b/migrations/001_initial_schema.sql @@ -0,0 +1,41 @@ +CREATE TABLE IF NOT EXISTS users ( + id UUID PRIMARY KEY, + username TEXT NOT NULL UNIQUE, + display_name TEXT NOT NULL, + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE TABLE IF NOT EXISTS chats ( + id UUID PRIMARY KEY, + title TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE TABLE IF NOT EXISTS chat_members ( + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + PRIMARY KEY (chat_id, user_id) +); + +CREATE TABLE IF NOT EXISTS messages ( + id UUID PRIMARY KEY, + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + sender_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + text TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE TABLE IF NOT EXISTS sessions ( + id UUID PRIMARY KEY, + token TEXT NOT NULL UNIQUE, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + expires_at TIMESTAMPTZ NOT NULL, + revoked_at TIMESTAMPTZ, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE INDEX IF NOT EXISTS idx_messages_chat_created ON messages(chat_id, created_at, id); +CREATE INDEX IF NOT EXISTS idx_chat_members_user ON chat_members(user_id, chat_id); +CREATE INDEX IF NOT EXISTS idx_chats_created ON chats(created_at, id); +CREATE INDEX IF NOT EXISTS idx_sessions_user ON sessions(user_id, expires_at); diff --git a/scripts/explain_pagination.py b/scripts/explain_pagination.py new file mode 100644 index 00000000..df4a8927 --- /dev/null +++ b/scripts/explain_pagination.py @@ -0,0 +1,43 @@ +#!/usr/bin/env python3 +"""Produce an EXPLAIN (ANALYZE, BUFFERS) proof for the chat-history cursor query.""" +import os +import uuid + +import psycopg + +DB_URL = os.getenv("DATABASE_URL", "postgresql://messenger:messenger@localhost:5432/messenger") + + +def main() -> None: + with psycopg.connect(DB_URL, connect_timeout=5) as conn: + with conn.cursor() as cur: + chat_id = uuid.uuid4() + user_id = uuid.uuid4() + cur.execute("INSERT INTO users(id, username, display_name, password_hash, created_at) VALUES (%s, %s, %s, %s, NOW())", (user_id, f"exp_{uuid.uuid4().hex[:12]}", "exp", "dummyhash")) + cur.execute("INSERT INTO chats(id, title, created_at) VALUES (%s, %s, NOW())", (chat_id, "exp")) + cur.execute("INSERT INTO chat_members(chat_id, user_id) VALUES (%s, %s)", (chat_id, user_id)) + for idx in range(10000): + cur.execute( + "INSERT INTO messages(id, chat_id, sender_id, text, created_at) VALUES (%s, %s, %s, %s, NOW() - INTERVAL '%s milliseconds')", + (uuid.uuid4(), chat_id, user_id, f"msg-{idx}", idx), + ) + conn.commit() + + cursor_ts = "2100-01-01T00:00:00Z" + cursor_id = str(uuid.uuid4()) + explain_sql = """ + EXPLAIN (ANALYZE, BUFFERS) + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = %s + AND (created_at, id) > (%s::timestamptz, %s::uuid) + ORDER BY created_at ASC, id ASC + LIMIT 1 + """ + cur.execute(explain_sql, (chat_id, cursor_ts, cursor_id)) + plan = cur.fetchall() + + print("\n".join(row[0] for row in plan)) + +if __name__ == "__main__": + main() diff --git a/scripts/restart.sh b/scripts/restart.sh index 3e91eb48..a9cb0be8 100755 --- a/scripts/restart.sh +++ b/scripts/restart.sh @@ -2,8 +2,17 @@ set -euo pipefail cd "$(dirname "$0")/.." -docker compose --env-file .env up -d --no-deps --force-recreate app db valkey >/dev/null 2>&1 || { - docker compose up -d --no-deps --force-recreate app db valkey -} +if docker compose version >/dev/null 2>&1; then + docker compose --env-file .env up -d --no-deps --force-recreate app db valkey >/dev/null 2>&1 || { + docker compose up -d --no-deps --force-recreate app db valkey + } +elif command -v docker-compose >/dev/null 2>&1; then + docker-compose --env-file .env up -d --no-deps --force-recreate app db valkey >/dev/null 2>&1 || { + docker-compose up -d --no-deps --force-recreate app db valkey + } +else + echo "Neither docker compose nor docker-compose is available." >&2 + exit 127 +fi echo "Restarted app, postgres and valkey with persisted volumes." diff --git a/tests/cache_consistency.py b/tests/cache_consistency.py index 81749e5b..68340a93 100644 --- a/tests/cache_consistency.py +++ b/tests/cache_consistency.py @@ -91,6 +91,18 @@ def main(): assert stale_result["status"] == 200, stale_result assert stale_result["body"]["username"] == username, stale_result + r.setex(key, 1, json.dumps({ + "token": token, + "user_id": str(uuid.uuid4()), + "expires_at": "2100-01-01T00:00:00Z", + "revoked_at": None, + "user": {"id": str(uuid.uuid4()), "username": "ttl-recovery", "display_name": "ttl-recovery", "created_at": "2020-01-01T00:00:00Z"}, + }, separators=(",", ":"), ensure_ascii=False)) + time.sleep(2) + short_ttl = http_json("GET", "/api/v1/users/me", expected=200, headers={"Authorization": "Bearer " + token}) + assert short_ttl["status"] == 200, short_ttl + assert short_ttl["body"]["username"] == username, short_ttl + revoke = http_json("DELETE", "/api/v1/auth/sessions/current", expected=204, headers={"Authorization": "Bearer " + token}) assert revoke["status"] == 204, revoke assert not r.get(key), "revoked session key should be deleted from cache" @@ -103,6 +115,7 @@ def main(): print(f"avg_latency_ms={avg:.2f}") print(f"p95_latency_ms={p95:.2f}") print("stale_cache_rejected=True") + print("short_ttl_recovers_from_db=True") print("logout_revokes_cache=True")