ЛР 2: PostgreSQL, Bearer-сессии и кэш сессий в Valkey (на 4)
Skeleton contracts / contracts (pull_request) Canceled after 0s

- Перенесён минимум lab1; переход 1 → 2: password при регистрации,
  Basic только на POST /auth/sessions, Bearer вместо X-User-Id, logout.
- PostgreSQL — источник истины: users, chats, chat_members, messages,
  sessions; миграции с PK/FK/UNIQUE/CHECK и индексами, атомарное
  создание чата, scrypt для паролей, SHA-256 токенов в БД.
- Valkey — кэш проверенных сессий с TTL, tombstone при logout,
  обход кэша и окно недоверия при отказе.
- Ограниченные пулы и таймауты PostgreSQL/Valkey, 503 при отказе БД.
- compose.yaml с Docker secrets и именованным томом, restart hook,
  собственные тесты, EXPLAIN на 110 тыс. сообщений, замер пользы кэша,
  заполненный REPORT.md и evidence/.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-10-16 02:15:02 +03:00
co-authored by Claude Opus 5.5
parent 65003b6119
commit ffb98242ff
23 changed files with 2461 additions and 17 deletions
+13 -3
View File
@@ -1,11 +1,21 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
# scripts/init-secrets.sh делает это автоматически и создаёт secrets/.
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
# Строка подключения читается из файла (Docker secret), значение в окружение не попадает.
# Файл создаёт scripts/init-secrets.sh: secrets/database_url -> /run/secrets/database_url.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
# Ограниченный пул соединений и таймаут SQL.
DB_POOL_SIZE=10
DB_STATEMENT_TIMEOUT_MS=5000
# Источник истины для сессий — PostgreSQL; Valkey — кэш проверенных сессий (SESSION_CACHE=off отключает).
SESSION_STORE=postgres
SESSION_CACHE=valkey
# URL Valkey читается из файла (Docker secret secrets/cache_url, создаёт scripts/init-secrets.sh).
CACHE_URL_FILE=/run/secrets/cache_url
# Срок жизни записи кэша (не больше остатка сессии), таймаут операций и пауза обхода после отказа.
SESSION_CACHE_TTL_SECONDS=30
CACHE_TIMEOUT_MS=250
CACHE_RETRY_SECONDS=5
+25
View File
@@ -0,0 +1,25 @@
# Lab2: мессенджер на Python 3.12 + PostgreSQL (драйвер psycopg 3).
FROM python:3.12.7-slim
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
APP_HOST=0.0.0.0 \
APP_PORT=8080
WORKDIR /app
# Сначала зависимости с закреплёнными версиями — слой кэшируется, пока не изменится requirements.txt.
COPY requirements.txt /app/
RUN pip install --no-cache-dir -r requirements.txt
COPY src/ /app/src/
COPY migrations/ /app/migrations/
# Запуск без root; сервер — основной процесс контейнера (PID 1), корректно обрабатывает SIGTERM.
RUN useradd --no-create-home --uid 10001 app
USER app
EXPOSE 8080
HEALTHCHECK --interval=5s --timeout=3s --start-period=10s --retries=5 \
CMD ["python", "-c", "import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).status == 200 else 1)"]
CMD ["python", "/app/src/server.py"]
+18 -1
View File
@@ -4,7 +4,7 @@ CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
.PHONY: help check validate test load test-persistence
.PHONY: help check validate test load test-persistence secrets up down student-test student-bench
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@@ -24,3 +24,20 @@ load:
test-persistence:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
# --- Цели студента (lab2) ---
secrets:
sh scripts/init-secrets.sh
up: secrets
docker compose --env-file .env up -d --build --wait
down:
docker compose --env-file .env down
student-test:
$(PYTHON) student-tests/test_lab2.py --base-url "$(BASE_URL)" $(STUDENT_ARGS)
student-bench:
$(PYTHON) student-tests/history_bench.py --base-url "$(BASE_URL)"
$(PYTHON) student-tests/cache_bench.py --base-url "$(BASE_URL)" --label valkey
+229 -13
View File
@@ -1,37 +1,253 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Автор, группа: Лазарев Юрий Сергеевич, БПИ2303
- Целевая оценка; выбранный трек 5, если нужен: **4**, трек 5 не заявлен
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Использованные источники, библиотеки и помощь ИИ: Python 3.12 (стандартная библиотека: `http.server`, `hashlib.scrypt`, `secrets`, `hmac`), `psycopg[binary]==3.2.3`, `psycopg-pool==3.2.4`, `redis==5.2.1` (клиент протокола RESP, работает с Valkey); образы `python:3.12.7-slim`, `postgres:16.4-alpine`, `valkey/valkey:8.0.2-alpine`. Документация PostgreSQL (transactions, EXPLAIN, constraints), Valkey (persistence, eviction), RFC 7617. Код перенесён из моей lab1 и доработан с помощью ИИ-ассистента (Claude), проверен и запущен автором.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Требования: Docker Engine 28 с Compose v2 (проверено: Docker Desktop 28.0.4, Compose v2.34.0, macOS), Python 3.9+ на хосте только для тестов, `make`. Порты `127.0.0.1:8080` и `127.0.0.1:8081` (тест TTL) должны быть свободны.
```sh
# 1. Локальные синтетические секреты и .env (значения не печатаются; повторный запуск ничего не перезаписывает)
sh scripts/init-secrets.sh # или: make secrets
# secrets/postgres_password, secrets/database_url, secrets/valkey.conf, secrets/cache_url (каталог в .gitignore)
# 2. Проверка конфигурации, сборка и запуск API + PostgreSQL + Valkey; --wait ждёт healthy
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build --wait # или: make up
# 3. Готовность
curl -si http://localhost:8080/health/ready # 200 {"status": "ok"}
# 4. Публичные проверки
make check
make test
make test-persistence ACTION_SCRIPT=scripts/restart.sh
# 5. Собственные проверки: границы, гонка, откат, TTL, отказ БД, кэш и отказ Valkey, рестарт
docker compose --env-file .env --profile ttl up -d --wait api-short-ttl # API с SESSION_TTL_SECONDS=2 на :8081
python3 student-tests/test_lab2.py --expiry-url http://localhost:8081 --db-outage --cache --persistence
docker compose --env-file .env --profile ttl stop api-short-ttl
# 6. План запроса истории на 110 000 сообщений + обход истории через API (добавляет синтетические данные)
python3 student-tests/history_bench.py --big 100000 --small-chats 20 --small-size 500
# 7. Польза кэша: транзакции PostgreSQL и задержка на 1000 проверок токена
python3 student-tests/cache_bench.py --label valkey
SESSION_CACHE=off docker compose --env-file .env up -d --wait api
python3 student-tests/cache_bench.py --label off
docker compose --env-file .env up -d --wait api # вернуть кэш
```
**Миграции** применяются автоматически при старте API (каталог `migrations/`, таблица `schema_migrations`, advisory lock). Отдельный запуск без старта сервера:
```sh
docker compose --env-file .env run --rm api python /app/src/server.py --migrate-only
```
**Безопасная остановка** (данные и том сохраняются): `docker compose --env-file .env --profile ttl down` (или `make down`).
**Намеренное удаление учебных данных** (необратимо, удаляет том `mtusi-lab2_pgdata`): `docker compose --env-file .env --profile ttl down -v`. Если удалить `secrets/`, но оставить том, пароль в томе разойдётся с новым секретом — тогда нужно удалить и том.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
клиент (curl / tests)
│ HTTP 127.0.0.1:8080, Basic только на POST /auth/sessions, далее Bearer
▼
api (mtusi-messenger:lab2, Python 3.12, uid 10001, PID 1)
│ 1) проверка токена: Valkey (кэш) ──промах/отказ──► 2) PostgreSQL
├──────────────► valkey (valkey:8.0.2-alpine) — кэш сессий, без persistence, пул ≤10, таймаут 250 мс
▼
postgres (postgres:16.4-alpine) — источник истины, пул ≤10, ожидание ≤5 с, statement_timeout 5 с
└── volume pgdata → /var/lib/postgresql/data
```
| Роль | Service | Образ/версия | Health/readiness | Volume | Сеть/порт | Credentials |
| --- | --- | --- | --- | --- | --- | --- |
| api | `api` | сборка из `Dockerfile`, база `python:3.12.7-slim` | `HEALTHCHECK` → `/health/ready` | нет (stateless) | `127.0.0.1:8080→8080` | secrets `database_url`, `cache_url` → `DATABASE_URL_FILE`, `CACHE_URL_FILE` |
| postgres | `postgres` | `postgres:16.4-alpine` | `pg_isready` | `pgdata` (именованный) | внутренняя сеть, 5432 | secret `postgres_password` → `POSTGRES_PASSWORD_FILE` |
| redis_or_valkey | `valkey` | `valkey/valkey:8.0.2-alpine` | `valkey-cli ping` (с паролем) | нет: persistence выключено намеренно | внутренняя сеть, 6379 | secret `valkey.conf` (`requirepass`); без пароля — `NOAUTH` |
| api (TTL-тест) | `api-short-ttl`, профиль `ttl` | тот же образ | — | нет | `127.0.0.1:8081→8080` | те же секреты |
### Схема и транзакции (уровень 3)
**Источник истины — PostgreSQL**: пользователи, чаты, участники, сообщения и сессии. В памяти API состояния нет.
Схема (`migrations/001_init.sql`):
- `users`: PK, `UNIQUE (username)`, CHECK формата username и длины display_name; `password_hash` — scrypt.
- `chats`: PK, CHECK длины title.
- `chat_members`: PK `(chat_id, user_id)`, FK на `chats` и `users`, `position` — порядок `member_ids`; индекс `(user_id, chat_id)` для списка чатов пользователя.
- `messages`: PK, FK на чат и отправителя, CHECK 1–4000; индекс `(chat_id, created_at, id)` — обоснование ниже.
- `sessions`: PK `token_hash` (SHA-256 токена), FK на `users`, `expires_at`, `revoked_at`; индекс `expires_at`.
Транзакционные границы:
- **Создание чата**: проверка участников, `INSERT chats` и все `INSERT chat_members` — одна транзакция. Ошибка, включая нарушение FK, откатывает её целиком.
- **Сообщение**: в одной транзакции `SELECT ... FOR UPDATE` строки чата с проверкой членства и `INSERT`. Вставки в один чат сериализуются, `created_at = clock_timestamp()` растёт в порядке фиксации, и keyset-курсор не пропускает конкурентные вставки. Ограничение: порядок зависит от часов сервера БД.
- **Регистрация**: гонку одинакового username решает `UNIQUE` в БД (`UniqueViolation` → 409), без «SELECT, потом INSERT».
- **Миграции**: каждый файл и его запись в `schema_migrations` — одна транзакция; процессы сериализуются `pg_advisory_lock`.
### Аутентификация и сессии
- Пароль 12–128 code points хешируется `hashlib.scrypt` (N=2^15, r=8, p=1, соль 16 байт). Проверка — `hmac.compare_digest`; для неизвестного username считается фиктивный хеш (одинаковое время ответа). bcrypt не выбран из-за усечения до 72 байт.
- `POST /api/v1/auth/sessions` принимает только Basic. Любая ошибка — одинаковый 401 с `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`.
- Токен — `secrets.token_urlsafe(32)` (256 бит). В PostgreSQL и Valkey хранится только SHA-256 токена.
- `expires_at = now() + SESSION_TTL_SECONDS` вычисляет БД; logout ставит `revoked_at`. Рестарт TTL не продлевает.
- Остальные endpoint требуют Bearer; Basic и `X-User-Id` дают 401, `X-User-Id` рядом с Bearer игнорируется. Чужой и несуществующий чат одинаково дают 404.
### Valkey: роль, источник истины, expiry и инвалидация (уровень 4)
**Роль** — кэш проверенных сессий (`src/session_cache.py`). Проверка Bearer-токена выполняется на каждом защищённом запросе, поэтому без кэша каждый запрос — это минимум одна транзакция PostgreSQL. **Источник истины остаётся PostgreSQL**, в Valkey лежат только производные копии:
- ключ `sess:<sha256(token) hex>` — сам токен в Valkey не попадает;
- значение `{"user": {...}, "exp": <unix-время истечения сессии>}` либо `"revoked"`.
**Путь проверки токена** (`current_user` в `src/server.py`):
1. `GET sess:<h>` в Valkey:
- копия → пользователь, PostgreSQL не трогаем;
- `"revoked"` → 401;
- промах или ошибка → шаг 2.
2. `SELECT` из `sessions` (действующая, не отозвана, не истекла). Затем `SET sess:<h> ... PX=<ttl> NX`.
**Политика expiry**:
- Положительная запись живёт `min(SESSION_CACHE_TTL_SECONDS=30, остаток сессии)` (PX в мс), поэтому кэш не переживает сессию. При чтении `exp` дополнительно сверяется с часами.
- Tombstone `"revoked"` живёт 31 с — дольше любой положительной записи.
- `maxmemory 64mb`, `allkeys-lru`: вытеснение любой записи безопасно. Вытесненная копия означает промах и чтение из БД. Вытесненный tombstone тоже даёт промах, а БД отвечает «отозвана».
**Инвалидация (logout)**:
1. `UPDATE sessions SET revoked_at` — COMMIT в PostgreSQL.
2. `SET sess:<h> "revoked"` поверх возможной копии (не `DEL`).
Кэш после промаха заполняется только через `SET NX`. Поэтому конкурентный запрос, прочитавший БД до отзыва, не может перезаписать tombstone. Кроме того, кэш не заполняется, если между чтением БД и записью прошло больше 1 с.
**Persistence Valkey выключено намеренно** (`save ""`, `appendonly no`). Valkey — не единственное хранилище сессий, а кэш над PostgreSQL. После рестарта или `FLUSHALL` кэш пуст: сессии читаются из БД и снова кэшируются, действующие токены работают, отозванные остаются отозванными. Это проверено публичным persistence-тестом (restart hook перезапускает и Valkey) и тестом `FLUSHALL`.
**Отказ Valkey**:
- Любая ошибка или таймаут (250 мс на соединение и операцию) → запрос обслуживается из PostgreSQL. Следующие 5 с кэш не опрашивается (circuit breaker), чтобы не платить таймаутом на каждом запросе.
- `/health/ready` остаётся 200: Valkey не критичен для обязательного пути.
- Если не удалось записать tombstone (Valkey завис или недоступен во время logout), процесс 31 с не доверяет положительным записям кэша. Устаревшая копия могла остаться в Valkey, но за это время она гарантированно истечёт.
- Анонимный или неизвестный токен при отказе Valkey не проходит: решение всегда принимает PostgreSQL.
**Ограничение**: окно недоверия хранится в памяти процесса. В lab2 API один, и защита полная. В lab3 при нескольких репликах о неудавшейся инвалидации узнает только одна реплика. Тогда нужен общий сигнал (например, эпоха кэша в PostgreSQL) или отказ от logout при недоступном Valkey.
### Пулы, таймауты, параметризация (уровень 4)
- Все SQL-запросы параметризованы (`%s` в psycopg, значения отдельно от текста запроса). Ключи Valkey строятся из hex-хеша.
- PostgreSQL: `ConnectionPool(min_size=1, max_size=DB_POOL_SIZE=10, timeout=5)`, `connect_timeout=5`, `statement_timeout=DB_STATEMENT_TIMEOUT_MS=5000`. Перед выдачей соединение проверяется (`check_connection`), поэтому после рестарта БД нет ложных 503.
- Valkey: `BlockingConnectionPool(max_connections=10, timeout=0.25)`, `socket_timeout` и `socket_connect_timeout` 250 мс.
- Нет БД → `503 unavailable` за ≤5 с (ожидание пула и connect_timeout), а не зависание или 500.
### Что перенесено из lab1 и что изменено
Из lab1 перенесён каркас HTTP-сервера на `http.server`: маршрутизация, единый формат ошибок, `X-Request-Id`, валидация полей и длин в code points, 415 для не-JSON, keyset-курсор с привязкой к ресурсу, логирование без тел запросов, SIGTERM, non-root образ.
Изменено (переход 1 → 2): `password` при регистрации; Basic → Bearer-сессия вместо `X-User-Id`; logout; in-memory хранилище заменено PostgreSQL (`src/store.py`); добавлены кэш сессий в Valkey (`src/session_cache.py`), миграции, Compose, Docker secrets, restart hook и собственные тесты.
### Соответствие `.env.example` реальной конфигурации
| Переменная | Где используется | Значение |
| --- | --- | --- |
| `APP_HOST`, `APP_PORT`, `APP_ENV` | `src/server.py` | `0.0.0.0`, `8080`, `lab` |
| `SESSION_TTL_SECONDS` | `create_session` | 3600 (в `api-short-ttl` — 2) |
| `DATABASE_URL_FILE` | `database_conninfo` | `/run/secrets/database_url` |
| `DB_POOL_SIZE`, `DB_STATEMENT_TIMEOUT_MS` | `src/store.py` | 10, 5000 |
| `SESSION_STORE` | информационно: где хранятся сессии | `postgres` (источник истины) |
| `SESSION_CACHE` | `cache_url()` | `valkey`; `off` отключает кэш (для сравнения) |
| `CACHE_URL_FILE` | `cache_url()` | `/run/secrets/cache_url` |
| `SESSION_CACHE_TTL_SECONDS`, `CACHE_TIMEOUT_MS`, `CACHE_RETRY_SECONDS` | `src/session_cache.py` | 30, 250, 5 |
## Доказательства критериев
### Уровень 3
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Структура skeleton | `make check` | `PASS: offline skeleton structure...` | [evidence/smoke.txt](evidence/smoke.txt) |
| Публичный smoke | `make test` | `PASS: lab2 public API scenario` | [evidence/smoke.txt](evidence/smoke.txt) |
| Данные и действующие сессии переживают рестарт API и всех хранилищ без удаления томов | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS`; `StartedAt` у api, postgres и valkey изменился; в логах PostgreSQL `shut down` → `ready to accept`, у Valkey `SIGTERM` → `Ready`; том тот же | [evidence/persistence.txt](evidence/persistence.txt) |
| После рестарта отозванный токен остаётся отозванным, история та же | `test_lab2.py --persistence` | 5 × OK | [evidence/student-tests.txt](evidence/student-tests.txt) |
| PK/FK, UNIQUE username, 4 таблицы | `\d` таблиц | ключи, `users_username_key`, CHECK, индексы | [evidence/database.txt](evidence/database.txt) |
| Миграции с нуля и повторно без дублей | первый старт на пустом томе; `--migrate-only` × 2 | `migration applied: 001_init.sql`; счётчики до и после равны | [evidence/database.txt](evidence/database.txt) |
| Создание чата атомарно | чат с неизвестным 3-м участником | 400, списки чатов не изменились, следующее создание — 201 | [evidence/student-tests.txt](evidence/student-tests.txt) |
| Basic только на входе, Bearer на остальных, `X-User-Id` не даёт доступ | тесты auth + smoke | Basic на `/users/me` → 401; только `X-User-Id` → 401; владелец не меняется | [evidence/student-tests.txt](evidence/student-tests.txt) |
| Срок жизни и отзыв | TTL = 2; logout | через 3 с 401; logout 204 → 401 → повторный 401 | [evidence/student-tests.txt](evidence/student-tests.txt) |
| Password KDF | `users.password_hash` | все хеши `scrypt N=2^15 r=8 p=1`; в `sessions` только 32-байтовые SHA-256 | [evidence/database.txt](evidence/database.txt) |
| Secrets/volumes не в Git | `git status --ignored`, `git check-ignore` | `.env` и все файлы `secrets/` игнорируются | [evidence/stack.txt](evidence/stack.txt) |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
### Уровень 4
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Valkey реально используется (кэш сессий с TTL) | `test_lab2.py --cache` | после входа в Valkey копия сессии; 50 запросов → 50 попаданий, 0 промахов | [evidence/student-tests.txt](evidence/student-tests.txt) |
| Кэш осмысленный (снимает нагрузку с источника истины) | `cache_bench.py`, 1000 проверок токена × 3 повтора | транзакций PostgreSQL: **3–13** с кэшем против **1693–1789** без; p50 0,80–0,86 мс против 1,08–1,16 мс | [evidence/cache-bench.txt](evidence/cache-bench.txt) |
| Описаны источник истины, expiry, инвалидация | раздел «Valkey» выше | logout → tombstone, отозванный токен сразу 401 | [evidence/student-tests.txt](evidence/student-tests.txt) |
| Рестарт/flush Valkey не теряет сессии (persistence не нужно: Valkey — кэш) | `FLUSHALL`; restart hook | действующий токен работает из БД, отозванный 401, кэш заново заполняется | [evidence/student-tests.txt](evidence/student-tests.txt), [evidence/persistence.txt](evidence/persistence.txt) |
| Параметризованные запросы, ограниченный пул, таймауты | код `src/store.py`, `src/session_cache.py` | пулы ≤10, таймауты 5 с / 250 мс, `statement_timeout` | раздел «Пулы» выше |
| Гонка регистрации одинакового username | 20 параллельных `POST /users` | ровно один 201, 19 × 409 | [evidence/student-tests.txt](evidence/student-tests.txt) |
| Rollback составной операции | чат с неизвестным участником | ни чата, ни участников; следующее создание — 201 | [evidence/student-tests.txt](evidence/student-tests.txt) |
| Индекс истории обоснован `EXPLAIN (ANALYZE, BUFFERS)` на ≥10 000 сообщений | `history_bench.py`: 110 205 сообщений, один чат на 100 000 и 20 по 500 | см. таблицу ниже: keyset-страница на глубине 90 000 — Index Scan, 51 строка, 7 буферов, 0,058 мс | [evidence/explain.txt](evidence/explain.txt) |
| Пагинация не сканирует всю историю на каждой странице | обход 100 000 сообщений через API, limit=100 | 1000 страниц без потерь и повторов; медиана первых 20 страниц 3,14 мс, последних 20 — 2,83 мс | [evidence/explain.txt](evidence/explain.txt) |
| Автопроверка expiry при коротком TTL | `--expiry-url` (TTL = 2) | 200 → через 3 с 401 с `WWW-Authenticate: Bearer` | [evidence/student-tests.txt](evidence/student-tests.txt) |
| Автопроверка logout и неверного пароля | `test_lab2.py` | logout 204/401/401; неверный пароль 401 Basic | [evidence/student-tests.txt](evidence/student-tests.txt) |
| Автопроверка недоступности БД | `--db-outage` | ready 503, live 200, `/chats` 503 за <10 с, вход 503, неизвестный токен не проходит; после старта прежний токен работает | [evidence/student-tests.txt](evidence/student-tests.txt) |
| Автопроверка недоступности Valkey | `--cache` (stop valkey) | ready 200; токен работает через БД за <2 с; без токена и с чужим 401; вход 201, logout 204 → 401; после старта токен, отозванный во время отказа, остаётся 401 | [evidence/student-tests.txt](evidence/student-tests.txt) |
| Зависание Valkey во время logout не «воскрешает» токен | `--cache` (pause valkey) | logout 204; в Valkey осталась устаревшая копия, но через 6 с (breaker закрыт) токен всё равно 401; в журнале `positive entries distrusted for 31s` | [evidence/student-tests.txt](evidence/student-tests.txt) |
### EXPLAIN (ANALYZE, BUFFERS) — сводка
Запрос — ровно тот, что выполняет приложение:
```sql
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = $1 AND (created_at, id) > ($2, $3)
ORDER BY created_at, id LIMIT 51
```
Данные: 110 205 строк, таблица 22 MB, индекс 11 MB; большой чат — 100 000 сообщений.
| Вариант | План | Прочитано строк | Буферов | Время выполнения |
| --- | --- | --- | --- | --- |
| Первая страница, индекс | Index Scan `messages_chat_order_idx` | 51 | 5 | 0,064 мс |
| **Keyset после 90 000-го, индекс** (как в приложении) | Index Scan, условие `ROW(created_at, id) > ROW(...)` в Index Cond | 51 | 7 | 0,058 мс |
| OFFSET 90000, индекс (так приложение не делает) | Index Scan, затем отбрасывание | 90 051 | 4 726 | 12,6 мс |
| Первая страница без индекса | Parallel Seq Scan + Sort top-N | вся таблица | 2 836 | 12,3 мс |
| Keyset без индекса | Seq Scan, `Rows Removed by Filter: 100205` | вся таблица | 2 792 | 7,7 мс |
Вывод: составной индекс `(chat_id, created_at, id)` совпадает с фильтром и сортировкой. Страница любой глубины — это спуск по B-дереву и чтение `limit + 1` записей, без сортировки. Стоимость не зависит ни от глубины, ни от размера чата. `OFFSET` растёт линейно с глубиной, а без индекса каждая страница читает всю таблицу.
Стоимость индекса: 11 MB на 110 тыс. строк и дополнительная запись в B-дерево при каждой вставке. Заливка 110 тыс. строк с индексом заняла 1,8 с; отдельно стоимость записи на «4» не измерялась.
Ограничения замера: все страницы в shared buffers (`shared hit`), холодный кэш и диск не измерялись; один прогон на ноутбуке без лимитов CPU/RAM.
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Стенд: MacBook (macOS), Docker Desktop 28.0.4, лимиты CPU/RAM на контейнеры не заданы, настройки PostgreSQL и Valkey по умолчанию, кроме указанных выше. Замеры latency последовательные (один клиент), это не нагрузочный тест.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| `scripts/restart.sh`: штатный рестарт API, PostgreSQL и Valkey | данные и сессии сохранены, прежний токен работает | public persistence PASS; те же пользователь, чат и история; отозванный токен 401 | ~3–4 с до `ready`; потерь нет; кэш пуст и заполняется заново |
| `docker compose stop postgres` | ready 503, бизнес-запросы 503 за ограниченное время | ready 503, live 200, `/chats` 503, вход 503; `/users/me` — 200 из кэша сессий, пока жива копия (≤30 с), иначе 503 (отзыв без БД невозможен: logout тоже 503) | после `start` — несколько секунд; потерь нет |
| `docker compose stop valkey` | API продолжает работать через PostgreSQL | все операции работают, ready 200, ответ <2 с (одна попытка 250 мс, далее breaker 5 с) | после `start` через 5 с кэш снова используется |
| `FLUSHALL` в Valkey | кэш пуст, корректность сохранена | действующий токен работает, отозванный 401 | мгновенно |
| `docker compose pause valkey` во время logout | отзыв фиксируется в БД, устаревшая копия не принимается | logout 204; устаревшая копия в Valkey не принята (31 с недоверия) | — |
| Сессия с `SESSION_TTL_SECONDS=2` | через 2 с — 401 | 401 на обоих экземплярах API (запись кэша живёт не дольше сессии) | — |
Гарантии durability: подтверждённое сообщение — это успешный COMMIT. При `fsync=on` и `synchronous_commit=on` (по умолчанию) WAL сброшен на диск до ответа, поэтому рестарт и падение процесса БД не теряют подтверждённых записей. Потерю тома или Docker-host это не покрывает.
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Выдерживается: рестарт или пересоздание контейнеров API, PostgreSQL и Valkey при сохранённом томе; временная недоступность PostgreSQL (503 и восстановление без перезапуска API); полная недоступность, зависание или очистка Valkey.
- Не выдерживается: потеря тома или Docker-host (бэкапов нет); единственные экземпляры PostgreSQL, Valkey и API.
- Окно недоверия кэшу после неудачной инвалидации локально для процесса; для нескольких реплик в lab3 нужен общий механизм (см. раздел «Valkey»).
- Во время отказа PostgreSQL `/users/me` может быть отдан из кэша до 30 с — это осознанный выбор: копия соответствует действующей сессии, а отозвать её без БД нельзя.
- HTTP без TLS допустим только на `127.0.0.1` с синтетическими данными.
- Истёкшие и отозванные сессии не удаляются из таблицы автоматически (индекс `sessions_expires_idx` подготовлен для периодической очистки).
- `history_bench.py` при каждом запуске добавляет ~110 тыс. синтетических сообщений в учебную БД.
+105
View File
@@ -0,0 +1,105 @@
# Lab2: API + PostgreSQL (источник истины) + Valkey (кэш сессий). Секреты — файлы в ./secrets (не коммитятся), создаются scripts/init-secrets.sh.
name: mtusi-lab2
services:
postgres:
image: postgres:16.4-alpine
environment:
POSTGRES_DB: messenger
POSTGRES_USER: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
secrets:
- postgres_password
volumes:
- pgdata:/var/lib/postgresql/data # данные переживают перезапуск/пересоздание контейнера
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 2s
timeout: 3s
retries: 30
stop_grace_period: 30s # даём PostgreSQL штатно завершиться (checkpoint)
restart: unless-stopped
# Кэш проверенных сессий. Источник истины — PostgreSQL, поэтому persistence намеренно
# выключено: после рестарта/flush кэш пуст, сессии читаются из БД и снова кэшируются.
valkey:
image: valkey/valkey:8.0.2-alpine
command:
- valkey-server
- /run/secrets/valkey.conf # requirepass из секрета
- --save
- "" # без RDB-снимков
- --appendonly
- "no" # без AOF
- --maxmemory
- 64mb
- --maxmemory-policy
- allkeys-lru # при нехватке памяти вытесняются старые записи
secrets:
- valkey.conf
healthcheck:
test: ["CMD-SHELL", "valkey-cli --no-auth-warning -a \"$$(sed -n 's/^requirepass //p' /run/secrets/valkey.conf)\" ping | grep -q PONG"]
interval: 2s
timeout: 3s
retries: 30
restart: unless-stopped
api:
build: .
image: mtusi-messenger:lab2
environment:
APP_HOST: ${APP_HOST:-0.0.0.0}
APP_PORT: ${APP_PORT:-8080}
APP_ENV: ${APP_ENV:-lab}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
SESSION_STORE: ${SESSION_STORE:-postgres}
DATABASE_URL_FILE: /run/secrets/database_url
DB_POOL_SIZE: ${DB_POOL_SIZE:-10}
DB_STATEMENT_TIMEOUT_MS: ${DB_STATEMENT_TIMEOUT_MS:-5000}
SESSION_CACHE: ${SESSION_CACHE:-valkey}
CACHE_URL_FILE: /run/secrets/cache_url
SESSION_CACHE_TTL_SECONDS: ${SESSION_CACHE_TTL_SECONDS:-30}
CACHE_TIMEOUT_MS: ${CACHE_TIMEOUT_MS:-250}
CACHE_RETRY_SECONDS: ${CACHE_RETRY_SECONDS:-5}
secrets:
- database_url
- cache_url
ports:
- "127.0.0.1:8080:8080" # только localhost: Basic по HTTP — учебный стенд
depends_on:
postgres:
condition: service_healthy
valkey:
condition: service_started # Valkey не критичен: API стартует и без него
restart: unless-stopped
# Отдельный экземпляр API с коротким TTL — только для проверки истечения сессии.
# Запуск: docker compose --profile ttl up -d api-short-ttl (порт 8081, та же БД).
api-short-ttl:
profiles: ["ttl"]
image: mtusi-messenger:lab2
environment:
SESSION_TTL_SECONDS: 2
DATABASE_URL_FILE: /run/secrets/database_url
CACHE_URL_FILE: /run/secrets/cache_url
secrets:
- database_url
- cache_url
ports:
- "127.0.0.1:8081:8080"
depends_on:
postgres:
condition: service_healthy
secrets:
postgres_password:
file: ./secrets/postgres_password
database_url:
file: ./secrets/database_url
valkey.conf:
file: ./secrets/valkey.conf
cache_url:
file: ./secrets/cache_url
volumes:
pgdata:
+11
View File
@@ -0,0 +1,11 @@
# 2026-10-15T23:09:37Z 1000 последовательных GET /users/me одним токеном, 3 повтора на режим
{"label": "valkey #1", "requests": 1000, "postgres_xact_commit_delta": 13, "p50_ms": 0.8, "p95_ms": 1.72}
{"label": "valkey #2", "requests": 1000, "postgres_xact_commit_delta": 13, "p50_ms": 0.85, "p95_ms": 2.05}
{"label": "valkey #3", "requests": 1000, "postgres_xact_commit_delta": 3, "p50_ms": 0.86, "p95_ms": 1.83}
$ SESSION_CACHE=off docker compose up -d --wait api
INFO listening on 0.0.0.0:8080 env=lab session_ttl=3600s session_cache=off
{"label": "off #1", "requests": 1000, "postgres_xact_commit_delta": 1789, "p50_ms": 1.16, "p95_ms": 2.28}
{"label": "off #2", "requests": 1000, "postgres_xact_commit_delta": 1693, "p50_ms": 1.09, "p95_ms": 1.98}
{"label": "off #3", "requests": 1000, "postgres_xact_commit_delta": 1699, "p50_ms": 1.08, "p95_ms": 2.02}
$ docker compose up -d --wait api (возврат SESSION_CACHE=valkey)
INFO listening on 0.0.0.0:8080 env=lab session_ttl=3600s session_cache=valkey
+108
View File
@@ -0,0 +1,108 @@
# 2026-10-12T14:22:38Z
--- 1. Миграции с нуля (пустой том, первый старт API):
api-1 | 2026-10-12 14:21:13,412 INFO migration applied: 001_init.sql
api-1 | 2026-10-12 14:21:13,412 INFO schema version: 001_init.sql
--- 2. Повторный запуск миграций не дублирует данные
до:
users | chats | messages | migrations
-------+-------+----------+------------
11 | 5 | 103 | 1
(1 row)
$ docker compose run --rm api python /app/src/server.py --migrate-only (запуск 1)
2026-10-12 14:22:39,348 INFO schema version: 001_init.sql
2026-10-12 14:22:39,348 INFO migrations are up to date, exiting (--migrate-only)
$ docker compose run --rm api python /app/src/server.py --migrate-only (запуск 2)
2026-10-12 14:22:40,518 INFO schema version: 001_init.sql
2026-10-12 14:22:40,518 INFO migrations are up to date, exiting (--migrate-only)
после:
users | chats | messages | migrations
-------+-------+----------+------------
11 | 5 | 103 | 1
(1 row)
version | applied_at
--------------+-------------------------------
001_init.sql | 2026-10-12 14:21:13.401972+00
(1 row)
--- 3. Схема: ключи, ограничения, индексы
Table "public.users"
Column | Type | Collation | Nullable | Default
---------------+--------------------------+-----------+----------+---------
id | uuid | | not null |
username | text | | not null |
display_name | text | | not null |
password_hash | text | | not null |
created_at | timestamp with time zone | | not null |
Indexes:
"users_pkey" PRIMARY KEY, btree (id)
"users_username_key" UNIQUE CONSTRAINT, btree (username)
Check constraints:
"users_display_name_len" CHECK (char_length(display_name) >= 1 AND char_length(display_name) <= 100)
"users_username_format" CHECK (username ~ '^[a-z0-9_]{3,32}$'::text)
Referenced by:
TABLE "chat_members" CONSTRAINT "chat_members_user_id_fkey" FOREIGN KEY (user_id) REFERENCES users(id)
TABLE "messages" CONSTRAINT "messages_sender_id_fkey" FOREIGN KEY (sender_id) REFERENCES users(id)
TABLE "sessions" CONSTRAINT "sessions_user_id_fkey" FOREIGN KEY (user_id) REFERENCES users(id)
Table "public.chat_members"
Column | Type | Collation | Nullable | Default
----------+---------+-----------+----------+---------
chat_id | uuid | | not null |
user_id | uuid | | not null |
position | integer | | not null |
Indexes:
"chat_members_pkey" PRIMARY KEY, btree (chat_id, user_id)
"chat_members_user_idx" btree (user_id, chat_id)
Check constraints:
"chat_members_position_check" CHECK ("position" >= 0)
Foreign-key constraints:
"chat_members_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
"chat_members_user_id_fkey" FOREIGN KEY (user_id) REFERENCES users(id)
Table "public.messages"
Column | Type | Collation | Nullable | Default
------------+--------------------------+-----------+----------+---------
id | uuid | | not null |
chat_id | uuid | | not null |
sender_id | uuid | | not null |
text | text | | not null |
created_at | timestamp with time zone | | not null |
Indexes:
"messages_pkey" PRIMARY KEY, btree (id)
"messages_chat_order_idx" btree (chat_id, created_at, id)
Check constraints:
"messages_text_check" CHECK (char_length(text) >= 1 AND char_length(text) <= 4000)
Foreign-key constraints:
"messages_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
"messages_sender_id_fkey" FOREIGN KEY (sender_id) REFERENCES users(id)
Table "public.sessions"
Column | Type | Collation | Nullable | Default
------------+--------------------------+-----------+----------+---------
token_hash | bytea | | not null |
user_id | uuid | | not null |
created_at | timestamp with time zone | | not null |
expires_at | timestamp with time zone | | not null |
revoked_at | timestamp with time zone | | |
Indexes:
"sessions_pkey" PRIMARY KEY, btree (token_hash)
"sessions_expires_idx" btree (expires_at)
Check constraints:
"sessions_check" CHECK (expires_at > created_at)
Foreign-key constraints:
"sessions_user_id_fkey" FOREIGN KEY (user_id) REFERENCES users(id)
--- 4. Пароли: только scrypt-хеш (показаны параметры), токены: только SHA-256 (32 байта)
kdf_params | count
-----------------------+-------
scrypt N=2^15 r=8 p=1 | 11
(1 row)
hash_bytes | sessions | revoked
------------+----------+---------
32 | 14 | 2
(1 row)
+126
View File
@@ -0,0 +1,126 @@
# 2026-10-15T23:09:01Z MacBook, Docker Desktop 28.0.4, без CPU/RAM-лимитов, postgres:16.4-alpine (настройки по умолчанию)
$ python3 student-tests/history_bench.py --big 100000 --small-chats 20 --small-size 500
====================================================================================================
1. Заливка данных
====================================================================================================
залито за 1.8 с
messages_total | chats_with_messages | in_big_chat | table_size | index_size
----------------+---------------------+-------------+------------+------------
110205 | 26 | 100000 | 22 MB | 11 MB
(1 row)
====================================================================================================
2a. С индексом: первая страница (как в приложении, limit=50 → LIMIT 51)
====================================================================================================
SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = '6cf4a78d-a633-497d-96ce-bd82abd08a11' ORDER BY created_at, id LIMIT 51
QUERY PLAN
-------------------------------------------------------------------------------------------------------
Limit (actual time=0.026..0.038 rows=51 loops=1)
Buffers: shared hit=5
-> Index Scan using messages_chat_order_idx on messages (actual time=0.025..0.035 rows=51 loops=1)
Index Cond: (chat_id = '6cf4a78d-a633-497d-96ce-bd82abd08a11'::uuid)
Buffers: shared hit=5
Planning:
Buffers: shared hit=137
Planning Time: 0.396 ms
Execution Time: 0.064 ms
(9 rows)
====================================================================================================
2b. С индексом: страница после 90000-го сообщения, keyset-курсор (как в приложении)
====================================================================================================
SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = '6cf4a78d-a633-497d-96ce-bd82abd08a11' AND (created_at, id) > ('2026-01-01 00:01:30+00', '29f2fea4-8210-4561-9e6a-e0c3a1b513c0'::uuid) ORDER BY created_at, id LIMIT 51
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (actual time=0.018..0.029 rows=51 loops=1)
Buffers: shared hit=7
-> Index Scan using messages_chat_order_idx on messages (actual time=0.017..0.026 rows=51 loops=1)
Index Cond: ((chat_id = '6cf4a78d-a633-497d-96ce-bd82abd08a11'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 00:01:30+00'::timestamp with time zone, '29f2fea4-8210-4561-9e6a-e0c3a1b513c0'::uuid)))
Buffers: shared hit=7
Planning:
Buffers: shared hit=136
Planning Time: 0.352 ms
Execution Time: 0.058 ms
(9 rows)
====================================================================================================
2c. Для сравнения: та же глубина через OFFSET 90000 (так приложение НЕ делает)
====================================================================================================
SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = '6cf4a78d-a633-497d-96ce-bd82abd08a11' ORDER BY created_at, id OFFSET 90000 LIMIT 51
QUERY PLAN
-----------------------------------------------------------------------------------------------------------
Limit (actual time=12.582..12.591 rows=51 loops=1)
Buffers: shared hit=4726
-> Index Scan using messages_chat_order_idx on messages (actual time=0.019..10.068 rows=90051 loops=1)
Index Cond: (chat_id = '6cf4a78d-a633-497d-96ce-bd82abd08a11'::uuid)
Buffers: shared hit=4726
Planning:
Buffers: shared hit=137
Planning Time: 0.377 ms
Execution Time: 12.607 ms
(9 rows)
====================================================================================================
2d. БЕЗ индекса messages_chat_order_idx (DROP INDEX внутри BEGIN … ROLLBACK, данные не меняются)
====================================================================================================
--- первая страница без индекса
QUERY PLAN
-----------------------------------------------------------------------------------------------
Limit (actual time=10.974..12.247 rows=51 loops=1)
Buffers: shared hit=2836
-> Gather Merge (actual time=10.973..12.241 rows=51 loops=1)
Workers Planned: 1
Workers Launched: 1
Buffers: shared hit=2836
-> Sort (actual time=9.575..9.579 rows=51 loops=2)
Sort Key: created_at, id
Sort Method: top-N heapsort Memory: 39kB
Buffers: shared hit=2836
Worker 0: Sort Method: top-N heapsort Memory: 40kB
-> Parallel Seq Scan on messages (actual time=0.019..6.242 rows=50000 loops=2)
Filter: (chat_id = '6cf4a78d-a633-497d-96ce-bd82abd08a11'::uuid)
Rows Removed by Filter: 5102
Buffers: shared hit=2792
Planning:
Buffers: shared hit=104
Planning Time: 0.367 ms
Execution Time: 12.294 ms
(19 rows)
--- keyset-страница без индекса
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (actual time=7.631..7.636 rows=51 loops=1)
Buffers: shared hit=2792
-> Sort (actual time=7.630..7.632 rows=51 loops=1)
Sort Key: created_at, id
Sort Method: top-N heapsort Memory: 45kB
Buffers: shared hit=2792
-> Seq Scan on messages (actual time=4.642..7.102 rows=10000 loops=1)
Filter: ((chat_id = '6cf4a78d-a633-497d-96ce-bd82abd08a11'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 00:01:30+00'::timestamp with time zone, '29f2fea4-8210-4561-9e6a-e0c3a1b513c0'::uuid)))
Rows Removed by Filter: 100205
Buffers: shared hit=2792
Planning Time: 0.060 ms
Execution Time: 7.668 ms
(12 rows)
indexname
-------------------------
messages_chat_order_idx
messages_pkey
(2 rows)
====================================================================================================
3. Полный обход истории большого чата через API (limit=100)
====================================================================================================
{
"pages": 1000,
"messages_read": 100000,
"expected": 100000,
"first_20_pages_median_ms": 3.14,
"last_20_pages_median_ms": 2.83,
"all_pages_p50_ms": 2.8,
"all_pages_p95_ms": 4.33,
"all_pages_max_ms": 10.96
}
PASS: все 100000 сообщений прочитаны без потерь и повторов
+22
View File
@@ -0,0 +1,22 @@
# 2026-10-15T23:10:29Z
--- до: контейнеры
/mtusi-lab2-api-1 started=2026-10-15T23:10:13.308098346Z
/mtusi-lab2-postgres-1 started=2026-10-15T23:08:12.796745137Z
/mtusi-lab2-valkey-1 started=2026-10-15T23:08:12.79643622Z
$ make test-persistence ACTION_SCRIPT=scripts/restart.sh
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
--- после: контейнеры (StartedAt изменился у всех трёх => перезапущены API, PostgreSQL и Valkey)
/mtusi-lab2-api-1 started=2026-10-15T23:10:33.226933382Z
/mtusi-lab2-postgres-1 started=2026-10-15T23:10:31.075516256Z
/mtusi-lab2-valkey-1 started=2026-10-15T23:10:31.076417256Z
--- том pgdata сохранён:
mtusi-lab2_pgdata created=2026-10-12T14:21:10Z
--- логи PostgreSQL о перезапуске:
postgres-1 | 2026-10-15 23:10:30.838 UTC [1] LOG: database system is shut down
postgres-1 | 2026-10-15 23:10:31.171 UTC [29] LOG: database system was shut down at 2026-10-15 23:10:30 UTC
postgres-1 | 2026-10-15 23:10:31.174 UTC [1] LOG: database system is ready to accept connections
--- логи Valkey о перезапуске:
valkey-1 | 1:signal-handler (1792105830) Received SIGTERM scheduling shutdown...
valkey-1 | 1:M 15 Oct 2026 23:10:31.135 * Ready to accept connections tcp
+8
View File
@@ -0,0 +1,8 @@
# 2026-10-15T23:10:28Z
$ make check
python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
$ make test
python3 tests/smoke.py --base-url "http://localhost:8080"
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
+55
View File
@@ -0,0 +1,55 @@
# 2026-10-15T23:11:46Z
Docker Engine 28.0.4
Docker Compose version v2.34.0-desktop.1
$ docker compose ps
SERVICE IMAGE STATUS PORTS
api mtusi-messenger:lab2 Up 11 seconds (healthy) 127.0.0.1:8080->8080/tcp
postgres postgres:16.4-alpine Up 13 seconds (healthy) 5432/tcp
valkey valkey/valkey:8.0.2-alpine Up 13 seconds (healthy) 6379/tcp
$ docker volume ls (именованные тома стенда)
mtusi-lab2_pgdata
$ Valkey: persistence выключено намеренно (кэш, источник истины — PostgreSQL)
save
appendonly no
maxmemory-policy allkeys-lru
$ Valkey без пароля не отвечает:
NOAUTH Authentication required.
$ процесс API — PID 1, не root
uid=10001(app) gid=10001(app) groups=10001(app)
python /app/src/server.py
$ git status --short --ignored
M .env.example
M Makefile
M REPORT.md
?? Dockerfile
?? compose.yaml
?? evidence/cache-bench.txt
?? evidence/database.txt
?? evidence/explain.txt
?? evidence/persistence.txt
?? evidence/smoke.txt
?? evidence/stack.txt
?? evidence/student-tests.txt
?? migrations/
?? requirements.txt
?? scripts/init-secrets.sh
?? scripts/restart.sh
?? src/
?? student-tests/
!! .env
!! secrets/
!! src/__pycache__/
!! student-tests/__pycache__/
$ git check-ignore secrets/* .env
secrets/cache_url
secrets/database_url
secrets/postgres_password
secrets/valkey.conf
.env
+108
View File
@@ -0,0 +1,108 @@
# 2026-10-15T23:10:42Z
$ python3 student-tests/test_lab2.py --expiry-url http://localhost:8081 --db-outage --cache --persistence
OK регистрация без password -> 400 (ожидалось 400)
OK password 11 символов -> 400 (ожидалось 400)
OK password 129 символов -> 400 (ожидалось 400)
OK password не строка -> 400 (ожидалось 400)
OK дубликат username -> 409 (ожидалось 409)
OK User не содержит пароль/хеш -> ['created_at', 'display_name', 'id', 'us… (ожидалось ['created_at', 'display_name', 'id', 'us…)
OK malformed JSON -> 400 (ожидалось 400)
OK неверный пароль -> 401 (ожидалось 401)
OK challenge Basic -> True (ожидалось True)
OK неизвестный пользователь -> 401 (ожидалось 401)
OK вход без Authorization -> 401 (ожидалось 401)
OK вход с Bearer вместо Basic -> 401 (ожидалось 401)
OK мусор вместо base64 -> 401 (ожидалось 401)
OK пароль с двоеточием и Unicode -> 50babb13-8c3d-4066-9146-f2961f042e25 (ожидалось 50babb13-8c3d-4066-9146-f2961f042e25)
OK два входа дают разные токены -> True (ожидалось True)
OK без токена -> 401 (ожидалось 401)
OK challenge Bearer -> True (ожидалось True)
OK случайный токен -> 401 (ожидалось 401)
OK Basic на бизнес-endpoint -> 401 (ожидалось 401)
OK только X-User-Id -> 401 (ожидалось 401)
OK X-User-Id не меняет владельца -> 50babb13-8c3d-4066-9146-f2961f042e25 (ожидалось 50babb13-8c3d-4066-9146-f2961f042e25)
OK logout -> 204 (ожидалось 204)
OK отозванный токен -> 401 (ожидалось 401)
OK повторный logout -> 401 (ожидалось 401)
OK другая сессия того же пользователя жива -> 200 (ожидалось 200)
OK чат: создатель не участник -> 400 (ожидалось 400)
OK чат: неизвестный участник -> 400 (ожидалось 400)
OK чат: дубликат участника -> 400 (ожидалось 400)
OK порядок member_ids сохранён -> ['50babb13-8c3d-4066-9146-f2961f042e25',… (ожидалось ['50babb13-8c3d-4066-9146-f2961f042e25',…)
OK чужой чат (Ева) -> 404 (ожидалось 404)
OK запись в чужой чат (Ева) -> 404 (ожидалось 404)
OK пустое сообщение -> 400 (ожидалось 400)
OK sender_id в теле -> 400 (ожидалось 400)
OK 4001 символ -> 400 (ожидалось 400)
OK 100 параллельных POST: ошибок -> 0 (ожидалось 0)
OK 100 параллельных POST: уникальных -> 100 (ожидалось 100)
OK история отсортирована (created_at, id) -> True (ожидалось True)
OK cursor от другого чата -> 400 (ожидалось 400)
OK мусорный cursor -> 400 (ожидалось 400)
OK limit=0 -> 400 (ожидалось 400)
OK неверный UUID в пути -> 400 (ожидалось 400)
OK гонка 20 регистраций: ровно один 201 -> 1 (ожидалось 1)
OK гонка 20 регистраций: остальные 409 -> 19 (ожидалось 19)
OK чат с неизвестным 3-м участником -> 400 (ожидалось 400)
OK после ошибки чат не появился у создателя -> [] (ожидалось [])
OK после ошибки чат не появился у участника b -> ['f719daa9-38c4-45b4-9e11-72582a3ab25d'] (ожидалось ['f719daa9-38c4-45b4-9e11-72582a3ab25d'])
OK следующее создание чата работает -> (201, ['50f22c4f-7abb-4395-9921-1bb23c95… (ожидалось (201, ['50f22c4f-7abb-4395-9921-1bb23c95…)
OK TTL=2: вход -> 201 (ожидалось 201)
OK TTL=2: сразу после входа токен работает -> 200 (ожидалось 200)
OK TTL=2: через 3 с токен истёк -> 401 (ожидалось 401)
OK challenge Bearer -> True (ожидалось True)
OK TTL=2: истёкший токен не работает и на основном API -> 401 (ожидалось 401)
--- остановка PostgreSQL: docker compose stop postgres
OK БД нет: /health/ready -> (503, 'unavailable') (ожидалось (503, 'unavailable'))
OK БД нет: /health/live -> 200 (ожидалось 200)
OK БД нет: список чатов с токеном -> 503, не 200 -> (503, 'unavailable') (ожидалось (503, 'unavailable'))
OK БД нет: ответ ограничен по времени (<10 с) -> True (ожидалось True)
OK БД нет: /users/me -> 200 из кэша или 503 -> True (ожидалось True)
OK БД нет: неизвестный токен не проходит -> True (ожидалось True)
OK БД нет: анонимный запрос не проходит -> True (ожидалось True)
OK БД нет: вход -> 503 -> 503 (ожидалось 503)
OK БД вернулась: прежний токен работает -> {'id': '50babb13-8c3d-4066-9146-f2961f04… (ожидалось {'id': '50babb13-8c3d-4066-9146-f2961f04…)
OK кэш: после входа в Valkey лежит копия сессии -> True (ожидалось True)
OK кэш: в Valkey нет самого токена/пароля -> True (ожидалось True)
OK кэш: 50 запросов -> 50 попаданий в Valkey -> (50, 0) (ожидалось (50, 0))
OK кэш: logout -> 204 (ожидалось 204)
OK кэш: в Valkey tombstone вместо копии -> revoked (ожидалось revoked)
OK кэш: отозванный токен сразу 401 -> 401 (ожидалось 401)
OK FLUSHALL: действующий токен работает (из БД) -> {'id': '547cea17-7447-4159-8601-17f1e477… (ожидалось {'id': '547cea17-7447-4159-8601-17f1e477…)
OK FLUSHALL: отозванный токен по-прежнему 401 -> 401 (ожидалось 401)
OK FLUSHALL: кэш снова заполнен после промаха -> True (ожидалось True)
--- остановка Valkey: docker compose stop valkey
OK Valkey нет: /health/ready 200 (не критичен) -> 200 (ожидалось 200)
OK Valkey нет: токен работает через БД -> {'id': '547cea17-7447-4159-8601-17f1e477… (ожидалось {'id': '547cea17-7447-4159-8601-17f1e477…)
OK Valkey нет: ответ быстрый (<2 с) -> True (ожидалось True)
OK Valkey нет: список чатов -> 200 (ожидалось 200)
OK Valkey нет: без токена 401 -> 401 (ожидалось 401)
OK Valkey нет: чужой токен 401 -> 401 (ожидалось 401)
OK Valkey нет: отозванный токен 401 -> 401 (ожидалось 401)
OK Valkey нет: вход 201 -> True (ожидалось True)
OK Valkey нет: logout 204 -> 204 (ожидалось 204)
OK Valkey нет: после logout 401 -> 401 (ожидалось 401)
OK Valkey вернулся: токен работает -> {'id': '547cea17-7447-4159-8601-17f1e477… (ожидалось {'id': '547cea17-7447-4159-8601-17f1e477…)
OK Valkey вернулся: кэш снова заполняется -> True (ожидалось True)
OK Valkey вернулся: токен, отозванный при отказе, 401 -> 401 (ожидалось 401)
--- зависание Valkey во время logout: docker compose pause valkey
OK Valkey завис: logout всё равно 204 (отзыв в БД) -> 204 (ожидалось 204)
OK Valkey ожил: в нём осталась устаревшая копия -> True (ожидалось True)
OK Valkey ожил: устаревшая копия не принята, 401 -> 401 (ожидалось 401)
OK Valkey ожил: действующий токен работает -> {'id': '547cea17-7447-4159-8601-17f1e477… (ожидалось {'id': '547cea17-7447-4159-8601-17f1e477…)
--- перезапуск API и PostgreSQL: scripts/restart.sh
OK после рестарта: прежний токен работает -> {'id': '50babb13-8c3d-4066-9146-f2961f04… (ожидалось {'id': '50babb13-8c3d-4066-9146-f2961f04…)
OK после рестарта: чат на месте -> {'id': 'f719daa9-38c4-45b4-9e11-72582a3a… (ожидалось {'id': 'f719daa9-38c4-45b4-9e11-72582a3a…)
OK после рестарта: история та же -> [{'id': 'c0e23a76-540f-46db-81a4-dbee552… (ожидалось [{'id': 'c0e23a76-540f-46db-81a4-dbee552…)
OK после рестарта: отозванный токен всё ещё отозван -> 401 (ожидалось 401)
OK после рестарта: вход по паролю работает -> 201 (ожидалось 201)
ИТОГО: ВСЕ ПРОВЕРКИ ПРОШЛИ
--- журнал API во время отказов Valkey (без токенов и тел запросов):
2026-10-15 23:10:56,857 WARNING database unavailable request_id=4ab5c512a16341c4bf7cc58c88e683e3
2026-10-15 23:11:01,873 WARNING database unavailable request_id=5c558c1c14714272a4563a46f3c2a88b
2026-10-15 23:11:06,888 WARNING database unavailable request_id=a20e46964d9046cb9aacf37b77904c45
2026-10-15 23:11:18,939 WARNING cache unavailable op=get; bypassing cache for 5s
2026-10-15 23:11:19,032 WARNING cache unavailable op=revoke; bypassing cache for 5s; positive entries distrusted for 31s
2026-10-15 23:11:25,882 WARNING cache unavailable op=get; bypassing cache for 5s
2026-10-15 23:11:26,156 WARNING cache unavailable op=revoke; bypassing cache for 5s; positive entries distrusted for 31s
+51
View File
@@ -0,0 +1,51 @@
-- Lab2, миграция 001: начальная схема. Источник истины — PostgreSQL.
-- Применяется приложением один раз (таблица schema_migrations, advisory lock),
-- в одной транзакции вместе с отметкой о версии.
CREATE TABLE users (
id uuid PRIMARY KEY,
username text NOT NULL,
display_name text NOT NULL,
password_hash text NOT NULL, -- scrypt$logN$r$p$salt$hash, не plaintext
created_at timestamptz NOT NULL,
CONSTRAINT users_username_key UNIQUE (username), -- гонка регистраций решается здесь
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
CONSTRAINT users_display_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100)
);
CREATE TABLE chats (
id uuid PRIMARY KEY,
title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100),
created_at timestamptz NOT NULL
);
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id uuid NOT NULL REFERENCES users(id),
position integer NOT NULL CHECK (position >= 0), -- порядок участников как в запросе
PRIMARY KEY (chat_id, user_id) -- участник не дублируется
);
-- Список чатов пользователя: поиск членства по user_id.
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id);
CREATE TABLE messages (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id uuid NOT NULL REFERENCES users(id),
text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000),
created_at timestamptz NOT NULL
);
-- Keyset-пагинация истории: WHERE chat_id = ? AND (created_at, id) > (?, ?)
-- ORDER BY created_at, id LIMIT n — читает только нужную страницу индекса.
CREATE INDEX messages_chat_order_idx ON messages (chat_id, created_at, id);
CREATE TABLE sessions (
token_hash bytea PRIMARY KEY, -- SHA-256 от токена; сам токен не хранится
user_id uuid NOT NULL REFERENCES users(id),
created_at timestamptz NOT NULL,
expires_at timestamptz NOT NULL,
revoked_at timestamptz,
CHECK (expires_at > created_at)
);
-- Для обслуживания: удаление истёкших сессий (DELETE ... WHERE expires_at < now()).
CREATE INDEX sessions_expires_idx ON sessions (expires_at);
+4
View File
@@ -0,0 +1,4 @@
# Закреплённые версии: драйвер и пул PostgreSQL, клиент Redis-протокола для Valkey.
psycopg[binary]==3.2.3
psycopg-pool==3.2.4
redis==5.2.1
+27
View File
@@ -0,0 +1,27 @@
#!/bin/sh
# Создаёт локальные синтетические секреты для учебного стенда (каталог secrets/ в .gitignore).
# Повторный запуск не перезаписывает существующие файлы: пароль БД в volume уже задан.
set -eu
cd "$(dirname "$0")/.."
mkdir -p secrets
chmod 700 secrets
if [ ! -f secrets/postgres_password ]; then
python3 -c 'import secrets; print(secrets.token_urlsafe(24), end="")' > secrets/postgres_password
echo "created secrets/postgres_password"
fi
if [ ! -f secrets/database_url ]; then
printf 'postgresql://messenger:%s@postgres:5432/messenger' "$(cat secrets/postgres_password)" > secrets/database_url
echo "created secrets/database_url"
fi
if [ ! -f secrets/valkey.conf ]; then
# Пароль Valkey передаётся через конфиг-файл (Docker secret), а не аргументом командной строки.
VALKEY_PASSWORD=$(python3 -c 'import secrets; print(secrets.token_urlsafe(24), end="")')
printf 'requirepass %s\n' "$VALKEY_PASSWORD" > secrets/valkey.conf
printf 'redis://:%s@valkey:6379/0' "$VALKEY_PASSWORD" > secrets/cache_url
echo "created secrets/valkey.conf and secrets/cache_url"
fi
# Файлы монтируются в контейнеры как Docker secrets; процессы там работают не от uid хоста,
# поэтому файлы читаемы, а доступ ограничивает каталог secrets/ (700).
chmod 644 secrets/postgres_password secrets/database_url secrets/valkey.conf secrets/cache_url
[ -f .env ] || { cp .env.example .env; echo "created .env from .env.example"; }
echo "secrets ready (values are not printed)"
+11
View File
@@ -0,0 +1,11 @@
#!/bin/sh
# Перезапуск API и всех используемых хранилищ (PostgreSQL, Valkey) с сохранением volume pgdata.
# Не выполняет down -v, не пересоздаёт БД и не меняет данные.
set -eu
cd "$(dirname "$0")/.."
# Сначала останавливаем API, затем хранилища (PostgreSQL — штатный shutdown с checkpoint);
# поднимаем в обратном порядке. Valkey без persistence стартует с пустым кэшем.
docker compose --env-file .env stop api
docker compose --env-file .env stop postgres valkey
docker compose --env-file .env start postgres valkey
docker compose --env-file .env start api
+53
View File
@@ -0,0 +1,53 @@
"""Пароли (scrypt из стандартной библиотеки) и сессионные токены."""
import base64
import hashlib
import hmac
import os
import secrets
# Параметры scrypt: N=2^15, r=8, p=1 (~32 МБ памяти и ~0.1 с на проверку).
SCRYPT_LOG_N = 15
SCRYPT_R = 8
SCRYPT_P = 1
_MAXMEM = 128 * 1024 * 1024
def _scrypt(password, salt, log_n, r, p):
return hashlib.scrypt(password.encode("utf-8"), salt=salt, n=2 ** log_n, r=r, p=p,
maxmem=_MAXMEM, dklen=32)
def hash_password(password):
"""Возвращает строку scrypt$logN$r$p$salt$hash; plaintext нигде не хранится."""
salt = os.urandom(16)
digest = _scrypt(password, salt, SCRYPT_LOG_N, SCRYPT_R, SCRYPT_P)
return "scrypt$%d$%d$%d$%s$%s" % (
SCRYPT_LOG_N, SCRYPT_R, SCRYPT_P,
base64.b64encode(salt).decode(), base64.b64encode(digest).decode())
def verify_password(password, stored):
try:
scheme, log_n, r, p, salt, digest = stored.split("$")
if scheme != "scrypt":
return False
expected = base64.b64decode(digest)
actual = _scrypt(password, base64.b64decode(salt), int(log_n), int(r), int(p))
except (ValueError, TypeError):
return False
return hmac.compare_digest(actual, expected) # сравнение за постоянное время
# Хеш несуществующего пользователя: неверный логин тратит столько же времени,
# сколько неверный пароль, и не выдаёт, существует ли username.
DUMMY_HASH = hash_password(secrets.token_urlsafe(16))
def new_token():
"""Непрозрачный случайный токен: 32 байта = 256 бит энтропии."""
return secrets.token_urlsafe(32)
def token_hash(token):
"""В БД лежит только SHA-256 токена: утечка таблицы не даёт готовых сессий."""
return hashlib.sha256(token.encode("utf-8")).digest()
+503
View File
@@ -0,0 +1,503 @@
#!/usr/bin/env python3
"""MTUSI Messenger, lab2: REST API с PostgreSQL и сессиями.
Отличия от lab1:
* данные лежат в PostgreSQL и переживают перезапуск API и БД;
* регистрация требует password (хранится только scrypt-хеш);
* POST /api/v1/auth/sessions (Basic) выдаёт Bearer-токен;
* все защищённые endpoint принимают только Authorization: Bearer;
* X-User-Id игнорируется.
Общий каркас (маршрутизация, формат ошибок, X-Request-Id, валидация, keyset-курсор)
перенесён из lab1 (app/server.py); хранилище в памяти заменено на store.py.
"""
import base64
import binascii
import json
import logging
import os
import re
import signal
import sys
import threading
import time
import uuid
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
from urllib.parse import parse_qs, urlsplit
import psycopg
from psycopg.conninfo import make_conninfo
from psycopg_pool import PoolTimeout
import security
from session_cache import REVOKED, SessionCache
from store import Conflict, Store, UnknownMember, format_ts
HOST = os.environ.get("APP_HOST", "0.0.0.0")
PORT = int(os.environ.get("APP_PORT", "8080"))
APP_ENV = os.environ.get("APP_ENV", "lab")
SESSION_TTL_SECONDS = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
MIGRATIONS_DIR = os.environ.get("MIGRATIONS_DIR", str(Path(__file__).resolve().parents[1] / "migrations"))
MAX_BODY_BYTES = 1024 * 1024
USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$")
DEFAULT_LIMIT = 50
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
BEARER_CHALLENGE = 'Bearer realm="messenger"'
logging.basicConfig(stream=sys.stdout, level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
log = logging.getLogger("messenger")
def database_conninfo():
"""Строка подключения к PostgreSQL.
Порядок: DATABASE_URL_FILE (Docker secret, рекомендуемый путь) → DATABASE_URL →
набор POSTGRES_*. Значение секрета нигде не логируется.
"""
path = os.environ.get("DATABASE_URL_FILE")
if path:
url = Path(path).read_text(encoding="utf-8").strip()
else:
url = os.environ.get("DATABASE_URL", "")
if url:
# connect_timeout ограничивает ожидание недоступной БД при открытии соединения.
return make_conninfo(url, connect_timeout=5)
return make_conninfo(
host=os.environ.get("POSTGRES_HOST", "localhost"),
port=os.environ.get("POSTGRES_PORT", "5432"),
dbname=os.environ.get("POSTGRES_DB", "messenger"),
user=os.environ.get("POSTGRES_USER", "messenger"),
password=os.environ.get("POSTGRES_PASSWORD", ""),
connect_timeout=5,
)
STORE = Store(database_conninfo(),
pool_size=int(os.environ.get("DB_POOL_SIZE", "10")),
statement_timeout_ms=int(os.environ.get("DB_STATEMENT_TIMEOUT_MS", "5000")))
def cache_url():
"""URL Valkey из CACHE_URL_FILE (Docker secret). SESSION_CACHE=off отключает кэш."""
if os.environ.get("SESSION_CACHE", "valkey").lower() == "off":
return ""
path = os.environ.get("CACHE_URL_FILE")
if path:
return Path(path).read_text(encoding="utf-8").strip()
return os.environ.get("CACHE_URL", "")
SESSION_CACHE = SessionCache(
cache_url(),
ttl_seconds=int(os.environ.get("SESSION_CACHE_TTL_SECONDS", "30")),
timeout_ms=int(os.environ.get("CACHE_TIMEOUT_MS", "250")),
retry_seconds=float(os.environ.get("CACHE_RETRY_SECONDS", "5")))
# --------------------------------------------------------------------------
# Ошибки API
# --------------------------------------------------------------------------
class ApiError(Exception):
def __init__(self, status, code, message, headers=None):
super().__init__(message)
self.status = status
self.code = code
self.message = message
self.headers = headers or {}
def bad_request(message="Неверный запрос"):
return ApiError(400, "invalid_request", message)
def unauthorized(challenge=BEARER_CHALLENGE):
# Одинаковый ответ для любых причин: не раскрываем, что именно не так.
return ApiError(401, "unauthorized", "Требуется действительная аутентификация",
{"WWW-Authenticate": challenge})
def not_found():
return ApiError(404, "not_found", "Объект не найден")
# --------------------------------------------------------------------------
# Валидация
# --------------------------------------------------------------------------
def parse_uuid(value):
try:
return str(uuid.UUID(value))
except (ValueError, TypeError, AttributeError):
return None
def require_object(body, allowed, required):
if not isinstance(body, dict):
raise bad_request("Тело запроса должно быть JSON-объектом")
if set(body) - set(allowed):
raise bad_request("Лишние поля в запросе")
if any(k not in body for k in required):
raise bad_request("Не хватает обязательных полей")
def require_text(value, field, max_len, min_len=1):
if not isinstance(value, str):
raise bad_request("Поле %s должно быть строкой" % field)
if not value.strip():
raise bad_request("Поле %s не должно быть пустым" % field)
if "\x00" in value:
raise bad_request("Поле %s содержит недопустимый символ" % field)
if not min_len <= len(value) <= max_len: # len() считает Unicode code points
raise bad_request("Поле %s имеет недопустимую длину" % field)
return value
def encode_cursor(kind, scope, key):
raw = json.dumps({"k": kind, "s": scope, "t": key[0], "i": key[1]}, separators=(",", ":"))
return base64.urlsafe_b64encode(raw.encode()).decode().rstrip("=")
def decode_cursor(cursor, kind, scope):
try:
padded = cursor + "=" * (-len(cursor) % 4)
data = json.loads(base64.urlsafe_b64decode(padded.encode("ascii")))
if data["k"] != kind or data["s"] != scope:
raise ValueError
t, i = data["t"], parse_uuid(data["i"])
if not isinstance(t, int) or isinstance(t, bool) or i is None or abs(t) > 10 ** 17:
raise ValueError
return (t, i)
except (ValueError, KeyError, TypeError, UnicodeError, binascii.Error):
raise bad_request("Неверный cursor")
def page_params(query):
def single(name):
values = query.get(name)
if values is None:
return None
if len(values) != 1:
raise bad_request("Параметр %s указан несколько раз" % name)
return values[0]
limit_raw = single("limit")
if limit_raw is None:
limit = DEFAULT_LIMIT
else:
if not re.fullmatch(r"[0-9]{1,3}", limit_raw) or not 1 <= int(limit_raw) <= 100:
raise bad_request("limit должен быть целым от 1 до 100")
limit = int(limit_raw)
cursor = single("cursor")
if cursor == "":
raise bad_request("Неверный cursor")
return limit, cursor
# --------------------------------------------------------------------------
# Обработчики
# --------------------------------------------------------------------------
def h_live(req):
return 200, {"status": "ok"}
def h_ready(req):
# Критичная зависимость одна — PostgreSQL. Без неё обслуживать запросы нельзя.
# Valkey не критичен: при его отказе сессии проверяются напрямую в PostgreSQL.
try:
STORE.ping()
except Exception:
raise ApiError(503, "unavailable", "Сервис временно недоступен")
return 200, {"status": "ok"}
def h_create_user(req):
body = req.json_body()
fields = ("username", "display_name", "password")
require_object(body, fields, fields)
username = body["username"]
if not isinstance(username, str) or not USERNAME_RE.fullmatch(username):
raise bad_request("username должен соответствовать [a-z0-9_]{3,32}")
display_name = require_text(body["display_name"], "display_name", 100)
password = require_text(body["password"], "password", 128, min_len=12)
try:
return 201, STORE.create_user(username, display_name, security.hash_password(password))
except Conflict:
raise ApiError(409, "conflict", "Имя пользователя уже занято")
def h_create_session(req):
"""Вход: только Authorization: Basic, без JSON body."""
header = req.headers.get("Authorization", "")
scheme, _, encoded = header.partition(" ")
failure = unauthorized(BASIC_CHALLENGE)
if scheme.lower() != "basic":
raise failure
try:
decoded = base64.b64decode(encoded.strip(), validate=True).decode("utf-8")
except (binascii.Error, ValueError, UnicodeError):
raise failure
username, sep, password = decoded.partition(":") # двоеточие в пароле допустимо
if not sep:
raise failure
user, stored_hash = (None, None)
if USERNAME_RE.fullmatch(username):
user, stored_hash = STORE.get_credentials(username)
# Проверяем scrypt всегда (для неизвестного логина — с фиктивным хешем):
# время ответа не выдаёт, существует ли пользователь.
ok = security.verify_password(password, stored_hash or security.DUMMY_HASH)
if user is None or not ok:
raise failure
token = security.new_token()
th = security.token_hash(token)
started = time.monotonic()
expires_at = STORE.create_session(user["id"], th, SESSION_TTL_SECONDS) # источник истины
SESSION_CACHE.put(th, user, expires_at.timestamp(), started) # прогрев кэша
return 201, {"token": token, "token_type": "Bearer", "expires_at": format_ts(expires_at), "user": user}
def h_delete_session(req):
req.current_user()
STORE.revoke_session(req.token_hash) # 1) COMMIT отзыва в PostgreSQL
SESSION_CACHE.revoke(req.token_hash) # 2) tombstone в Valkey поверх возможной копии
return 204, None
def h_me(req):
return 200, req.current_user()
def h_create_chat(req):
user = req.current_user()
body = req.json_body()
require_object(body, ("title", "member_ids"), ("title", "member_ids"))
title = require_text(body["title"], "title", 100)
members = body["member_ids"]
if not isinstance(members, list) or not 1 <= len(members) <= 100:
raise bad_request("member_ids должен быть списком из 1–100 UUID")
normalized = []
for m in members:
mid = parse_uuid(m) if isinstance(m, str) else None
if mid is None:
raise bad_request("member_ids должен содержать UUID-строки")
normalized.append(mid)
if len(set(normalized)) != len(normalized):
raise bad_request("Дубликаты в member_ids")
if user["id"] not in normalized:
raise bad_request("Создатель должен входить в member_ids")
try:
return 201, STORE.create_chat(title, normalized)
except UnknownMember:
raise bad_request("Неизвестный участник чата")
def h_list_chats(req):
user = req.current_user()
limit, cursor = page_params(req.query)
after = decode_cursor(cursor, "chats", user["id"]) if cursor else None
items, last = STORE.list_chats(user["id"], after, limit)
return 200, {"items": items, "next_cursor": encode_cursor("chats", user["id"], last) if last else None}
def _chat_or_404(user, chat_id):
chat = STORE.get_chat_for(user["id"], chat_id)
if chat is None:
raise not_found()
return chat
def h_get_chat(req, chat_id):
user = req.current_user()
return 200, _chat_or_404(user, req.path_uuid(chat_id))
def h_create_message(req, chat_id):
user = req.current_user()
cid = req.path_uuid(chat_id)
_chat_or_404(user, cid) # сначала доступ: посторонний получает 404
body = req.json_body()
require_object(body, ("text",), ("text",))
text = require_text(body["text"], "text", 4000)
message = STORE.add_message(user["id"], cid, text)
if message is None:
raise not_found()
return 201, message
def h_list_messages(req, chat_id):
user = req.current_user()
cid = req.path_uuid(chat_id)
_chat_or_404(user, cid)
limit, cursor = page_params(req.query)
after = decode_cursor(cursor, "messages", cid) if cursor else None
items, last = STORE.list_messages(cid, after, limit)
return 200, {"items": items, "next_cursor": encode_cursor("messages", cid, last) if last else None}
ROUTES = [
("GET", re.compile(r"^/health/live$"), h_live),
("GET", re.compile(r"^/health/ready$"), h_ready),
("POST", re.compile(r"^/api/v1/users$"), h_create_user),
("GET", re.compile(r"^/api/v1/users/me$"), h_me),
("POST", re.compile(r"^/api/v1/auth/sessions$"), h_create_session),
("DELETE", re.compile(r"^/api/v1/auth/sessions/current$"), h_delete_session),
("POST", re.compile(r"^/api/v1/chats$"), h_create_chat),
("GET", re.compile(r"^/api/v1/chats$"), h_list_chats),
("GET", re.compile(r"^/api/v1/chats/([^/]+)$"), h_get_chat),
("POST", re.compile(r"^/api/v1/chats/([^/]+)/messages$"), h_create_message),
("GET", re.compile(r"^/api/v1/chats/([^/]+)/messages$"), h_list_messages),
]
class Handler(BaseHTTPRequestHandler):
protocol_version = "HTTP/1.1"
server_version = "mtusi-messenger/2.0"
sys_version = ""
def json_body(self):
ctype = (self.headers.get("Content-Type") or "").split(";")[0].strip().lower()
if ctype != "application/json":
raise ApiError(415, "unsupported_media_type", "Ожидается Content-Type: application/json")
try:
return json.loads(self._body.decode("utf-8"))
except (UnicodeDecodeError, ValueError):
raise bad_request("Некорректный JSON")
def current_user(self):
"""Только Bearer-токен действующей сессии. Basic и X-User-Id доступа не дают."""
scheme, _, token = self.headers.get("Authorization", "").partition(" ")
token = token.strip()
if scheme.lower() != "bearer" or not token:
raise unauthorized()
self.token_hash = security.token_hash(token)
cached = SESSION_CACHE.get(self.token_hash) # 1) Valkey: hit / tombstone / промах
if cached is REVOKED:
raise unauthorized()
if cached is not None:
return cached
started = time.monotonic()
found = STORE.get_session_user(self.token_hash) # 2) промах → PostgreSQL
if found is None:
raise unauthorized()
user, expires_at = found
SESSION_CACHE.put(self.token_hash, user, expires_at.timestamp(), started)
return user
def path_uuid(self, value):
parsed = parse_uuid(value)
if parsed is None:
raise bad_request("Неверный UUID в пути")
return parsed
def _read_body(self):
length = self.headers.get("Content-Length")
if length is None:
return b""
try:
n = int(length)
except ValueError:
raise bad_request("Неверный Content-Length")
if n < 0:
raise bad_request("Неверный Content-Length")
if n > MAX_BODY_BYTES:
self.close_connection = True
raise ApiError(413, "payload_too_large", "Тело запроса слишком большое")
return self.rfile.read(n)
def _dispatch(self, method):
self.request_id = uuid.uuid4().hex
started = time.monotonic()
parts = urlsplit(self.path)
path = parts.path
headers = {}
try:
self._body = self._read_body()
self.query = parse_qs(parts.query, keep_blank_values=True)
for m, pattern, func in ROUTES:
match = pattern.match(path)
if match and m == method:
status, payload = func(self, *match.groups())
break
else:
raise not_found()
except ApiError as err:
status, payload, headers = err.status, self._error(err.code, err.message), err.headers
except (psycopg.OperationalError, PoolTimeout):
# БД недоступна: честный 503, а не «успех» или 500.
log.warning("database unavailable request_id=%s", self.request_id)
status, payload = 503, self._error("unavailable", "Сервис временно недоступен")
except Exception:
log.exception("unhandled error request_id=%s", self.request_id)
status, payload = 500, self._error("internal_error", "Внутренняя ошибка сервера")
self._send(status, payload, headers)
# В лог не попадают тела запросов, пароли, токены и тексты сообщений.
log.info("%s %s -> %d %.1fms request_id=%s", method, path, status,
(time.monotonic() - started) * 1000, self.request_id)
def _error(self, code, message):
return {"error": {"code": code, "message": message, "request_id": self.request_id}}
def _send(self, status, payload, headers):
self.send_response(status)
self.send_header("X-Request-Id", self.request_id)
for name, value in headers.items():
self.send_header(name, value)
if payload is None: # 204: без тела
self.end_headers()
return
data = json.dumps(payload, ensure_ascii=False).encode("utf-8")
self.send_header("Content-Type", "application/json; charset=utf-8")
self.send_header("Content-Length", str(len(data)))
self.end_headers()
self.wfile.write(data)
def do_GET(self):
self._dispatch("GET")
def do_POST(self):
self._dispatch("POST")
def do_PUT(self):
self._dispatch("PUT")
def do_PATCH(self):
self._dispatch("PATCH")
def do_DELETE(self):
self._dispatch("DELETE")
def log_message(self, fmt, *args):
pass
class Server(ThreadingHTTPServer):
request_queue_size = 1024
daemon_threads = True
def main():
STORE.open()
STORE.migrate(MIGRATIONS_DIR)
if "--migrate-only" in sys.argv[1:]:
# Отдельный запуск миграций: docker compose run --rm api python /app/src/server.py --migrate-only
log.info("migrations are up to date, exiting (--migrate-only)")
STORE.close()
return
server = Server((HOST, PORT), Handler)
def stop(signum, frame):
log.info("signal %d received, shutting down", signum)
threading.Thread(target=server.shutdown, daemon=True).start()
signal.signal(signal.SIGTERM, stop)
signal.signal(signal.SIGINT, stop)
log.info("listening on %s:%d env=%s session_ttl=%ds session_cache=%s", HOST, PORT, APP_ENV,
SESSION_TTL_SECONDS, "valkey" if SESSION_CACHE.enabled else "off")
server.serve_forever()
server.server_close()
STORE.close()
log.info("stopped")
if __name__ == "__main__":
main()
+121
View File
@@ -0,0 +1,121 @@
"""Кэш сессий в Valkey (уровень 4).
Роль: ускорить проверку Bearer-токена, которая выполняется на КАЖДОМ защищённом запросе.
Источник истины — таблица sessions в PostgreSQL; Valkey хранит только производные копии.
Ключ: sess:<sha256(token) hex> (сам токен в Valkey не попадает)
Значение: {"user": {...}, "exp": <unix-время истечения сессии>} либо "revoked"
Политика expiry:
* положительная запись живёт min(SESSION_CACHE_TTL_SECONDS, остаток сессии) — PX в мс,
поэтому кэш не переживает саму сессию; при чтении "exp" дополнительно сверяется с часами;
* запись "revoked" (tombstone) живёт SESSION_CACHE_TTL_SECONDS + 1 с — дольше любой
положительной записи, созданной до отзыва.
Инвалидация (logout): сначала UPDATE sessions SET revoked_at в PostgreSQL (COMMIT), затем
SET sess:<h> "revoked" поверх положительной записи. Заполнение кэша после промаха делается
SET NX, поэтому конкурентный запрос, прочитавший БД до отзыва, не может перезаписать tombstone.
Отказ Valkey: любая ошибка/таймаут (по умолчанию 250 мс) → запрос обслуживается из PostgreSQL,
кэш обходится CACHE_RETRY_SECONDS секунд (простой circuit breaker). Если не удалось записать
tombstone, процесс SESSION_CACHE_TTL_SECONDS+1 секунд не доверяет положительным записям кэша:
устаревшая запись могла остаться в Valkey, но за это время она гарантированно истечёт.
"""
import json
import logging
import threading
import time
import redis
log = logging.getLogger("messenger.cache")
PREFIX = "sess:"
REVOKED = object() # результат get(): сессия отозвана (tombstone)
MISS = None # результат get(): нет данных/кэш недоступен → идти в PostgreSQL
_TOMBSTONE = b"revoked"
class SessionCache:
def __init__(self, url, ttl_seconds=30, timeout_ms=250, retry_seconds=5.0, pool_size=10):
self.enabled = bool(url)
self.ttl = ttl_seconds
self.retry_seconds = retry_seconds
self._lock = threading.Lock()
self._skip_until = 0.0 # circuit breaker: до этого момента кэш не опрашиваем
self._distrust_until = 0.0 # до этого момента положительные записи игнорируем
self.client = None
if self.enabled:
timeout = timeout_ms / 1000.0
# Ограниченный пул: не более pool_size соединений, ожидание свободного — timeout.
pool = redis.BlockingConnectionPool.from_url(
url, max_connections=pool_size, timeout=timeout,
socket_timeout=timeout, socket_connect_timeout=timeout)
self.client = redis.Redis(connection_pool=pool)
# --- служебное ---
def _available(self):
return self.enabled and time.monotonic() >= self._skip_until
def _failed(self, op, invalidation=False):
now = time.monotonic()
with self._lock:
self._skip_until = now + self.retry_seconds
if invalidation:
self._distrust_until = max(self._distrust_until, now + self.ttl + 1)
log.warning("cache unavailable op=%s; bypassing cache for %.0fs%s", op, self.retry_seconds,
"; positive entries distrusted for %ds" % (self.ttl + 1) if invalidation else "")
@staticmethod
def _key(token_hash):
return PREFIX + token_hash.hex()
# --- API ---
def get(self, token_hash):
"""Пользователь из кэша, REVOKED или MISS."""
if not self._available():
return MISS
try:
raw = self.client.get(self._key(token_hash))
except redis.RedisError:
self._failed("get")
return MISS
if raw is None:
return MISS
if raw == _TOMBSTONE:
return REVOKED
if time.monotonic() < self._distrust_until:
return MISS
try:
data = json.loads(raw)
if data["exp"] <= time.time():
return MISS
return data["user"]
except (ValueError, KeyError, TypeError):
return MISS
def put(self, token_hash, user, expires_epoch, read_started):
"""Заполнить кэш после чтения действующей сессии из PostgreSQL."""
if not self._available():
return
# Если между чтением БД и записью в кэш прошло подозрительно много времени,
# данные могли устареть (например, logout + истечение tombstone) — не кэшируем.
if time.monotonic() - read_started > 1.0:
return
ttl_ms = int(min(self.ttl, expires_epoch - time.time()) * 1000)
if ttl_ms <= 0:
return
value = json.dumps({"user": user, "exp": expires_epoch}, separators=(",", ":"))
try:
self.client.set(self._key(token_hash), value, px=ttl_ms, nx=True)
except redis.RedisError:
self._failed("set")
def revoke(self, token_hash):
"""Tombstone после COMMIT отзыва в PostgreSQL. Пробуем даже при открытом breaker."""
if not self.enabled:
return
try:
self.client.set(self._key(token_hash), _TOMBSTONE, ex=self.ttl + 1)
except redis.RedisError:
self._failed("revoke", invalidation=True)
+271
View File
@@ -0,0 +1,271 @@
"""Работа с PostgreSQL: пользователи, чаты, сообщения, сессии.
Источник истины — база данных. В памяти процесса состояния нет, поэтому
перезапуск API (и самой БД с сохранённым volume) не теряет данные.
"""
import datetime as dt
import logging
import time
import uuid
from pathlib import Path
import psycopg
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool
log = logging.getLogger("messenger.store")
EPOCH = dt.datetime(1970, 1, 1, tzinfo=dt.timezone.utc)
MIGRATIONS_LOCK_ID = 727001 # произвольный номер advisory-блокировки для миграций
class Conflict(Exception):
pass
class UnknownMember(Exception):
pass
def format_ts(value):
"""datetime -> RFC 3339 UTC с микросекундами и суффиксом Z."""
return value.astimezone(dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
def to_micros(value):
delta = value - EPOCH
return (delta.days * 86400 + delta.seconds) * 1_000_000 + delta.microseconds
def from_micros(micros):
return EPOCH + dt.timedelta(microseconds=micros)
def _user(row):
# Пароль/hash и сессионные данные никогда не входят в User.
return {
"id": str(row["id"]),
"username": row["username"],
"display_name": row["display_name"],
"created_at": format_ts(row["created_at"]),
}
def _chat(row):
return {
"id": str(row["id"]),
"title": row["title"],
"member_ids": [str(m) for m in row["member_ids"]],
"created_at": format_ts(row["created_at"]),
}
def _message(row):
return {
"id": str(row["id"]),
"chat_id": str(row["chat_id"]),
"sender_id": str(row["sender_id"]),
"text": row["text"],
"created_at": format_ts(row["created_at"]),
}
CHAT_COLUMNS = """c.id, c.title, c.created_at,
(SELECT array_agg(m.user_id ORDER BY m.position) FROM chat_members m WHERE m.chat_id = c.id) AS member_ids"""
class Store:
def __init__(self, conninfo, pool_size=10, statement_timeout_ms=5000):
# Ограниченный пул: не более pool_size соединений; ожидание свободного — до 5 с,
# затем PoolTimeout → 503. statement_timeout обрывает зависший SQL.
# check: перед выдачей соединение проверяется. После перезапуска PostgreSQL
# «мёртвые» соединения отбрасываются, и запрос не получает ложный 503.
self.pool = ConnectionPool(
conninfo, min_size=1, max_size=pool_size, timeout=5,
kwargs={"row_factory": dict_row,
"options": "-c statement_timeout=%d" % statement_timeout_ms},
open=False,
check=ConnectionPool.check_connection)
# --- запуск ---
def open(self, wait_seconds=60):
"""Ждём готовности БД (она может стартовать дольше API) и открываем пул."""
self.pool.open()
deadline = time.monotonic() + wait_seconds
while True:
try:
with self.pool.connection() as conn:
conn.execute("SELECT 1")
return
except Exception as exc:
if time.monotonic() > deadline:
raise
log.info("database is not ready yet (%s), retrying", type(exc).__name__)
time.sleep(1)
def close(self):
self.pool.close()
def migrate(self, directory):
"""Применяет *.sql по порядку имён; каждая миграция — одна транзакция, один раз."""
files = sorted(Path(directory).glob("*.sql"))
with self.pool.connection() as conn:
# Advisory-блокировка (сессионная): несколько процессов не применят миграции одновременно.
conn.autocommit = True
conn.execute("SELECT pg_advisory_lock(%s)", (MIGRATIONS_LOCK_ID,))
try:
conn.execute("""CREATE TABLE IF NOT EXISTS schema_migrations (
version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())""")
done = {r["version"] for r in conn.execute("SELECT version FROM schema_migrations")}
for path in files:
if path.name in done:
continue
# Каждая миграция и её отметка — одна транзакция: либо целиком, либо никак.
with conn.transaction():
conn.execute(path.read_text(encoding="utf-8"))
conn.execute("INSERT INTO schema_migrations (version) VALUES (%s)", (path.name,))
log.info("migration applied: %s", path.name)
log.info("schema version: %s", files[-1].name if files else "none")
finally:
conn.execute("SELECT pg_advisory_unlock(%s)", (MIGRATIONS_LOCK_ID,))
conn.autocommit = False
def ping(self):
with self.pool.connection() as conn:
conn.execute("SELECT 1")
# --- пользователи ---
def create_user(self, username, display_name, password_hash):
try:
with self.pool.connection() as conn:
row = conn.execute(
"""INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES (%s, %s, %s, %s, clock_timestamp())
RETURNING id, username, display_name, created_at""",
(uuid.uuid4(), username, display_name, password_hash)).fetchone()
except psycopg.errors.UniqueViolation:
# Уникальность гарантирует сама БД — гонка двух регистраций безопасна.
raise Conflict()
return _user(row)
def get_credentials(self, username):
with self.pool.connection() as conn:
row = conn.execute(
"SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = %s",
(username,)).fetchone()
if row is None:
return None, None
return _user(row), row["password_hash"]
# --- сессии ---
def create_session(self, user_id, token_hash, ttl_seconds):
with self.pool.connection() as conn:
row = conn.execute(
"""INSERT INTO sessions (token_hash, user_id, created_at, expires_at)
VALUES (%s, %s, now(), now() + make_interval(secs => %s))
RETURNING expires_at""",
(token_hash, user_id, ttl_seconds)).fetchone()
return row["expires_at"]
def get_session_user(self, token_hash):
"""(пользователь, expires_at) действующей сессии или None (неизвестна/истекла/отозвана)."""
with self.pool.connection() as conn:
row = conn.execute(
"""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 = %s AND s.revoked_at IS NULL AND s.expires_at > now()""",
(token_hash,)).fetchone()
return (_user(row), row["expires_at"]) if row else None
def revoke_session(self, token_hash):
with self.pool.connection() as conn:
conn.execute(
"UPDATE sessions SET revoked_at = now() WHERE token_hash = %s AND revoked_at IS NULL",
(token_hash,))
# --- чаты ---
def create_chat(self, title, member_ids):
"""Чат и его участники создаются в одной транзакции (атомарно)."""
chat_id = uuid.uuid4()
# Блок `with pool.connection()` = одна транзакция: COMMIT при выходе без исключения,
# ROLLBACK при любом исключении. Чат без участников (или наоборот) не появится.
try:
with self.pool.connection() as conn:
found = conn.execute(
"SELECT count(*) AS n FROM users WHERE id = ANY(%s::uuid[])", (member_ids,)).fetchone()["n"]
if found != len(member_ids):
raise UnknownMember()
conn.execute(
"INSERT INTO chats (id, title, created_at) VALUES (%s, %s, clock_timestamp())",
(chat_id, title))
with conn.cursor() as cur:
cur.executemany(
"INSERT INTO chat_members (chat_id, user_id, position) VALUES (%s, %s, %s)",
[(chat_id, m, i) for i, m in enumerate(member_ids)])
row = conn.execute("SELECT " + CHAT_COLUMNS + " FROM chats c WHERE c.id = %s", (chat_id,)).fetchone()
except psycopg.errors.ForeignKeyViolation:
# Внешний ключ — последняя линия защиты: транзакция откатывается целиком.
raise UnknownMember()
return _chat(row)
def get_chat_for(self, user_id, chat_id):
"""Чат, если пользователь — участник; иначе None (чужой и несуществующий неразличимы)."""
with self.pool.connection() as conn:
row = conn.execute(
"SELECT " + CHAT_COLUMNS + """ FROM chats c
WHERE c.id = %s AND EXISTS (
SELECT 1 FROM chat_members m WHERE m.chat_id = c.id AND m.user_id = %s)""",
(chat_id, user_id)).fetchone()
return _chat(row) if row else None
def list_chats(self, user_id, after, limit):
params = [user_id]
where = ""
if after:
where = "AND (c.created_at, c.id) > (%s, %s::uuid)"
params += [from_micros(after[0]), after[1]]
params.append(limit + 1) # +1 запись: узнаём, есть ли следующая страница
with self.pool.connection() as conn:
rows = conn.execute(
"SELECT " + CHAT_COLUMNS + """ FROM chats c
JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s
WHERE true """ + where + " ORDER BY c.created_at, c.id LIMIT %s", params).fetchall()
return self._page(rows, limit, _chat)
# --- сообщения ---
def add_message(self, user_id, chat_id, text):
with self.pool.connection() as conn:
# FOR UPDATE по строке чата: вставки в один чат идут по очереди, поэтому
# created_at растёт в порядке фиксации и keyset-курсор не пропускает записи.
allowed = conn.execute(
"""SELECT 1 FROM chats c WHERE c.id = %s AND EXISTS (
SELECT 1 FROM chat_members m WHERE m.chat_id = c.id AND m.user_id = %s)
FOR UPDATE OF c""", (chat_id, user_id)).fetchone()
if allowed is None:
return None
row = conn.execute(
"""INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES (%s, %s, %s, %s, clock_timestamp())
RETURNING id, chat_id, sender_id, text, created_at""",
(uuid.uuid4(), chat_id, user_id, text)).fetchone()
return _message(row)
def list_messages(self, chat_id, after, limit):
params = [chat_id]
where = ""
if after:
where = "AND (created_at, id) > (%s, %s::uuid)"
params += [from_micros(after[0]), after[1]]
params.append(limit + 1)
with self.pool.connection() as conn:
rows = conn.execute(
"SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = %s "
+ where + " ORDER BY created_at, id LIMIT %s", params).fetchall()
return self._page(rows, limit, _message)
@staticmethod
def _page(rows, limit, convert):
has_more = len(rows) > limit
rows = rows[:limit]
last = (to_micros(rows[-1]["created_at"]), str(rows[-1]["id"])) if rows and has_more else None
return [convert(r) for r in rows], last
+72
View File
@@ -0,0 +1,72 @@
#!/usr/bin/env python3
"""Польза кэша сессий: нагрузка на PostgreSQL и задержка проверки токена.
python3 student-tests/cache_bench.py --label valkey [--requests 1000]
Делает N последовательных GET /api/v1/users/me одним токеном и считает:
* прирост xact_commit в pg_stat_database (сколько транзакций выполнила БД);
* p50/p95 задержки.
Сравнение: запустить при SESSION_CACHE=valkey и при SESSION_CACHE=off (см. REPORT.md).
Фоновый шум: healthcheck API (~1 SELECT 1 раз в 5 с).
"""
import argparse
import base64
import json
import statistics
import subprocess
import time
import urllib.request
import uuid
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
p = argparse.ArgumentParser()
p.add_argument("--base-url", default="http://localhost:8080")
p.add_argument("--label", required=True)
p.add_argument("--requests", type=int, default=1000)
args = p.parse_args()
BASE = args.base_url.rstrip("/")
def api(method, path, body=None, headers=None):
h = dict(headers or {})
data = json.dumps(body).encode() if body is not None else None
if data:
h["Content-Type"] = "application/json"
with urllib.request.urlopen(urllib.request.Request(BASE + path, data=data, headers=h, method=method),
timeout=30) as r:
return json.loads(r.read() or b"null")
def commits():
time.sleep(1.5) # статистика PostgreSQL публикуется с задержкой до ~1 с
out = subprocess.run(
["docker", "compose", "--env-file", str(ROOT / ".env"), "exec", "-T", "postgres", "psql",
"-U", "messenger", "-d", "messenger", "-X", "-A", "-t", "-c",
"SELECT xact_commit FROM pg_stat_database WHERE datname = 'messenger'"],
cwd=ROOT, check=True, capture_output=True, text=True)
return int(out.stdout.strip())
name, pw = "cb_" + uuid.uuid4().hex[:10], "T3st-" + uuid.uuid4().hex
api("POST", "/api/v1/users", {"username": name, "display_name": "Cache bench", "password": pw})
token = api("POST", "/api/v1/auth/sessions",
headers={"Authorization": "Basic " + base64.b64encode((name + ":" + pw).encode()).decode()})["token"]
auth = {"Authorization": "Bearer " + token}
for _ in range(20): # прогрев соединений
api("GET", "/api/v1/users/me", headers=auth)
before = commits()
lat = []
for _ in range(args.requests):
t0 = time.perf_counter()
api("GET", "/api/v1/users/me", headers=auth)
lat.append((time.perf_counter() - t0) * 1000)
after = commits()
lat.sort()
print(json.dumps({
"label": args.label, "requests": args.requests,
"postgres_xact_commit_delta": after - before,
"p50_ms": round(statistics.median(lat), 2),
"p95_ms": round(lat[int(len(lat) * 0.95) - 1], 2),
}, ensure_ascii=False))
+156
View File
@@ -0,0 +1,156 @@
#!/usr/bin/env python3
"""Обоснование индекса истории: EXPLAIN (ANALYZE, BUFFERS) на большом объёме + замер пагинации через API.
python3 student-tests/history_bench.py [--big 100000] [--small-chats 20] [--small-size 500]
1. Через API создаёт двух синтетических пользователей, большой чат и N маленьких чатов.
2. Через psql (docker compose exec postgres) заливает сообщения: generate_series, одна транзакция.
Неравномерно: один чат на --big сообщений, остальные по --small-size.
3. Печатает EXPLAIN (ANALYZE, BUFFERS) ровно того SQL, который выполняет приложение:
первая страница, «глубокая» страница по keyset-курсору, та же глубина через OFFSET;
затем те же запросы БЕЗ индекса messages_chat_order_idx (DROP INDEX внутри BEGIN … ROLLBACK).
4. Проходит всю историю большого чата через API (limit=100) и сравнивает задержку первых и
последних страниц: при keyset-пагинации она не растёт с номером страницы.
Каждый запуск добавляет синтетические данные в учебную БД (API курса не удаляет сообщения).
"""
import argparse
import base64
import json
import statistics
import subprocess
import time
import urllib.parse
import urllib.request
import uuid
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
parser = argparse.ArgumentParser()
parser.add_argument("--base-url", default="http://localhost:8080")
parser.add_argument("--big", type=int, default=100_000)
parser.add_argument("--small-chats", type=int, default=20)
parser.add_argument("--small-size", type=int, default=500)
args = parser.parse_args()
BASE = args.base_url.rstrip("/")
def api(method, path, body=None, headers=None):
h = dict(headers or {})
data = None
if body is not None:
data = json.dumps(body).encode()
h["Content-Type"] = "application/json"
req = urllib.request.Request(BASE + path, data=data, headers=h, method=method)
with urllib.request.urlopen(req, timeout=30) as r:
raw = r.read()
return json.loads(raw) if raw else None
def psql(sql, tuples_only=False):
cmd = ["docker", "compose", "--env-file", str(ROOT / ".env"), "exec", "-T", "postgres",
"psql", "-U", "messenger", "-d", "messenger", "-X", "-q", "-v", "ON_ERROR_STOP=1"]
if tuples_only:
cmd += ["-A", "-t"]
out = subprocess.run(cmd, input=sql, cwd=ROOT, check=True, capture_output=True, text=True)
return out.stdout.strip()
def user(label):
name = "bench_%s_%s" % (label, uuid.uuid4().hex[:8])
pw = "T3st-" + uuid.uuid4().hex
u = api("POST", "/api/v1/users", {"username": name, "display_name": "Bench " + label, "password": pw})
cred = base64.b64encode((name + ":" + pw).encode()).decode()
s = api("POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + cred})
return u, {"Authorization": "Bearer " + s["token"]}
def section(title):
print("\n" + "=" * 100 + "\n" + title + "\n" + "=" * 100)
# ---------- 1. данные ----------
a, ha = user("a")
b, _ = user("b")
big = api("POST", "/api/v1/chats", {"title": "Большой чат", "member_ids": [a["id"], b["id"]]}, ha)
small = [api("POST", "/api/v1/chats", {"title": "Малый %d" % i, "member_ids": [a["id"], b["id"]]}, ha)
for i in range(args.small_chats)]
section("1. Заливка данных")
started = time.monotonic()
values = ",".join("('%s'::uuid)" % c["id"] for c in small) # UUID получены от нашего API
psql("""
BEGIN;
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(), '{big}'::uuid,
CASE WHEN n % 2 = 0 THEN '{a}'::uuid ELSE '{b}'::uuid END,
'synthetic message #' || n || ' ' || repeat('x', (n * 7919) % 200),
timestamptz '2026-01-01 00:00:00+00' + n * interval '1 millisecond'
FROM generate_series(1, {big_n}) AS n;
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(), c.id, '{a}'::uuid, 'small chat message #' || n,
timestamptz '2026-01-01 00:00:00+00' + n * interval '1 millisecond'
FROM (VALUES {values}) AS c(id), generate_series(1, {small_n}) AS n;
COMMIT;
ANALYZE messages;
""".format(big=big["id"], a=a["id"], b=b["id"], big_n=args.big, small_n=args.small_size, values=values))
print("залито за %.1f с" % (time.monotonic() - started))
print(psql("""SELECT count(*) AS messages_total,
count(DISTINCT chat_id) AS chats_with_messages,
(SELECT count(*) FROM messages WHERE chat_id = '{big}') AS in_big_chat,
pg_size_pretty(pg_relation_size('messages')) AS table_size,
pg_size_pretty(pg_relation_size('messages_chat_order_idx')) AS index_size
FROM messages""".format(big=big["id"])))
# ---------- 2. EXPLAIN ----------
deep_offset = int(args.big * 0.9)
cur_ts, cur_id = psql("""SELECT created_at, id FROM messages WHERE chat_id = '{big}'
ORDER BY created_at, id OFFSET {off} LIMIT 1""".format(
big=big["id"], off=deep_offset - 1), tuples_only=True).split("|")
COLS = "SELECT id, chat_id, sender_id, text, created_at FROM messages"
Q_FIRST = COLS + " WHERE chat_id = '{c}' ORDER BY created_at, id LIMIT 51".format(c=big["id"])
Q_KEYSET = (COLS + " WHERE chat_id = '{c}' AND (created_at, id) > ('{t}', '{i}'::uuid)"
" ORDER BY created_at, id LIMIT 51").format(c=big["id"], t=cur_ts, i=cur_id)
Q_OFFSET = (COLS + " WHERE chat_id = '{c}' ORDER BY created_at, id OFFSET {o} LIMIT 51").format(
c=big["id"], o=deep_offset)
EXPLAIN = "EXPLAIN (ANALYZE, BUFFERS, COSTS OFF) "
for title, q in [
("2a. С индексом: первая страница (как в приложении, limit=50 → LIMIT 51)", Q_FIRST),
("2b. С индексом: страница после %d-го сообщения, keyset-курсор (как в приложении)" % deep_offset, Q_KEYSET),
("2c. Для сравнения: та же глубина через OFFSET %d (так приложение НЕ делает)" % deep_offset, Q_OFFSET)]:
section(title)
print(q)
print(psql(EXPLAIN + q))
section("2d. БЕЗ индекса messages_chat_order_idx (DROP INDEX внутри BEGIN … ROLLBACK, данные не меняются)")
print(psql("BEGIN;\nDROP INDEX messages_chat_order_idx;\n"
"\\echo '--- первая страница без индекса'\n" + EXPLAIN + Q_FIRST + ";\n"
"\\echo '--- keyset-страница без индекса'\n" + EXPLAIN + Q_KEYSET + ";\nROLLBACK;"))
print(psql("SELECT indexname FROM pg_indexes WHERE tablename = 'messages' ORDER BY 1"))
# ---------- 3. пагинация через API ----------
section("3. Полный обход истории большого чата через API (limit=100)")
path = "/api/v1/chats/%s/messages?limit=100" % big["id"]
latencies, total, cursor = [], 0, None
while True:
url = path + ("&cursor=" + urllib.parse.quote(cursor, safe="") if cursor else "")
t0 = time.perf_counter()
page = api("GET", url, headers=ha)
latencies.append((time.perf_counter() - t0) * 1000)
total += len(page["items"])
cursor = page["next_cursor"]
if not cursor:
break
first, last = latencies[1:21], latencies[-20:] # первая страница — прогрев
print(json.dumps({
"pages": len(latencies), "messages_read": total, "expected": args.big,
"first_20_pages_median_ms": round(statistics.median(first), 2),
"last_20_pages_median_ms": round(statistics.median(last), 2),
"all_pages_p50_ms": round(statistics.median(latencies), 2),
"all_pages_p95_ms": round(sorted(latencies)[int(len(latencies) * 0.95) - 1], 2),
"all_pages_max_ms": round(max(latencies), 2),
}, ensure_ascii=False, indent=1))
assert total == args.big, "пагинация потеряла или задублировала сообщения"
print("PASS: все %d сообщений прочитаны без потерь и повторов" % total)
+364
View File
@@ -0,0 +1,364 @@
#!/usr/bin/env python3
"""Собственные проверки lab2 (только stdlib): аутентификация, границы, транзакции, сохранность.
python3 student-tests/test_lab2.py # граничные проверки, гонка, атомарность
python3 student-tests/test_lab2.py --expiry-url http://localhost:8081 # + истечение (SESSION_TTL_SECONDS=2)
python3 student-tests/test_lab2.py --db-outage # + остановка PostgreSQL -> 503, восстановление
python3 student-tests/test_lab2.py --persistence # + перезапуск API и БД через scripts/restart.sh
Токены и пароли не печатаются. Флаги --db-outage/--persistence управляют docker compose.
"""
import argparse
import base64
import json
import subprocess
import sys
import threading
import time
import urllib.error
import urllib.request
import uuid
from pathlib import Path
parser = argparse.ArgumentParser()
parser.add_argument("--base-url", default="http://localhost:8080")
parser.add_argument("--persistence", action="store_true")
parser.add_argument("--expiry-url", default=None, help="экземпляр API с SESSION_TTL_SECONDS=2")
parser.add_argument("--db-outage", action="store_true")
parser.add_argument("--cache", action="store_true",
help="проверки Valkey: отказ, FLUSHALL, зависание при logout (docker compose)")
args = parser.parse_args()
BASE = args.base_url.rstrip("/")
ROOT = Path(__file__).resolve().parents[1]
fails = 0
def call(method, path, body=None, token=None, headers=None, raw=None, base=None):
h = dict(headers or {})
if token:
h["Authorization"] = "Bearer " + token
data = raw if raw is not None else (json.dumps(body, ensure_ascii=False).encode() if body is not None else None)
if data is not None:
h.setdefault("Content-Type", "application/json")
req = urllib.request.Request((base or BASE) + path, data=data, headers=h, method=method)
try:
resp = urllib.request.urlopen(req, timeout=30)
except urllib.error.HTTPError as err:
resp = err
with resp:
text = resp.read()
assert resp.headers.get("X-Request-Id"), "нет X-Request-Id"
return resp.code, (json.loads(text) if text else None), resp.headers
def expect(name, got, want):
global fails
ok = got == want
fails += not ok
short = lambda v: (str(v)[:40] + "…") if len(str(v)) > 40 else str(v)
print("%-4s %-46s -> %s (ожидалось %s)" % ("OK" if ok else "FAIL", name, short(got), short(want)))
def basic(username, password):
return {"Authorization": "Basic " + base64.b64encode((username + ":" + password).encode()).decode()}
def register(prefix, password):
username = prefix + uuid.uuid4().hex[:8]
code, user, _ = call("POST", "/api/v1/users", {"username": username, "display_name": "Тест", "password": password})
assert code == 201, code
return user
def login(username, password):
code, session, _ = call("POST", "/api/v1/auth/sessions", headers=basic(username, password))
assert code == 201, code
return session["token"]
PW_A, PW_B = "Пароль:с:двоеточием-Ω1", "T3st-" + uuid.uuid4().hex
a, b, e = register("a_", PW_A), register("b_", PW_B), register("e_", PW_B)
ta, tb, te = login(a["username"], PW_A), login(b["username"], PW_B), login(e["username"], PW_B)
# --- регистрация ---
users = "/api/v1/users"
expect("регистрация без password", call("POST", users, {"username": "zz_" + uuid.uuid4().hex[:6], "display_name": "x"})[0], 400)
expect("password 11 символов", call("POST", users, {"username": "zz_" + uuid.uuid4().hex[:6], "display_name": "x", "password": "a" * 11})[0], 400)
expect("password 129 символов", call("POST", users, {"username": "zz_" + uuid.uuid4().hex[:6], "display_name": "x", "password": "a" * 129})[0], 400)
expect("password не строка", call("POST", users, {"username": "zz_" + uuid.uuid4().hex[:6], "display_name": "x", "password": 123456789012})[0], 400)
expect("дубликат username", call("POST", users, {"username": a["username"], "display_name": "x", "password": PW_B})[0], 409)
expect("User не содержит пароль/хеш", sorted(a), ["created_at", "display_name", "id", "username"])
expect("malformed JSON", call("POST", users, raw=b"{bad")[0], 400)
# --- вход ---
sess = "/api/v1/auth/sessions"
code, _, hdr = call("POST", sess, headers=basic(a["username"], "wrong-password-123"))
expect("неверный пароль", code, 401)
expect(" challenge Basic", hdr.get("WWW-Authenticate", "").startswith("Basic"), True)
expect("неизвестный пользователь", call("POST", sess, headers=basic("no_such_user_x", PW_B))[0], 401)
expect("вход без Authorization", call("POST", sess)[0], 401)
expect("вход с Bearer вместо Basic", call("POST", sess, token=ta)[0], 401)
expect("мусор вместо base64", call("POST", sess, headers={"Authorization": "Basic !!!"})[0], 401)
expect("пароль с двоеточием и Unicode", call("GET", "/api/v1/users/me", token=ta)[1]["id"], a["id"])
t1, t2 = login(b["username"], PW_B), login(b["username"], PW_B)
expect("два входа дают разные токены", t1 != t2 and len(t1) >= 43, True)
# --- Bearer ---
me = "/api/v1/users/me"
code, _, hdr = call("GET", me)
expect("без токена", code, 401)
expect(" challenge Bearer", hdr.get("WWW-Authenticate", "").startswith("Bearer"), True)
expect("случайный токен", call("GET", me, token="x" * 43)[0], 401)
expect("Basic на бизнес-endpoint", call("GET", me, headers=basic(a["username"], PW_A))[0], 401)
expect("только X-User-Id", call("GET", me, headers={"X-User-Id": a["id"]})[0], 401)
expect("X-User-Id не меняет владельца", call("GET", me, token=ta, headers={"X-User-Id": e["id"]})[1]["id"], a["id"])
# --- logout ---
expect("logout", call("DELETE", sess + "/current", token=t1)[0], 204)
expect("отозванный токен", call("GET", me, token=t1)[0], 401)
expect("повторный logout", call("DELETE", sess + "/current", token=t1)[0], 401)
expect("другая сессия того же пользователя жива", call("GET", me, token=t2)[0], 200)
# --- чаты и сообщения ---
chats = "/api/v1/chats"
expect("чат: создатель не участник", call("POST", chats, {"title": "t", "member_ids": [b["id"]]}, ta)[0], 400)
expect("чат: неизвестный участник", call("POST", chats, {"title": "t", "member_ids": [a["id"], str(uuid.uuid4())]}, ta)[0], 400)
expect("чат: дубликат участника", call("POST", chats, {"title": "t", "member_ids": [a["id"], a["id"]]}, ta)[0], 400)
chat = call("POST", chats, {"title": "Проверка", "member_ids": [a["id"], b["id"]]}, ta)[1]
chat2 = call("POST", chats, {"title": "t2", "member_ids": [a["id"]]}, ta)[1]
expect("порядок member_ids сохранён", chat["member_ids"], [a["id"], b["id"]])
msgs = "/api/v1/chats/%s/messages" % chat["id"]
expect("чужой чат (Ева)", call("GET", chats + "/" + chat["id"], token=te)[0], 404)
expect("запись в чужой чат (Ева)", call("POST", msgs, {"text": "x"}, te)[0], 404)
expect("пустое сообщение", call("POST", msgs, {"text": " "}, ta)[0], 400)
expect("sender_id в теле", call("POST", msgs, {"text": "x", "sender_id": b["id"]}, ta)[0], 400)
expect("4001 символ", call("POST", msgs, {"text": "я" * 4001}, ta)[0], 400)
errors = []
def send(i):
try:
code, _, _ = call("POST", msgs, {"text": "m%d 👋" % i}, ta if i % 2 else tb)
if code != 201:
errors.append(code)
except Exception as exc:
errors.append(type(exc).__name__)
threads = [threading.Thread(target=send, args=(i,)) for i in range(100)]
[t.start() for t in threads]
[t.join() for t in threads]
def read_all(token, limit=7):
seen, cursor = [], None
while True:
_, page, _ = call("GET", msgs + "?limit=%d" % limit + ("&cursor=" + cursor if cursor else ""), token=token)
seen += page["items"]
cursor = page["next_cursor"]
if not cursor:
return seen
history = read_all(tb)
expect("100 параллельных POST: ошибок", len(errors), 0)
expect("100 параллельных POST: уникальных", len({m["id"] for m in history}), 100)
expect("история отсортирована (created_at, id)",
history == sorted(history, key=lambda m: (m["created_at"], uuid.UUID(m["id"]).int)), True)
first = call("GET", msgs + "?limit=1", token=ta)[1]
expect("cursor от другого чата", call("GET", "/api/v1/chats/%s/messages?cursor=%s" % (chat2["id"], first["next_cursor"]), token=ta)[0], 400)
expect("мусорный cursor", call("GET", msgs + "?cursor=abc", token=ta)[0], 400)
expect("limit=0", call("GET", msgs + "?limit=0", token=ta)[0], 400)
expect("неверный UUID в пути", call("GET", chats + "/xyz", token=ta)[0], 400)
# --- гонка регистрации одного username ---
race_name = "race_" + uuid.uuid4().hex[:10]
race_codes = []
def register_same():
try:
race_codes.append(call("POST", "/api/v1/users",
{"username": race_name, "display_name": "Гонка", "password": PW_B})[0])
except Exception as exc:
race_codes.append(type(exc).__name__)
threads = [threading.Thread(target=register_same) for _ in range(20)]
[t.start() for t in threads]
[t.join() for t in threads]
expect("гонка 20 регистраций: ровно один 201", sorted(race_codes).count(201), 1)
expect("гонка 20 регистраций: остальные 409", sorted(race_codes).count(409), 19)
# --- атомарность создания чата: ошибка не оставляет «полу-чата» ---
def chat_ids(token):
_, page, _ = call("GET", chats + "?limit=100", token=token)
return [c["id"] for c in page["items"]]
fresh_pw = "T3st-" + uuid.uuid4().hex
fresh = register("f_", fresh_pw)
tf = login(fresh["username"], fresh_pw)
before = chat_ids(tf)
before_b = chat_ids(tb)
code = call("POST", chats, {"title": "откат", "member_ids": [fresh["id"], b["id"], str(uuid.uuid4())]}, tf)[0]
expect("чат с неизвестным 3-м участником", code, 400)
expect("после ошибки чат не появился у создателя", chat_ids(tf), before)
expect("после ошибки чат не появился у участника b", chat_ids(tb), before_b)
code, ok_chat, _ = call("POST", chats, {"title": "после отката", "member_ids": [fresh["id"]]}, tf)
expect("следующее создание чата работает", (code, chat_ids(tf)), (201, before + [ok_chat["id"]]))
# --- истечение сессии (отдельный экземпляр API с SESSION_TTL_SECONDS=2) ---
if args.expiry_url:
eb = args.expiry_url.rstrip("/")
code, s, _ = call("POST", sess, headers=basic(a["username"], PW_A), base=eb)
expect("TTL=2: вход", code, 201)
expect("TTL=2: сразу после входа токен работает", call("GET", me, token=s["token"], base=eb)[0], 200)
time.sleep(3)
code, _, hdr = call("GET", me, token=s["token"], base=eb)
expect("TTL=2: через 3 с токен истёк", code, 401)
expect(" challenge Bearer", hdr.get("WWW-Authenticate", "").startswith("Bearer"), True)
expect("TTL=2: истёкший токен не работает и на основном API", call("GET", me, token=s["token"])[0], 401)
# --- недоступность PostgreSQL ---
if args.db_outage:
print("--- остановка PostgreSQL: docker compose stop postgres")
compose = ["docker", "compose", "--env-file", str(ROOT / ".env")]
subprocess.run(compose + ["stop", "postgres"], cwd=ROOT, check=True,
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
try:
code, body, _ = call("GET", "/health/ready")
expect("БД нет: /health/ready", (code, body["error"]["code"]), (503, "unavailable"))
expect("БД нет: /health/live", call("GET", "/health/live")[0], 200)
started = time.monotonic()
code, body, _ = call("GET", chats, token=ta)
expect("БД нет: список чатов с токеном -> 503, не 200", (code, body["error"]["code"]), (503, "unavailable"))
expect("БД нет: ответ ограничен по времени (<10 с)", time.monotonic() - started < 10, True)
# /users/me может быть отдан из кэша сессий (копия действующей сессии, отзыв без БД невозможен)
expect("БД нет: /users/me -> 200 из кэша или 503", call("GET", me, token=ta)[0] in (200, 503), True)
expect("БД нет: неизвестный токен не проходит", call("GET", me, token="y" * 43)[0] in (401, 503), True)
expect("БД нет: анонимный запрос не проходит", call("GET", me)[0] in (401, 503), True)
expect("БД нет: вход -> 503", call("POST", sess, headers=basic(a["username"], PW_A))[0], 503)
finally:
subprocess.run(compose + ["start", "postgres"], cwd=ROOT, check=True,
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
deadline = time.monotonic() + 60
while call("GET", "/health/ready")[0] != 200:
assert time.monotonic() < deadline, "БД не восстановилась"
time.sleep(1)
expect("БД вернулась: прежний токен работает", call("GET", me, token=ta)[1], a)
# --- Valkey: роль кэша, отказ, flush, зависание при logout ---
if args.cache:
compose = ["docker", "compose", "--env-file", str(ROOT / ".env")]
def dc(*cmd):
subprocess.run(compose + list(cmd), cwd=ROOT, check=True,
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
def vcli(*cmd):
"""valkey-cli внутри контейнера; пароль читается там же из секрета и не печатается."""
out = subprocess.run(compose + ["exec", "-T", "valkey", "sh", "-c",
'valkey-cli --no-auth-warning -a "$(sed -n "s/^requirepass //p" '
'/run/secrets/valkey.conf)" "$@"', "_"] + list(cmd),
cwd=ROOT, check=True, capture_output=True, text=True)
return out.stdout.strip()
def stats():
info = dict(l.split(":", 1) for l in vcli("INFO", "stats").splitlines() if ":" in l)
return int(info["keyspace_hits"]), int(info["keyspace_misses"])
import hashlib
def cache_value(token):
return vcli("GET", "sess:" + hashlib.sha256(token.encode()).hexdigest())
pw = "T3st-" + uuid.uuid4().hex
cu = register("c_", pw)
tc = login(cu["username"], pw)
expect("кэш: после входа в Valkey лежит копия сессии", cu["id"] in cache_value(tc), True)
expect("кэш: в Valkey нет самого токена/пароля", tc not in vcli("--scan", "--pattern", "*") and True, True)
h0, m0 = stats()
for _ in range(50):
call("GET", me, token=tc)
h1, m1 = stats()
expect("кэш: 50 запросов -> 50 попаданий в Valkey", (h1 - h0, m1 - m0), (50, 0))
# logout мгновенно виден через кэш
t2 = login(cu["username"], pw)
call("GET", me, token=t2)
expect("кэш: logout", call("DELETE", sess + "/current", token=t2)[0], 204)
expect("кэш: в Valkey tombstone вместо копии", cache_value(t2), "revoked")
expect("кэш: отозванный токен сразу 401", call("GET", me, token=t2)[0], 401)
# FLUSHALL: кэш пуст, сессии читаются из PostgreSQL
vcli("FLUSHALL")
expect("FLUSHALL: действующий токен работает (из БД)", call("GET", me, token=tc)[1], cu)
expect("FLUSHALL: отозванный токен по-прежнему 401", call("GET", me, token=t2)[0], 401)
expect("FLUSHALL: кэш снова заполнен после промаха", cu["id"] in cache_value(tc), True)
# Valkey остановлен: API работает через PostgreSQL
print("--- остановка Valkey: docker compose stop valkey")
dc("stop", "valkey")
try:
expect("Valkey нет: /health/ready 200 (не критичен)", call("GET", "/health/ready")[0], 200)
started = time.monotonic()
expect("Valkey нет: токен работает через БД", call("GET", me, token=tc)[1], cu)
expect("Valkey нет: ответ быстрый (<2 с)", time.monotonic() - started < 2, True)
expect("Valkey нет: список чатов", call("GET", chats, token=tc)[0], 200)
expect("Valkey нет: без токена 401", call("GET", me)[0], 401)
expect("Valkey нет: чужой токен 401", call("GET", me, token="z" * 43)[0], 401)
expect("Valkey нет: отозванный токен 401", call("GET", me, token=t2)[0], 401)
t3 = login(cu["username"], pw)
expect("Valkey нет: вход 201", bool(t3), True)
expect("Valkey нет: logout 204", call("DELETE", sess + "/current", token=t3)[0], 204)
expect("Valkey нет: после logout 401", call("GET", me, token=t3)[0], 401)
finally:
dc("start", "valkey")
deadline = time.monotonic() + 30
while "PONG" not in vcli("PING"):
assert time.monotonic() < deadline, "Valkey не поднялся"
time.sleep(0.5)
time.sleep(6) # дольше CACHE_RETRY_SECONDS: приложение снова опрашивает кэш
expect("Valkey вернулся: токен работает", call("GET", me, token=tc)[1], cu)
expect("Valkey вернулся: кэш снова заполняется", cu["id"] in cache_value(tc), True)
expect("Valkey вернулся: токен, отозванный при отказе, 401", call("GET", me, token=t3)[0], 401)
# Самый опасный случай: Valkey «завис» (pause) во время logout -> tombstone не записан,
# в Valkey осталась положительная копия сессии. Она не должна «воскресить» токен.
t4 = login(cu["username"], pw)
call("GET", me, token=t4)
print("--- зависание Valkey во время logout: docker compose pause valkey")
dc("pause", "valkey")
try:
expect("Valkey завис: logout всё равно 204 (отзыв в БД)", call("DELETE", sess + "/current", token=t4)[0], 204)
finally:
dc("unpause", "valkey")
expect("Valkey ожил: в нём осталась устаревшая копия", cu["id"] in cache_value(t4), True)
time.sleep(6) # breaker закрыт, кэш снова опрашивается
expect("Valkey ожил: устаревшая копия не принята, 401", call("GET", me, token=t4)[0], 401)
expect("Valkey ожил: действующий токен работает", call("GET", me, token=tc)[1], cu)
if args.persistence:
print("--- перезапуск API и PostgreSQL: scripts/restart.sh")
subprocess.run([str(ROOT / "scripts" / "restart.sh")], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
deadline = time.monotonic() + 90
while True:
try:
if call("GET", "/health/ready")[0] == 200:
break
except Exception:
pass
assert time.monotonic() < deadline, "сервер не поднялся"
time.sleep(1)
expect("после рестарта: прежний токен работает", call("GET", me, token=ta)[1], a)
expect("после рестарта: чат на месте", call("GET", chats + "/" + chat["id"], token=tb)[1], chat)
expect("после рестарта: история та же", read_all(tb), history)
expect("после рестарта: отозванный токен всё ещё отозван", call("GET", me, token=t1)[0], 401)
expect("после рестарта: вход по паролю работает", call("POST", sess, headers=basic(a["username"], PW_A))[0], 201)
print("ИТОГО:", "ВСЕ ПРОВЕРКИ ПРОШЛИ" if not fails else "%d ПРОВАЛОВ" % fails)
sys.exit(1 if fails else 0)