level 4: redis cache etc

This commit is contained in:
2026-10-26 17:50:20 +03:00
parent 9d3de3b2d9
commit 175a8d8bfd
14 changed files with 686 additions and 78 deletions
+4 -2
View File
@@ -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
+20 -15
View File
@@ -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)` совпадают.
+70
View File
@@ -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()
+10 -8
View File
@@ -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'),
)
+1
View File
@@ -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')
+7 -2
View File
@@ -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:
+87 -48
View File
@@ -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:
+16 -1
View File
@@ -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
+16
View File
@@ -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)
+31
View File
@@ -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.
+1
View File
@@ -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
+293
View File
@@ -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())
+128
View File
@@ -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())
+2 -2
View File
@@ -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