Lab2 final implementation and validation
Skeleton contracts / contracts (pull_request) Canceled after 0s

This commit is contained in:
2026-10-16 18:31:22 +03:00
parent 5736aa5f89
commit 56cc687b62
6 changed files with 283 additions and 283 deletions
+46 -129
View File
@@ -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:<token>` с 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.
+128 -151
View File
@@ -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):
+41
View File
@@ -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);
+43
View File
@@ -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()
+12 -3
View File
@@ -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."
+13
View File
@@ -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")