level 5: track 1
Skeleton contracts / contracts (pull_request) Failing after 28s

This commit is contained in:
2026-10-29 10:53:32 +03:00
parent 175a8d8bfd
commit 6e84c7a7fc
10 changed files with 736 additions and 25 deletions
+3
View File
@@ -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
+33 -7
View File
@@ -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)` совпадают.
+43 -1
View File
@@ -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()
+9
View File
@@ -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(),
)
+6 -1
View File
@@ -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:
+147 -16
View File
@@ -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(
+2
View File
@@ -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:
+43
View File
@@ -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
}
}
}
+2
View File
@@ -0,0 +1,2 @@
ALTER TABLE chats
ADD COLUMN history_version BIGINT NOT NULL DEFAULT 0;
+448
View File
@@ -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()