level 4: redis cache etc
This commit is contained in:
+4
-2
@@ -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
|
||||
|
||||
@@ -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)` совпадают.
|
||||
|
||||
@@ -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
@@ -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'),
|
||||
)
|
||||
|
||||
@@ -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
@@ -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
@@ -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
@@ -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
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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,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
|
||||
|
||||
@@ -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())
|
||||
@@ -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
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user