diff --git a/.env.example b/.env.example index 2291af6e..21bec36e 100644 --- a/.env.example +++ b/.env.example @@ -18,3 +18,6 @@ POSTGRES_DB=messenger SESSION_STORE=postgres # Compose injects REDIS_URL. When set, this file wins and is not logged. # CACHE_URL_FILE=/run/secrets/cache_url +# First history page. protected is the default: the page key includes the chat version. +# naive and off exist only to measure the track-1 race and must not stay in .env. +# HISTORY_CACHE=protected diff --git a/REPORT.md b/REPORT.md index dafbc3c5..38142f9f 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,7 +1,7 @@ # Отчёт — лабораторная 2 - Автор, группа: Тимаева М.П. БПИ2302 -- Целевая оценка; выбранный трек 5, если нужен: 4 +- Целевая оценка; выбранный трек 5, если нужен: 5, трек 1 - Commit/PR: TODO после публикации - Использованные источники, библиотеки и помощь ИИ: контракт и README этой лабораторной; PostgreSQL transactions и EXPLAIN; RFC 7617; библиотеки fastapi, uvicorn, asyncpg 0.32.0, redis 8.1.0, argon2-cffi 25.1.0. Реализацию помог собрать агент Cursor. @@ -27,6 +27,7 @@ chmod +x scripts/restart.sh make test-persistence ACTION_SCRIPT=scripts/restart.sh python scripts/check_grade4.py python scripts/explain_history.py +python scripts/track1_cache.py ``` `scripts/restart.sh` перезапускает `api`, `postgres` и `redis`, без `down -v`. На Windows `python` не может запустить этот файл через CreateProcess (`WinError 193`). На этой машине публичный harness был выполнен в контейнере `docker:28-cli` с `python3`, в сети compose и с Docker socket. Подробности в `evidence/grade4.txt`. @@ -35,15 +36,19 @@ python scripts/explain_history.py ## Архитектура и решения -Клиент ходит в один процесс API. Источник истины для пользователей, чатов, сообщений и сессий — PostgreSQL, named volume `pgdata`. Redis 7.4 — кэш поиска сессии: ключ `session:{sha256 токена}`, значение — `expires_at`. Сырой токен и hash пароля в Redis не пишутся. TTL ключа равен остатку до `expires_at` и чтением не продлевается. Промах или недоступный Redis не заменяют строку PostgreSQL: личность подтверждается только ею. Logout сначала удаляет строку, затем ключ. После рестарта Redis пуст, и тот же токен находится в PostgreSQL, поэтому отдельная persistence Redis не нужна. +Клиент ходит в один процесс API. Источник истины для пользователей, чатов, сообщений и сессий — PostgreSQL, named volume `pgdata`. Redis 7.4 кэширует поиск сессии и первую страницу истории. Ключ сессии — `session:{sha256 токена}`, значение — `expires_at`. Сырой токен и hash пароля в Redis не пишутся. TTL ключа равен остатку до `expires_at` и чтением не продлевается. Промах или недоступный Redis не заменяют строку PostgreSQL: личность подтверждается только ею. Logout сначала удаляет строку, затем ключ. -Таблицы `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)`). +Первая страница `GET /messages` без cursor при `limit=50` лежит в ключе `history:{chat_id}:{history_version}`. Колонка `chats.history_version` увеличивается в той же транзакции, что и `INSERT` сообщения, и публикуется в Redis до ответа 201. Чтение, которое начинается после 201, видит новую версию и не читает страницу предыдущей. Гонка «SELECT успел выполниться до commit и записал старую страницу» публикует её только под старой версией. TTL страницы 30 с снимает брошенные ключи и не отвечает за свежесть. Страницы с cursor всегда идут в SQL. Пока один промах выполняет SELECT, остальные запросы того же процесса ждут тот же результат (singleflight на asyncio future). `HISTORY_CACHE=naive` пишет страницу в ключ без версии и не сбрасывает её при записи; `off` не кэширует историю. Оба режима только для измерения, обычный `docker compose up` оставляет `protected`. + +Redis запущен как `redis-server --save "" --appendonly no` и без своего volume. Рестарт контейнера поднимает пустой кэш. После этого сессия читается из PostgreSQL, а история — тоже из PostgreSQL, пока страница снова не попадёт в кэш. + +Таблицы `migrations/001_init.sql`: `users` (UNIQUE username), `sessions` (PK — SHA-256 токена, FK на пользователя, `expires_at`), `chats`, `chat_members` (PK пары, оба FK, `position`), `messages` (FK на чат и отправителя), `schema_migrations`. `migrations/002_chat_version.sql` добавляет `chats.history_version bigint NOT NULL DEFAULT 0`. Индекс `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`. Та же 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` и `REDIS_URL` задаёт compose; `DATABASE_URL_FILE` и `CACHE_URL_FILE` — необязательные замены. `SESSION_STORE=postgres` означает, что строка сессии живёт в PostgreSQL, а Redis только кэширует поиск. +Переменные: `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 только кэширует поиск. `HISTORY_CACHE` по умолчанию `protected`. Из lab1 сохранены пользователи, чаты, членство, сообщения и keyset-пагинация. Идентификация lab1 (`X-User-Id`) заменена на пароль, Basic и Bearer. @@ -55,26 +60,47 @@ python scripts/explain_history.py | Данные и сессия переживают рестарт 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 | +| Кэш первой страницы истории | `python scripts/track1_cache.py`, один чат, `limit=50`, без другой нагрузки на `messages` | naive: 8 из 8 чтений после 201 без нового сообщения; 32 холодных GET → 32 скана. off: 20 GET → 20 сканов. protected: 0 из 8 пропусков; 32 GET → 1 скан; 20 тёплых → 0 сканов, p50 5.786 мс против 8.519 мс у холодного промаха. Рестарт Redis: сообщение на месте, сканы 1 затем 0, сессия 200 | evidence/track1.json | | Повтор миграций не дублирует данные | второй `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 | | Недоступная БД | `docker compose stop postgres`, затем start | `/health/live` 200, `/health/ready` 503 `unavailable` без SQL | evidence/grade3.txt | | Секреты вне Git | `git check-ignore -v .env` | `.gitignore:2:.env` | — | -`make check` эквивалентен `python scripts/check_contract.py` и тоже PASS. Контракт и публичные тесты не менялись. +`make check` эквивалентен `python scripts/check_contract.py` и тоже PASS. Контракт и публичные тесты не менялись. После трека 1 заново прогнаны smoke (PASS) и persistence (PASS). ID после этого рестарта: api `1538b7d21085`, postgres `cbe7139645a5`, redis `c6a09b1c7977`. Volume `mtusi2026lab2-fork_pgdata` на месте. `HISTORY_CACHE` в контейнере `protected`, в `.env` этой переменной нет, `SESSION_TTL_SECONDS` 3600. ## Эксперименты и отказы -Отдельного нагрузочного эксперимента нет. EXPLAIN снят на 10 000 сообщениях одного чата: вторая страница keyset, `LIMIT 51`, выполнение 0.363 мс, прочитаны 4 страницы буфера. +Гипотеза трека 1: без версии чата чтение, начатое после уже подтверждённой записи, может получить первую страницу без этого сообщения; версия в ключе убирает такое чтение; singleflight на холодном ключе сводит SELECT истории к одному; тёплая страница не трогает `messages` и короче холодного промаха. + +Методика. Один чат, один и тот же `GET /messages?limit=50`, стенд без другой нагрузки на `messages`. Счётчик — дельта `idx_scan + seq_scan` из `pg_stat_user_tables` для `messages`. PostgreSQL публикует эти числа при завершении backend, поэтому скрипт после каждого окна завершает соединения пула и только потом читает статистику. p50 считается по успешным GET на клиенте. В `naive` процесс держит заполнение страницы 200 мс, чтобы 32 промаха успели открыть свой SELECT; в `protected` и `off` этой паузы нет. Скрипт сам переключает `HISTORY_CACHE`, пересоздаёт только API и в `finally` возвращает прежний `.env`. + +| Режим | Наблюдение | Сканы `messages` | p50, мс | +| --- | --- | --- | --- | +| naive, 8 GET, каждый начат после 201 | все 8 без нового сообщения | — | — | +| naive, 32 одновременных GET по холодному ключу | отдельный SELECT на клиента | 32 | 343.766, внутри пауза записи 200 мс | +| off, 20 последовательных GET | кэша нет, каждый GET читает SQL | 20 | 4.950 | +| protected, 8 GET, каждый начат после 201 | новое сообщение есть в каждом | — | — | +| protected, 32 одновременных GET по холодному ключу | один SELECT на всех | 1 | 160.808 | +| protected, холодный промах по одному | страница строится заново | — | 8.519 | +| protected, 20 GET по тёплой странице | таблица `messages` не читается | 0 | 5.786 | +| `docker compose restart redis`, PostgreSQL жив | сообщение на месте; первое чтение — промах, второе — попадание; `GET /users/me` → 200 | 1, затем 0 | — | + +Тёплое попадание (5.786 мс) короче холодного промаха (8.519 мс). Один короткий index scan в режиме off дал 4.950 мс: на этом стенде два обращения к Redis близки по времени к одному такому SELECT. Выигрыш тёплой страницы здесь — ноль сканов `messages`. + +EXPLAIN снят на 10 000 сообщениях одного чата: вторая страница keyset, `LIMIT 51`, выполнение 0.363 мс, прочитаны 4 страницы буфера. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | | `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 не удалялся | +| `docker compose restart redis` при живом PostgreSQL | Подтверждённое сообщение остаётся, первое чтение истории идёт в SQL, следующее берётся из кэша, сессия жива | Сообщение на месте, сканы `messages` 1 затем 0, сессия 200 | Кэш после рестарта пуст, потому что RDB и AOF выключены и volume нет. Строки PostgreSQL не пропадали | ## Ограничения и следующие шаги -Один процесс API и одна БД. Потеря Docker-хоста уничтожает и API, и PostgreSQL. Redis не хранит сессию сам по себе: после очистки кэша доступна только строка в PostgreSQL, а пока БД недоступна, кэш не принимается за личность. Пул ограничен 10 соединениями и таймаутом 5 с. Идемпотентность и вторая реплика — лабораторная 3 курса. Оценка 5 (согласованность кэша под гонкой или эксперимент на ≥100 000 сообщений с backup) не делалась. +Один процесс API и одна БД. Потеря Docker-хоста уничтожает и API, и PostgreSQL. Redis не хранит сессию сам по себе: после очистки кэша доступна только строка в PostgreSQL, а пока БД недоступна, кэш не принимается за личность. Пул ограничен 10 соединениями и таймаутом 5 с. Идемпотентность и вторая реплика — лабораторная 3 курса. + +Singleflight действует внутри одного процесса. Страницы с cursor не кэшируются. Дельта `pg_stat_user_tables` верна, пока во время окна нет другой нагрузки на `messages`. TTL 30 с не заменяет версию в ключе. Пауза 200 мс есть только в `naive`, чтобы одновременные промахи наложились; она входит в p50 этого режима. На этом стенде один index scan короче двух чтений Redis, поэтому тёплый кэш выигрывает числом SQL, а не каждым миллисекундом относительно `off`. Учебное упрощение: время сообщения монотонно только внутри одного процесса. Процесс один, поэтому порядок записи и `(created_at, id)` совпадают. diff --git a/app/cache.py b/app/cache.py index 3ad5c136..4e61cca9 100644 --- a/app/cache.py +++ b/app/cache.py @@ -1,4 +1,4 @@ -"""Session lookup cache. PostgreSQL remains the source of truth.""" +"""Lookup cache for sessions and the first history page. PostgreSQL remains the source of truth.""" import logging from datetime import datetime, timezone from typing import Optional @@ -8,6 +8,8 @@ from redis.asyncio import Redis logger = logging.getLogger('messenger') _PREFIX = 'session:' +_VERSION_PREFIX = 'hver:' +_PAGE_TTL_SECONDS = 30 def open_cache(url: str) -> Redis: @@ -66,5 +68,45 @@ class SessionCache: except Exception as exc: logger.warning('session cache delete skipped (%s)', type(exc).__name__) + async def history_version(self, chat_id: str) -> Optional[int]: + """Published chat version, or None on a miss and when Redis cannot be reached.""" + try: + raw = await self._client.get(_VERSION_PREFIX + chat_id) + except Exception as exc: + logger.warning('history version read skipped (%s)', type(exc).__name__) + return None + if raw is None: + return None + try: + return int(raw) + except ValueError: + return None + + async def publish_history_version(self, chat_id: str, version: int) -> None: + """Point readers at version. A failed write drops the key so the next read uses PostgreSQL.""" + key = _VERSION_PREFIX + chat_id + try: + await self._client.set(key, str(version)) + except Exception as exc: + logger.warning('history version write skipped (%s)', type(exc).__name__) + try: + await self._client.delete(key) + except Exception as drop_exc: + logger.warning('history version delete skipped (%s)', type(drop_exc).__name__) + + async def get_history_page(self, key: str) -> Optional[str]: + try: + return await self._client.get(key) + except Exception as exc: + logger.warning('history cache read skipped (%s)', type(exc).__name__) + return None + + async def set_history_page(self, key: str, payload: str) -> None: + """TTL only drops abandoned version keys. Freshness comes from the version in the key.""" + try: + await self._client.set(key, payload, ex=_PAGE_TTL_SECONDS) + except Exception as exc: + logger.warning('history cache write 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 584063dc..1e5cf422 100644 --- a/app/config.py +++ b/app/config.py @@ -13,6 +13,7 @@ class Settings: session_ttl_seconds: int database_url: str redis_url: str + history_cache: str def _secret(file_var: str, value_var: str) -> str: @@ -32,6 +33,13 @@ def _secret(file_var: str, value_var: str) -> str: return value +def _history_cache() -> str: + mode = os.getenv('HISTORY_CACHE', 'protected').strip().lower() or 'protected' + if mode not in ('protected', 'naive', 'off'): + raise RuntimeError('HISTORY_CACHE must be protected, naive or off') + return mode + + def load_settings() -> Settings: return Settings( host=os.getenv('APP_HOST', '0.0.0.0'), @@ -42,4 +50,5 @@ def load_settings() -> Settings: session_ttl_seconds=int(os.getenv('SESSION_TTL_SECONDS', '3600')), database_url=_secret('DATABASE_URL_FILE', 'DATABASE_URL'), redis_url=_secret('CACHE_URL_FILE', 'REDIS_URL'), + history_cache=_history_cache(), ) diff --git a/app/main.py b/app/main.py index 0b739ad3..0c63cdab 100644 --- a/app/main.py +++ b/app/main.py @@ -62,7 +62,12 @@ async def lifespan(app: FastAPI): cache = SessionCache(open_cache(settings.redis_url)) try: await apply_migrations(pool) - app.state.store = Store(pool, cache, settings.session_ttl_seconds) + app.state.store = Store( + pool, + cache, + settings.session_ttl_seconds, + settings.history_cache, + ) yield finally: try: diff --git a/app/store.py b/app/store.py index 716818be..0d9f2563 100644 --- a/app/store.py +++ b/app/store.py @@ -1,4 +1,6 @@ +import asyncio import hashlib +import json import secrets import threading import uuid @@ -9,7 +11,7 @@ from typing import Dict, List, Optional, Sequence, Tuple import asyncpg from .cache import SessionCache -from .errors import conflict, invalid_request, unavailable +from .errors import conflict, invalid_request, not_found, unavailable from .pagination import Key from .passwords import hash_password, password_matches @@ -72,6 +74,27 @@ def _stamp(moment: datetime) -> str: return moment.astimezone(timezone.utc).isoformat(timespec='microseconds').replace('+00:00', 'Z') +def _encode_page(messages: Sequence[Message], has_more: bool) -> str: + return json.dumps( + {'items': [message.to_dict() for message in messages], 'has_more': has_more}, + separators=(',', ':'), + ) + + +def _decode_page(payload: Optional[str]) -> Optional[Tuple[List[Message], bool]]: + if not payload: + return None + try: + data = json.loads(payload) + messages = [ + Message(item['id'], item['chat_id'], item['sender_id'], item['text'], item['created_at']) + for item in data['items'] + ] + return messages, bool(data['has_more']) + except (KeyError, TypeError, ValueError): + return None + + def _parse_stamp(value: str) -> datetime: if value.endswith('Z'): value = value[:-1] + '+00:00' @@ -99,15 +122,29 @@ def _db_down(exc: BaseException) -> bool: )) -class Store: - """PostgreSQL is the source of truth. Redis only caches the session lookup.""" +_FIRST_PAGE_LIMIT = 50 +# Opens the unguarded fill long enough for concurrent misses to each run their own SELECT. +_NAIVE_FILL_HOLD_SECONDS = 0.2 - def __init__(self, pool: asyncpg.Pool, cache: SessionCache, session_ttl_seconds: int = 3600) -> None: + +class Store: + """PostgreSQL is the source of truth. Redis caches session lookup and the first history page.""" + + def __init__( + self, + pool: asyncpg.Pool, + cache: SessionCache, + session_ttl_seconds: int = 3600, + history_mode: str = 'protected', + ) -> None: self._pool = pool self._cache = cache self._session_ttl = timedelta(seconds=session_ttl_seconds) + self._history_mode = history_mode self._lock = threading.Lock() self._last_moment: Optional[datetime] = None + self._flights: Dict[str, asyncio.Future] = {} + self._flight_lock = asyncio.Lock() def _now(self) -> datetime: """Strictly increasing server time, so append order always equals sort order.""" @@ -328,23 +365,117 @@ class Store: async def add_message(self, chat_id: str, sender_id: str, text: str) -> Message: message_id = uuid.uuid4() created = self._now() + chat_uuid = _as_uuid(chat_id, 'Некорректный chat_id') async with self._pool.acquire() as conn: - await conn.execute( - ''' - INSERT INTO messages (id, chat_id, sender_id, text, created_at) - VALUES ($1, $2, $3, $4, $5) - ''', - message_id, - _as_uuid(chat_id, 'Некорректный chat_id'), - _as_uuid(sender_id, 'Некорректный user_id'), - text, - created, - ) - return Message(str(message_id), chat_id, sender_id, text, _stamp(created)) + async with conn.transaction(): + version = await conn.fetchval( + ''' + UPDATE chats + SET history_version = history_version + 1 + WHERE id = $1 + RETURNING history_version + ''', + chat_uuid, + ) + if version is None: + raise not_found('Чат не найден') + await conn.execute( + ''' + INSERT INTO messages (id, chat_id, sender_id, text, created_at) + VALUES ($1, $2, $3, $4, $5) + ''', + message_id, + chat_uuid, + _as_uuid(sender_id, 'Некорректный user_id'), + text, + created, + ) + if self._history_mode == 'protected': + await self._cache.publish_history_version(str(chat_uuid), int(version)) + return Message(str(message_id), str(chat_uuid), sender_id, text, _stamp(created)) async def list_messages(self, chat_id: str, limit: int, after: Optional[Key]) -> Tuple[List[Message], bool]: chat_uuid = _as_uuid(chat_id, 'Некорректный chat_id') after_at, after_id = self._cursor(after) + if after_at is None and limit == _FIRST_PAGE_LIMIT and self._history_mode != 'off': + if self._history_mode == 'protected': + return await self._protected_first_page(chat_uuid, limit) + return await self._naive_first_page(chat_uuid, limit) + return await self._fetch_messages(chat_uuid, limit, after_at, after_id) + + async def _protected_first_page(self, chat_uuid: uuid.UUID, limit: int) -> Tuple[List[Message], bool]: + chat_id = str(chat_uuid) + version = await self._cache.history_version(chat_id) + if version is None: + version = await self._load_history_version(chat_uuid) + await self._cache.publish_history_version(chat_id, version) + key = 'history:%s:%s' % (chat_id, version) + cached = _decode_page(await self._cache.get_history_page(key)) + if cached is not None: + return cached + return await self._singleflight(key, lambda: self._fill_page(key, chat_uuid, limit)) + + async def _naive_first_page(self, chat_uuid: uuid.UUID, limit: int) -> Tuple[List[Message], bool]: + key = 'history:%s' % chat_uuid + cached = _decode_page(await self._cache.get_history_page(key)) + if cached is not None: + return cached + messages, has_more = await self._fetch_messages(chat_uuid, limit, None, None) + await asyncio.sleep(_NAIVE_FILL_HOLD_SECONDS) + await self._cache.set_history_page(key, _encode_page(messages, has_more)) + return messages, has_more + + async def _fill_page(self, key: str, chat_uuid: uuid.UUID, limit: int) -> Tuple[List[Message], bool]: + cached = _decode_page(await self._cache.get_history_page(key)) + if cached is not None: + return cached + messages, has_more = await self._fetch_messages(chat_uuid, limit, None, None) + await self._cache.set_history_page(key, _encode_page(messages, has_more)) + return messages, has_more + + async def _singleflight(self, key: str, loader): + async with self._flight_lock: + flight = self._flights.get(key) + if flight is None: + flight = asyncio.get_running_loop().create_future() + self._flights[key] = flight + leader = True + else: + leader = False + if not leader: + return await flight + try: + value = await loader() + except Exception as exc: + if not flight.done(): + flight.set_exception(exc) + raise + else: + if not flight.done(): + flight.set_result(value) + return value + finally: + async with self._flight_lock: + if self._flights.get(key) is flight: + del self._flights[key] + + async def _load_history_version(self, chat_uuid: uuid.UUID) -> int: + async with self._pool.acquire() as conn: + version = await conn.fetchval( + 'SELECT history_version FROM chats WHERE id = $1', + chat_uuid, + ) + if version is None: + raise not_found('Чат не найден') + return int(version) + + async def _fetch_messages( + self, + chat_uuid: uuid.UUID, + limit: int, + after_at: Optional[datetime], + after_id: Optional[uuid.UUID], + ) -> Tuple[List[Message], bool]: async with self._pool.acquire() as conn: if after_at is None: rows = await conn.fetch( diff --git a/compose.yaml b/compose.yaml index ff31358e..a863e56d 100644 --- a/compose.yaml +++ b/compose.yaml @@ -20,6 +20,7 @@ services: redis: image: redis:7.4.11-alpine + command: ["redis-server", "--save", "", "--appendonly", "no"] ports: - "127.0.0.1:6379:6379" healthcheck: @@ -42,6 +43,7 @@ services: SHUTDOWN_TIMEOUT_SECONDS: ${SHUTDOWN_TIMEOUT_SECONDS:-5} DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB} REDIS_URL: redis://redis:6379/0 + HISTORY_CACHE: ${HISTORY_CACHE:-protected} ports: - "127.0.0.1:8080:8080" depends_on: diff --git a/evidence/track1.json b/evidence/track1.json new file mode 100644 index 00000000..a1ba6fa2 --- /dev/null +++ b/evidence/track1.json @@ -0,0 +1,43 @@ +{ + "track": 1, + "cached_limit": 50, + "page_ttl_seconds": 30, + "naive_fill_hold_seconds": 0.2, + "naive": { + "reads_started_after_201": 8, + "reads_missing_new_message": 8, + "stale_read_observed": true, + "cold": { + "clients": 32, + "message_scans": 32, + "p50_ms": 343.766 + } + }, + "off": { + "clients": 20, + "message_scans": 20, + "p50_ms": 4.95 + }, + "protected": { + "reads_started_after_201": 8, + "reads_missing_new_message": 0, + "read_after_write": true, + "cold": { + "clients": 32, + "message_scans": 1, + "p50_ms": 160.808 + }, + "sequential_miss_p50_ms": 8.519, + "warm": { + "clients": 20, + "message_scans": 0, + "p50_ms": 5.786 + }, + "after_redis_restart": { + "confirmed_message_present": true, + "first_read_message_scans": 1, + "second_read_message_scans": 0, + "session_status": 200 + } + } +} diff --git a/migrations/002_chat_version.sql b/migrations/002_chat_version.sql new file mode 100644 index 00000000..7d23f190 --- /dev/null +++ b/migrations/002_chat_version.sql @@ -0,0 +1,2 @@ +ALTER TABLE chats + ADD COLUMN history_version BIGINT NOT NULL DEFAULT 0; diff --git a/scripts/track1_cache.py b/scripts/track1_cache.py new file mode 100644 index 00000000..6d8fbf20 --- /dev/null +++ b/scripts/track1_cache.py @@ -0,0 +1,448 @@ +#!/usr/bin/env python3 +"""Track 1: stale first page, then versioned cache and singleflight. + +The script switches HISTORY_CACHE, recreates only the API, and always restores +the previous .env. It does not print tokens. +""" +import base64 +import json +import os +import subprocess +import sys +import threading +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' +EVIDENCE_PATH = ROOT / 'evidence' / 'track1.json' +COLD_CLIENTS = 32 +READERS = 8 +WARM_READS = 20 + + +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) + started = time.perf_counter() + try: + with urllib.request.urlopen(req, timeout=timeout) as response: + payload = response.read() + elapsed_ms = (time.perf_counter() - started) * 1000 + return response.status, payload, elapsed_ms + except urllib.error.HTTPError as exc: + elapsed_ms = (time.perf_counter() - started) * 1000 + return exc.code, exc.read(), elapsed_ms + + +def compose(*args, check=True): + proc = subprocess.run( + ['docker', 'compose', '--env-file', '.env', *args], + cwd=ROOT, + check=False, + capture_output=True, + text=True, + ) + if check and proc.returncode != 0: + sys.stderr.write(proc.stderr) + raise SystemExit('docker compose %s failed' % ' '.join(args)) + return proc + + +def psql(sql): + proc = compose( + '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, + ) + return proc.stdout.strip() + + +def redis_cli(*args, check=True): + proc = compose('exec', '-T', 'redis', 'redis-cli', *args, check=check) + return proc + + +def wait_ready(seconds=90): + 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 wait_redis(seconds=40): + deadline = time.monotonic() + seconds + while time.monotonic() < deadline: + proc = redis_cli('ping', check=False) + if proc.returncode == 0 and 'PONG' in proc.stdout: + return + time.sleep(0.3) + raise SystemExit('redis did not answer PING') + + +def message_scans(): + raw = psql( + "SELECT COALESCE(idx_scan,0)+COALESCE(seq_scan,0) " + "FROM pg_stat_user_tables WHERE relname = 'messages'" + ) + if not raw: + raise SystemExit('messages stats are missing') + return int(raw) + + +def drained_message_scans(): + """Backends publish table stats on exit. Drop the ones that ran the workload.""" + raw = psql( + "SELECT pid FROM pg_stat_activity " + "WHERE datname = current_database() AND pid <> pg_backend_pid() " + "AND backend_type = 'client backend'" + ) + pids = [line.strip() for line in raw.splitlines() if line.strip()] + if pids: + if not all(pid.isdigit() for pid in pids): + raise SystemExit('unexpected pid list') + listed = ','.join(pids) + psql('SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE pid IN (%s)' % listed) + deadline = time.monotonic() + 5 + while time.monotonic() < deadline: + still = psql('SELECT count(*) FROM pg_stat_activity WHERE pid IN (%s)' % listed) + if still == '0': + break + time.sleep(0.05) + else: + raise SystemExit('postgres backends did not disconnect') + return message_scans() + + +def p50(samples): + ordered = sorted(samples) + return ordered[(len(ordered) - 1) // 2] + + +def bearer(token): + return {'Authorization': 'Bearer ' + token} + + +def write_mode(mode): + text = ENV_PATH.read_text(encoding='utf-8') + newline = '\r\n' if '\r\n' in text else '\n' + lines = [line for line in text.splitlines() if not line.startswith('HISTORY_CACHE=')] + lines.append('HISTORY_CACHE=' + mode) + ENV_PATH.write_bytes((newline.join(lines) + newline).encode('utf-8')) + + +def recreate_api(build=False): + args = ['up', '-d', '--force-recreate', '--no-deps'] + if build: + args = ['up', '-d', '--build', '--force-recreate', '--no-deps'] + args.append('api') + compose(*args) + wait_ready() + + +def flush_history(): + keys = [] + for pattern in ('history:*', 'hver:*'): + proc = redis_cli('--scan', '--pattern', pattern) + keys.extend(line.strip() for line in proc.stdout.splitlines() if line.strip()) + if keys: + redis_cli('DEL', *keys) + + +def register_and_chat(): + username = 'u_t1_%s' % uuid.uuid4().hex[:12] + password = 'T3st-' + uuid.uuid4().hex + status, raw, _ = call('POST', '/api/v1/users', { + 'username': username, + 'display_name': 'track1', + 'password': password, + }) + if status != 201: + raise SystemExit('register failed: %s' % status) + user = json.loads(raw) + basic = base64.b64encode((username + ':' + password).encode('utf-8')).decode('ascii') + status, raw, _ = call( + 'POST', '/api/v1/auth/sessions', + headers={'Authorization': 'Basic ' + basic}, + ) + if status != 201: + raise SystemExit('login failed: %s' % status) + token = json.loads(raw)['token'] + status, raw, _ = call( + 'POST', '/api/v1/chats', + {'title': 'track1', 'member_ids': [user['id']]}, + headers=bearer(token), + ) + if status != 201: + raise SystemExit('chat failed: %s' % status) + chat_id = json.loads(raw)['id'] + status, _, _ = call( + 'POST', '/api/v1/chats/%s/messages' % chat_id, + {'text': 'seed'}, + headers=bearer(token), + ) + if status != 201: + raise SystemExit('seed message failed: %s' % status) + return token, chat_id + + +def reads_after_write(token, chat_id): + status, _, _ = call( + 'GET', '/api/v1/chats/%s/messages?limit=50' % chat_id, + headers=bearer(token), + ) + if status != 200: + raise SystemExit('warm read failed: %s' % status) + post_done = threading.Event() + posted = {} + + def poster(): + status, raw, _ = call( + 'POST', '/api/v1/chats/%s/messages' % chat_id, + {'text': 'confirmed-' + uuid.uuid4().hex[:8]}, + headers=bearer(token), + ) + posted['status'] = status + if status == 201: + posted['id'] = json.loads(raw)['id'] + post_done.set() + + def reader(_index): + if not post_done.wait(20): + return None + status, raw, _ = call( + 'GET', '/api/v1/chats/%s/messages?limit=50' % chat_id, + headers=bearer(token), + ) + if status != 200: + return None + ids = [item['id'] for item in json.loads(raw)['items']] + return posted.get('id') in ids + + with ThreadPoolExecutor(max_workers=READERS + 1) as pool: + post = pool.submit(poster) + jobs = [pool.submit(reader, index) for index in range(READERS)] + post.result() + seen = [job.result() for job in jobs] + if posted.get('status') != 201 or 'id' not in posted: + raise SystemExit('post failed: %s' % posted.get('status')) + present = sum(1 for item in seen if item is True) + missing = sum(1 for item in seen if item is False) + return { + 'reads_started_after_201': present + missing, + 'reads_missing_new_message': missing, + 'message_id': posted['id'], + } + + +def cold_reads(token, chat_id): + flush_history() + before = drained_message_scans() + timings = [] + failures = [] + + def one(_index): + status, _, elapsed = call( + 'GET', '/api/v1/chats/%s/messages?limit=50' % chat_id, + headers=bearer(token), + ) + timings.append(elapsed) + if status != 200: + failures.append(status) + + with ThreadPoolExecutor(max_workers=COLD_CLIENTS) as pool: + list(pool.map(one, range(COLD_CLIENTS))) + if failures: + raise SystemExit('cold reads failed: %s' % failures[:3]) + return { + 'clients': COLD_CLIENTS, + 'message_scans': drained_message_scans() - before, + 'p50_ms': round(p50(timings), 3), + } + + +def miss_latency(token, chat_id, samples=12): + """One GET after a flush. The clock starts at the request, not at the flush.""" + timings = [] + for _ in range(samples): + flush_history() + status, _, elapsed = call( + 'GET', '/api/v1/chats/%s/messages?limit=50' % chat_id, + headers=bearer(token), + ) + if status != 200: + raise SystemExit('cold miss failed: %s' % status) + timings.append(elapsed) + return round(p50(timings), 3) + + +def warm_reads(token, chat_id): + status, _, _ = call( + 'GET', '/api/v1/chats/%s/messages?limit=50' % chat_id, + headers=bearer(token), + ) + if status != 200: + raise SystemExit('warm fill failed: %s' % status) + before = drained_message_scans() + timings = [] + for _ in range(WARM_READS): + status, _, elapsed = call( + 'GET', '/api/v1/chats/%s/messages?limit=50' % chat_id, + headers=bearer(token), + ) + if status != 200: + raise SystemExit('warm read failed: %s' % status) + timings.append(elapsed) + return { + 'clients': WARM_READS, + 'message_scans': drained_message_scans() - before, + 'p50_ms': round(p50(timings), 3), + } + + +def redis_restart(token, chat_id, message_id): + compose('exec', '-T', 'redis', 'sh', '-c', 'rm -f /data/dump.rdb /data/appendonly.aof') + compose('restart', 'redis') + wait_redis() + time.sleep(0.5) + session_status, _, _ = call('GET', '/api/v1/users/me', headers=bearer(token)) + before = drained_message_scans() + status, raw, _ = call( + 'GET', '/api/v1/chats/%s/messages?limit=50' % chat_id, + headers=bearer(token), + ) + first_delta = drained_message_scans() - before + present = False + if status == 200: + present = message_id in [item['id'] for item in json.loads(raw)['items']] + before = drained_message_scans() + status, _, _ = call( + 'GET', '/api/v1/chats/%s/messages?limit=50' % chat_id, + headers=bearer(token), + ) + second_delta = drained_message_scans() - before + return { + 'confirmed_message_present': present and status == 200, + 'first_read_message_scans': first_delta, + 'second_read_message_scans': second_delta, + 'session_status': session_status, + } + + +def problems_of(evidence): + found = [] + naive = evidence['naive'] + protected = evidence['protected'] + if naive['reads_missing_new_message'] < 1: + found.append('naive did not show a stale read') + if protected['reads_missing_new_message'] != 0: + found.append('protected missed a confirmed message') + if evidence['off']['message_scans'] != WARM_READS: + found.append('off scans %s' % evidence['off']['message_scans']) + if naive['cold']['message_scans'] < COLD_CLIENTS - 8: + found.append('naive cold scans %s' % naive['cold']['message_scans']) + if protected['cold']['message_scans'] > 2: + found.append('protected cold scans %s' % protected['cold']['message_scans']) + if protected['warm']['message_scans'] != 0: + found.append('warm scans %s' % protected['warm']['message_scans']) + if protected['warm']['p50_ms'] >= protected['sequential_miss_p50_ms']: + found.append('warm p50 is not below a cold miss') + restart = protected['after_redis_restart'] + if not restart['confirmed_message_present']: + found.append('message missing after redis restart') + if restart['first_read_message_scans'] < 1: + found.append('restart was not a miss') + if restart['second_read_message_scans'] != 0: + found.append('second read after restart was not a hit') + if restart['session_status'] != 200: + found.append('session after redis restart: %s' % restart['session_status']) + return found + + +def main(): + if not ENV_PATH.is_file(): + raise SystemExit('.env is missing') + original = ENV_PATH.read_bytes() + failure = None + try: + print('naive mode', flush=True) + write_mode('naive') + compose('up', '-d', '--build') + wait_ready() + token, chat_id = register_and_chat() + naive_race = reads_after_write(token, chat_id) + naive_cold = cold_reads(token, chat_id) + print('off mode', flush=True) + write_mode('off') + recreate_api(build=False) + off_repeat = warm_reads(token, chat_id) + print('protected mode', flush=True) + write_mode('protected') + recreate_api(build=False) + protected_race = reads_after_write(token, chat_id) + protected_cold = cold_reads(token, chat_id) + protected_miss_p50 = miss_latency(token, chat_id) + protected_warm = warm_reads(token, chat_id) + print('redis restart', flush=True) + restarted = redis_restart(token, chat_id, protected_race['message_id']) + evidence = { + 'track': 1, + 'cached_limit': 50, + 'page_ttl_seconds': 30, + 'naive_fill_hold_seconds': 0.2, + 'naive': { + 'reads_started_after_201': naive_race['reads_started_after_201'], + 'reads_missing_new_message': naive_race['reads_missing_new_message'], + 'stale_read_observed': naive_race['reads_missing_new_message'] > 0, + 'cold': naive_cold, + }, + 'off': off_repeat, + 'protected': { + 'reads_started_after_201': protected_race['reads_started_after_201'], + 'reads_missing_new_message': protected_race['reads_missing_new_message'], + 'read_after_write': protected_race['reads_missing_new_message'] == 0, + 'cold': protected_cold, + 'sequential_miss_p50_ms': protected_miss_p50, + 'warm': protected_warm, + 'after_redis_restart': restarted, + }, + } + found = problems_of(evidence) + print(json.dumps(evidence, indent=2), flush=True) + if found: + raise SystemExit('track1 failed: ' + '; '.join(found)) + EVIDENCE_PATH.parent.mkdir(parents=True, exist_ok=True) + EVIDENCE_PATH.write_text(json.dumps(evidence, indent=2) + '\n', encoding='utf-8') + print('wrote evidence/track1.json', flush=True) + except SystemExit as exc: + failure = exc + finally: + ENV_PATH.write_bytes(original) + print('restoring protected api', flush=True) + compose('up', '-d', '--force-recreate', '--no-deps', 'api') + wait_ready() + compose('start', 'redis') + compose('start', 'postgres') + if failure is not None: + raise failure + + +if __name__ == '__main__': + main()