37 changed files with 2264 additions and 40 deletions
+23 -16
View File
@@ -1,20 +1,27 @@
# В образ попадает только то, что нужно рантайму. Всё лишнее исключаем:
# уменьшает контекст сборки, ускоряет build и не даёт утечь .env/секретам.
.git
.github
.gitignore
.dockerignore
Dockerfile
Dockerfile.example
.env
.env.*
!.env.example
secrets
certs
volumes
data
backups
*.key
*.pem
*.p12
*.pfx
*.jks
.venv
__pycache__
node_modules
evidence
.DS_Store
.venv/
__pycache__/
*.py[cod]
tests/
student-tests/
scripts/
contracts/
evidence/
*.md
.github/
lab.json
requirements-dev.txt
compose.yaml
compose.example.yaml
examples/
Makefile
MAINTAINERS.md
+22 -7
View File
@@ -1,11 +1,26 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
# Скопируйте в .env для ЛОКАЛЬНОГО учебного стенда; .env никогда не коммитится.
# Пароль ниже — синтетический пример, задайте свой.
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.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
# PostgreSQL — источник истины (пользователи, чаты, сообщения, СЕССИИ).
# Compose собирает из них DATABASE_URL. Вне compose можно задать
# DATABASE_URL или DATABASE_URL_FILE=/run/secrets/database_url (файл приоритетнее).
POSTGRES_DB=messenger
POSTGRES_USER=messenger
POSTGRES_PASSWORD=change-me-local-only
# Сессии: хранятся в PostgreSQL, Redis — только кэш (уровень 4).
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
SESSION_TTL_SECONDS=3600
# CACHE_URL (или CACHE_URL_FILE) задаёт compose: redis://redis:6379/0. Пусто = без кэша.
SESSION_CACHE_TTL_SECONDS=60
# Пул соединений и таймауты
DB_POOL_MAX=10
DB_POOL_TIMEOUT=3
DB_STATEMENT_TIMEOUT_MS=5000
REDIS_TIMEOUT=0.5
LOG_LEVEL=info
+27
View File
@@ -0,0 +1,27 @@
# syntax=docker/dockerfile:1
# ---- Stage 1: builder: зависимости ставим отдельно, в рантайм несём только результат
FROM python:3.12.7-slim-bookworm AS builder
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 PIP_NO_CACHE_DIR=1 PIP_DISABLE_PIP_VERSION_CHECK=1
WORKDIR /app
COPY requirements.txt .
RUN pip install --prefix=/install -r requirements.txt
# ---- Stage 2: runtime
FROM python:3.12.7-slim-bookworm AS runtime
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 \
APP_HOST=0.0.0.0 APP_PORT=8080 SHUTDOWN_TIMEOUT=10
RUN useradd --create-home --uid 10001 appuser
WORKDIR /app
COPY --from=builder /install /usr/local
COPY app ./app
COPY migrations ./migrations
USER appuser
EXPOSE 8080
# /health/ready проверяет PostgreSQL: без БД контейнер станет unhealthy.
HEALTHCHECK --interval=10s --timeout=3s --start-period=10s --retries=3 \
CMD python -c "import os,urllib.request,sys; \
u='http://127.0.0.1:'+os.getenv('APP_PORT','8080')+'/health/ready'; \
sys.exit(0 if urllib.request.urlopen(u,timeout=2).status==200 else 1)" || exit 1
# exec-форма: uvicorn — PID 1 и сам получает SIGTERM от docker stop.
CMD ["python", "-m", "app"]
+126 -17
View File
@@ -1,37 +1,146 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Санжаровский, БВТ2304
- Целевая оценка: **4** (трек 5 не заявлен)
- Commit/PR: TODO после публикации (ветка `solution/bvt2304-sanzharovskiy`)
- Источники и библиотеки: FastAPI, uvicorn, Pydantic, psycopg 3 + psycopg-pool, argon2-cffi, redis-py; документация PostgreSQL (transactions, EXPLAIN, индексы), Redis persistence, RFC 7617 (Basic), RFC 6750 (Bearer).
- Помощь ИИ: Claude (Anthropic) помогал проектировать схему, писать код, тесты и отчёт. Все решения я разобрал и могу объяснить; результаты проверок получены реальными запусками (файлы в `evidence/`).
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужно: Docker Desktop (Compose v2), Python 3.9+ для тестов. Образы закреплены: `python:3.12.7-slim-bookworm`, `postgres:16.4-alpine`, `redis:7.4.1-alpine`; Python-зависимости закреплены в `requirements.txt`.
```sh
cp .env.example .env # Windows: copy .env.example .env ; задать свой POSTGRES_PASSWORD
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
# миграции применяются автоматически при старте API (MIGRATE_ON_START=true);
# вручную/повторно: docker compose --env-file .env exec api python -m app.migrate
curl http://localhost:8080/health/ready # ждём {"status":"ok"}
make check
make test # без make: python tests/smoke.py --base-url http://localhost:8080
make test-persistence ACTION_SCRIPT=scripts/restart.sh
# Windows: python tests\resilience.py --mode persistence --action-script scripts\restart.cmd --base-url http://localhost:8080
python student-tests/run.py --base-url http://localhost:8080
python student-tests/race.py --base-url http://localhost:8080
python student-tests/outage.py --base-url http://localhost:8080
python student-tests/logout_cache.py --base-url http://localhost:8080
docker compose --env-file .env --profile ttl up -d api-ttl
python student-tests/expiry.py --base-url http://localhost:8081
docker compose cp student-tests/rollback_check.py api:/tmp/rollback_check.py
docker compose exec api python /tmp/rollback_check.py
docker compose cp student-tests/explain.sql postgres:/tmp/explain.sql
docker compose exec postgres psql -U messenger -d messenger -f /tmp/explain.sql
```
Остановка без потери данных: `docker compose --env-file .env down` (volume `pgdata` сохраняется).
Намеренное удаление учебных данных: `docker compose --env-file .env down -v` (удаляет volume `pgdata`, только осознанно).
Действий оператора, кроме создания `.env`, не требуется. `.env` и секреты в Git не попадают (`.gitignore`), в образ — тоже (`.dockerignore`).
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
клиент ──HTTP──▶ api (FastAPI/uvicorn, без состояния)
│ ограниченный пул psycopg (max 10), таймауты
├──▶ postgres — ИСТОЧНИК ИСТИНЫ: users, chats, chat_members, messages, sessions
│ volume pgdata, миграции migrations/NNNN_*.sql
└──▶ redis — только КЭШ поиска сессии (ключ sess:<sha256(token)>, TTL)
```
| Роль | Service | Версия | Health/readiness | Volume | Порт | Credentials |
| --- | --- | --- | --- | --- | --- | --- |
| api | `api` | собирается из `Dockerfile` (multi-stage, non-root uid 10001) | `HEALTHCHECK` → `/health/ready` | нет (stateless) | `127.0.0.1:8080` | env из `.env` |
| postgres | `postgres` | `postgres:16.4-alpine` | `pg_isready` | `pgdata` | только внутренняя сеть | `POSTGRES_*` из `.env` |
| redis | `redis` | `redis:7.4.1-alpine` | `redis-cli ping` | нет (кэш, persistence выключен) | только внутренняя сеть | без пароля, наружу не опубликован |
| api-ttl | `api-ttl` (profile `ttl`) | тот же образ, `SESSION_TTL_SECONDS=2` | — | — | `127.0.0.1:8081` | — |
**Схема БД** (`migrations/0001_init.sql`): `users` (PK uuid, `username` UNIQUE + CHECK по шаблону, `password_hash`), `chats` (FK `created_by`), `chat_members` (PK `(chat_id,user_id)`, FK на chats ON DELETE CASCADE и на users, `position` для порядка участников), `messages` (FK на chat и sender, CHECK длины текста, индекс `(chat_id, created_at, id)`), `sessions` (PK `token_hash bytea`, FK user, `expires_at`, `revoked_at`).
**Миграции**: таблица `schema_migrations` + `pg_advisory_lock` (несколько API не применят миграцию дважды), каждый файл — в своей транзакции. Повторный запуск: `applied: nothing (up to date)`, данные не дублируются (`evidence/migrations.txt`).
**Транзакционные границы**: создание чата = `INSERT chats` + `INSERT chat_members` в одной транзакции (откат проверен `rollback_check.py`). Вход = проверка пароля + `INSERT sessions`. Сообщение — один `INSERT`. Регистрация защищена от гонки ограничением UNIQUE: проигравший получает 409.
**Аутентификация**: пароль — Argon2id (`argon2-cffi`, параметры библиотеки, своя соль у каждого хэша); для несуществующего пользователя проверяется хэш-заглушка, чтобы время ответа не выдавало существование username. `POST /api/v1/auth/sessions` принимает только `Basic` (без JSON), username ASCII, пароль UTF-8 12–128, двоеточие в пароле допустимо. Токен — `secrets.token_urlsafe(32)` (256 бит), в БД хранится только SHA-256 от него. Все остальные endpoint — только `Bearer`; `X-User-Id` игнорируется. Аутентификация — FastAPI dependency, поэтому 401 возвращается раньше валидации тела. Доступ к чату проверяется отдельно (не участник → 404).
**Сессии и Redis (уровень 4)**:
- Источник истины — таблица `sessions` в PostgreSQL. Срок задаёт `expires_at = now + SESSION_TTL_SECONDS`, рестарт его не продлевает.
- Чтение Bearer: сначала Redis `sess:<sha256>`; промах → `SELECT … WHERE revoked_at IS NULL AND expires_at > now()` → запись в кэш.
- Политика expiry кэша: TTL ключа = `min(SESSION_CACHE_TTL_SECONDS=60, время до expires_at)`, при чтении из кэша дополнительно сверяется `exp`. Кэш никогда не продлевает сессию.
- Инвалидация (logout) атомарна для БД и кэша (`app/sessions.py`, `revoke`): в одной транзакции `UPDATE sessions SET revoked_at` и затем `DEL` ключа в Redis. Если Redis не ответил (остановлен, приостановлен, таймаут), транзакция откатывается и клиент получает `503 unavailable`: logout не подтверждён, сессия остаётся согласованной. `204` возвращается только когда отозвано и в БД, и в кэше, поэтому после `204` старый токен не принимается никогда, в том числе после восстановления Redis.
- Гонка «параллельное чтение кладёт отозванную сессию в кэш после DEL» закрыта блокировкой: чтение сессии из БД идёт с `SELECT … FOR SHARE` и кладёт её в кэш, не отпуская строку; `UPDATE` в logout ждёт окончания такого чтения и удаляет ключ уже после него.
- Redis недоступен / flush / рестарт → кэш обходится, всё читается из PostgreSQL; сессии не теряются. Поэтому Redis запущен без persistence (`--save "" --appendonly no`) — осознанно: он не единственное хранилище.
- PostgreSQL недоступен → `503 unavailable` (обработчик `OperationalError`/`PoolTimeout`), `/health/ready` = 503, `/health/live` = 200. Неизвестный токен никогда не принимается.
**Пагинация**: keyset по `(created_at, id)`: `WHERE chat_id=$1 AND (created_at,id) > ($2,$3) ORDER BY created_at, id LIMIT limit+1`. Курсор — base64 JSON с привязкой к чату (курсор от другого чата → 400).
**Пул и таймауты**: `AsyncConnectionPool(min=1, max=DB_POOL_MAX=10)`, ожидание свободного соединения `DB_POOL_TIMEOUT=3 c`, `connect_timeout=3 c`, `statement_timeout=5000 мс`, Redis `socket_timeout=0.5 c`. Все запросы параметризованы (`%s`), SQL из пользовательских строк не собирается.
**Из lab1 перенесено**: формат ошибок `{"error":{code,message,request_id}}`, `X-Request-Id`, 422→400, `extra="forbid"`, graceful shutdown, multi-stage non-root Dockerfile. **Изменено**: хранилище в памяти + `threading.Lock` заменены PostgreSQL (конкурентность обеспечивают транзакции и ограничения БД), `X-User-Id` заменён на Basic → Bearer.
**Соответствие `.env.example` и реальной конфигурации**:
| Переменная skeleton | В решении |
| --- | --- |
| `APP_HOST`, `APP_PORT` | используются как есть |
| `APP_ENV` | только метка, на поведение не влияет |
| `SESSION_TTL_SECONDS` | срок сессии (`expires_at`) |
| `DATABASE_URL_FILE` | поддерживается (приоритетнее `DATABASE_URL`); в compose `DATABASE_URL` собирается из `POSTGRES_*` |
| `SESSION_STORE=postgres` | сессии всегда в PostgreSQL |
| `CACHE_URL_FILE` | поддерживается, также `CACHE_URL` (в compose `redis://redis:6379/0`); пусто — кэш выключен |
| дополнительно | `SESSION_CACHE_TTL_SECONDS`, `DB_POOL_MAX`, `DB_POOL_TIMEOUT`, `DB_STATEMENT_TIMEOUT_MS`, `REDIS_TIMEOUT`, `MIGRATE_ON_START`, `LOG_LEVEL` |
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
Стенд для приложенных файлов: 2 vCPU, 7 GiB RAM, Linux, Python 3.11, PostgreSQL 16, Redis 7; API на `127.0.0.1:8092`. На этом стенде Docker-образы скачать нельзя (нет доступа к registry), поэтому сервисы запущены процессами с теми же настройками, а restart-hook делал то же самое средствами `pg_ctl`/`redis-server`. На защите те же сценарии выполняются через `docker compose`.
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл |
| --- | --- | --- | --- |
| Публичный smoke | `make check`, `make validate`, `make test` | все три PASS | `evidence/smoke.txt` |
| Данные и сессии переживают рестарт API и хранилищ | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` (`restart.sh`: `docker compose restart postgres redis api`, volumes не трогает) | PASS: тот же токен читает те же данные | `evidence/persistence.txt` |
| Миграции с нуля и повторно | `python -m app.migrate` на пустой и на заполненной БД | `['0001_init']`, затем `nothing (up to date)`, число users не изменилось | `evidence/migrations.txt` |
| PK/FK, UNIQUE username, атомарный чат | `migrations/0001_init.sql`; `rollback_check.py` | вставка неизвестного участника падает на FK, после отката `chats=0, members=0` | `evidence/rollback.txt` |
| Basic только на `/auth/sessions`, Bearer, `X-User-Id` не даёт доступ | `student-tests/run.py` (раздел «аутентификация») | Basic на бизнес-endpoint → 401; `X-User-Id` → 401 и не подменяет владельца | `evidence/student-tests.txt` |
| Неверный пароль, неизвестный user | `run.py` | одинаковый 401 + `WWW-Authenticate: Basic …` | `evidence/student-tests.txt` |
| Logout | `run.py` | 204 → токен 401 → повторный logout 401 | `evidence/student-tests.txt` |
| Logout при приостановленном Redis | `logout_cache.py` (прогрев кэша → `docker compose pause redis` → logout → `unpause` → старый токен) | logout не подтверждается (503, не 204); после восстановления повторный logout → 204, старый токен → 401. На версии до исправления: 204 и старый токен снова принимался | `evidence/logout-cache.txt` |
| Тип содержимого | `run.py` (раздел «Content-Type») | корректный JSON с `text/plain` → 415 `unsupported_media_type`; без токена сначала 401; `application/json; charset=utf-8` принимается; битый JSON → 400 | `evidence/student-tests.txt` |
| Expiry при коротком TTL | `expiry.py` против `api-ttl` (TTL=2) | `expires_at` ≈ +2 c; до истечения 200, после — 401 (кэш не продлил сессию) | `evidence/expiry.txt` |
| Гонка регистрации одного username | `run.py`: 20 параллельных POST | ровно один 201 и девятнадцать 409 | `evidence/student-tests.txt` |
| Конкурентная запись | `race.py`: 10 клиентов × 10 сообщений | 100 принято, 100 уникальных в истории | `evidence/student-tests.txt` |
| Индекс истории + EXPLAIN на ≥10 000 | `student-tests/explain.sql` (60 000 сообщений, 12 000 в чате) | Index Scan, 4–5 буферов, ~0.1 мс; без индекса Seq Scan, 740 буферов, 6.8 мс | `evidence/explain.txt` |
| Недоступность Redis/БД | `outage.py` | без Redis всё работает в обход кэша; без PostgreSQL 503, ready 503, live 200, аноним 401; после восстановления тот же токен работает | `evidence/outage.txt` |
| Пул, таймауты, параметризованный SQL | `app/db.py`, `app/config.py`, `app/repo.py` | см. раздел «Архитектура» | — |
| Секреты не в Git | `.gitignore`, `.dockerignore`, `.env.example` | `.env` не коммитится, токены в evidence не печатаются | — |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
**EXPLAIN** (`evidence/explain.txt`). Гипотеза: составной индекс `(chat_id, created_at, id)` позволяет читать страницу истории за O(limit) независимо от её позиции, без сортировки. Данные: 60 000 сообщений в 10 чатах, в целевом — 12 000; `ANALYZE` перед замером; всё в транзакции с `ROLLBACK`.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| Запрос | План | Buffers | Время |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| первая страница (51 строка) | Index Scan `messages_chat_created_id_idx` | 4 | 0.03 мс |
| страница из середины (keyset) | Index Scan, условие `ROW(created_at,id) > ROW(...)` в Index Cond | 5 | 0.09 мс |
| та же страница с запрещённым индексом | Seq Scan + top-N sort, отброшено 54 001 строк | 740 | 6.8 мс |
Вывод: keyset-страница не читает предыдущие страницы (в отличие от OFFSET) и не сканирует всю таблицу. Цена — дополнительный индекс при записи.
**Нагрузка** (`evidence/load.json`): `tests/load.py --duration 15 --concurrency 4`, closed loop, POST сообщений, без прогрева: 6636 успешных, 0 ошибок, 439 RPS, p50 8.5 мс, p95 13.1 мс, p99 17.7 мс. Клиент на той же машине, есть coordinated omission, поэтому это не предел пропускной способности.
| Воздействие | Что ожидаем | Что наблюдали | Восстановление / потеря данных |
| --- | --- | --- | --- |
| рестарт API + PostgreSQL + Redis (volume сохранён) | данные и сессия на месте | PASS resilience, тот же токен работает | несколько секунд до ready; потерь нет |
| остановка Redis | кэш обходится, сервис работает | `/users/me` 200, запись 201, вход 201, поддельный токен 401 | сразу; потерь нет (Redis — только кэш) |
| остановка PostgreSQL | ограниченная ошибка, не зависание | 503, ready 503, live 200, аноним 401 | после старта БД ready 200, тот же токен читает историю |
| истечение TTL (2 c) | 401 после срока | 401 + `WWW-Authenticate: Bearer` | — |
| сбой посреди создания чата | откат целиком | `chats=0, members=0` | — |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Пока Redis недоступен, logout возвращает 503 и его нужно повторить после восстановления: так отзыв никогда не подтверждается без инвалидации кэша. Остальные операции в это время работают в обход кэша.
- При недоступном PostgreSQL сессия из кэша ещё распознаётся, но любое действие с данными получает 503.
- Durability: ответ 201 означает COMMIT в PostgreSQL с настройками по умолчанию (`synchronous_commit=on`, fsync). Реплик и бэкапов нет — отказ диска с volume означает потерю данных.
- `created_at` назначает API по своим UTC-часам; при равных метках порядок задаёт `id`. При нескольких репликах (lab3) часы разных хостов могут расходиться.
- Нет rate limiting на вход (перебор паролей замедляет только Argon2id). Нет TLS: HTTP только для локального стенда с синтетическими данными.
- Трек 5 не выполнялся.
View File
+22
View File
@@ -0,0 +1,22 @@
"""
Точка входа контейнера: `python -m app`. Настройки — из окружения (app/config.py).
uvicorn ловит SIGTERM: перестаёт принимать запросы и дожидается текущих
(до SHUTDOWN_TIMEOUT), затем закрывает пул БД и соединение с Redis.
"""
import logging
import uvicorn
from .config import settings
if __name__ == "__main__":
logging.basicConfig(level=settings.log_level.upper(),
format="%(asctime)s %(levelname)s %(name)s %(message)s")
uvicorn.run(
"app.main:app",
host=settings.host,
port=settings.port,
timeout_graceful_shutdown=settings.shutdown_timeout,
access_log=False, # свой лог в middleware: без query, токенов и тел
log_level=settings.log_level,
)
+55
View File
@@ -0,0 +1,55 @@
"""
Конфигурация только из переменных окружения (ничего не зашито в код и образ).
"""
from __future__ import annotations
import os
from dataclasses import dataclass
def _int(name: str, default: int) -> int:
return int(os.getenv(name, str(default)))
def _float(name: str, default: float) -> float:
return float(os.getenv(name, str(default)))
def _secret(name: str, default: str = "") -> str:
"""Значение из NAME_FILE (Docker secret, файл) или из переменной NAME.
Файл приоритетнее: так credentials не видны в `docker inspect`."""
path = os.getenv(name + "_FILE")
if path:
with open(path, encoding="utf-8") as f:
return f.read().strip()
return os.getenv(name, default)
@dataclass(frozen=True)
class Settings:
# HTTP
host: str = os.getenv("APP_HOST", "0.0.0.0")
port: int = _int("APP_PORT", 8080)
shutdown_timeout: int = _int("SHUTDOWN_TIMEOUT", 10)
log_level: str = os.getenv("LOG_LEVEL", "info")
# PostgreSQL — источник истины
database_url: str = _secret(
"DATABASE_URL", "postgresql://messenger:devpass@127.0.0.1:5432/messenger")
db_pool_min: int = _int("DB_POOL_MIN", 1)
db_pool_max: int = _int("DB_POOL_MAX", 10) # ограниченный пул
db_pool_timeout: float = _float("DB_POOL_TIMEOUT", 3.0) # ждать свободное соединение
db_connect_timeout: int = _int("DB_CONNECT_TIMEOUT", 3)
db_statement_timeout_ms: int = _int("DB_STATEMENT_TIMEOUT_MS", 5000)
migrate_on_start: bool = os.getenv("MIGRATE_ON_START", "true").lower() == "true"
# Сессии
session_ttl_seconds: int = _int("SESSION_TTL_SECONDS", 3600)
# Redis/Valkey — кэш сессий (не источник истины). Пусто = кэш выключен.
# Имя из skeleton — CACHE_URL(_FILE); REDIS_URL оставлено как синоним.
redis_url: str = _secret("CACHE_URL") or _secret("REDIS_URL")
redis_timeout: float = _float("REDIS_TIMEOUT", 0.5)
session_cache_ttl_seconds: int = _int("SESSION_CACHE_TTL_SECONDS", 60)
settings = Settings()
+50
View File
@@ -0,0 +1,50 @@
"""
Пул соединений с PostgreSQL.
- Пул ограничен (DB_POOL_MAX): при нагрузке запросы ждут свободное соединение
не дольше DB_POOL_TIMEOUT, а не открывают соединения без предела.
- connect_timeout и statement_timeout: зависший запрос или недоступная БД
не держат обработчик бесконечно — клиент получает 503.
- Все запросы параметризованы (%s), SQL-инъекция невозможна.
"""
from __future__ import annotations
from psycopg_pool import AsyncConnectionPool
from .config import settings
pool: AsyncConnectionPool | None = None
def make_pool() -> AsyncConnectionPool:
return AsyncConnectionPool(
conninfo=settings.database_url,
min_size=settings.db_pool_min,
max_size=settings.db_pool_max,
timeout=settings.db_pool_timeout,
kwargs={
"connect_timeout": settings.db_connect_timeout,
"options": f"-c statement_timeout={settings.db_statement_timeout_ms}",
"application_name": "messenger-api",
},
# Перед выдачей соединение проверяется (SELECT 1 на уровне протокола):
# после рестарта PostgreSQL «мёртвые» соединения отбрасываются, а не дают 503.
check=AsyncConnectionPool.check_connection,
open=False,
)
async def open_pool() -> None:
global pool
pool = make_pool()
# wait=False: API стартует, даже если БД ещё поднимается; /health/ready это покажет.
await pool.open(wait=False)
async def close_pool() -> None:
if pool is not None:
await pool.close()
def get_pool() -> AsyncConnectionPool:
assert pool is not None, "pool is not opened"
return pool
+376
View File
@@ -0,0 +1,376 @@
"""
HTTP-слой мессенджера (lab2).
Клиент → HTTP API (этот файл) → PostgreSQL (источник истины)
↘ Redis/Valkey (кэш сессий, необязательный)
Что изменилось относительно lab1:
* регистрация принимает password, хранится только Argon2id-хэш;
* вход: POST /api/v1/auth/sessions с Authorization: Basic → Bearer-токен;
* все бизнес-запросы требуют Authorization: Bearer; X-User-Id игнорируется;
* данные и действующие сессии лежат в PostgreSQL и переживают рестарт.
"""
from __future__ import annotations
import base64
import binascii
import logging
import re
import time
import uuid
from contextlib import asynccontextmanager
import psycopg
from fastapi import Depends, FastAPI, Query, Request
from fastapi.concurrency import run_in_threadpool
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse, Response
from psycopg_pool import PoolTimeout
from pydantic import BaseModel, field_validator
from starlette.exceptions import HTTPException as StarletteHTTPException
from . import db, repo, security, sessions
from .config import settings
from .migrate import migrate
logger = logging.getLogger("messenger")
USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$")
BEARER_CHALLENGE = 'Bearer realm="messenger"'
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
@asynccontextmanager
async def lifespan(app: FastAPI):
if settings.migrate_on_start:
try:
applied = await migrate()
logger.info("migrations: %s", applied or "up to date")
except psycopg.OperationalError as exc:
# БД ещё не готова: API всё равно стартует, /health/ready покажет 503.
logger.warning("migrations skipped, database unavailable: %s", type(exc).__name__)
await db.open_pool()
sessions.init_redis()
yield
await sessions.close_redis()
await db.close_pool()
app = FastAPI(title="MTUSI Messenger — lab2", lifespan=lifespan)
# ============================================================================
# 1. ЕДИНЫЙ ФОРМАТ ОШИБОК {"error":{"code","message","request_id"}}
# ============================================================================
class ApiError(Exception):
def __init__(self, status: int, code: str, message: str, headers: dict | None = None):
self.status, self.code, self.message, self.headers = status, code, message, headers or {}
def error_response(request: Request, status: int, code: str, message: str,
headers: dict | None = None) -> JSONResponse:
rid = getattr(request.state, "request_id", str(uuid.uuid4()))
return JSONResponse(
status_code=status,
content={"error": {"code": code, "message": message, "request_id": rid}},
headers={"X-Request-Id": rid, **(headers or {})},
)
@app.exception_handler(ApiError)
async def handle_api_error(request: Request, exc: ApiError):
return error_response(request, exc.status, exc.code, exc.message, exc.headers)
@app.exception_handler(RequestValidationError)
async def handle_validation(request: Request, exc: RequestValidationError):
return error_response(request, 400, "invalid_request", "invalid request body or parameters")
@app.exception_handler(StarletteHTTPException)
async def handle_http(request: Request, exc: StarletteHTTPException):
# Только коды из enum контракта (contracts/openapi.json → Error.code).
code = {401: "unauthorized", 404: "not_found", 409: "conflict",
413: "payload_too_large", 415: "unsupported_media_type",
429: "rate_limited", 503: "unavailable"}.get(
exc.status_code, "internal_error" if exc.status_code >= 500 else "invalid_request")
return error_response(request, exc.status_code, code, str(exc.detail))
@app.exception_handler(psycopg.OperationalError)
@app.exception_handler(PoolTimeout)
async def handle_db_down(request: Request, exc: Exception):
# БД недоступна или не ответила за таймаут: ограниченная ошибка, а не зависание.
logger.warning("database unavailable: %s", type(exc).__name__)
return error_response(request, 503, "unavailable", "service temporarily unavailable")
@app.exception_handler(Exception)
async def handle_unexpected(request: Request, exc: Exception):
logger.exception("unexpected error")
return error_response(request, 500, "internal_error", "internal error")
# ============================================================================
# 2. X-Request-Id + лог без тела запроса, токенов и паролей
# ============================================================================
@app.middleware("http")
async def add_request_id(request: Request, call_next):
rid = str(uuid.uuid4())
request.state.request_id = rid
start = time.monotonic()
response = await call_next(request)
response.headers["X-Request-Id"] = rid
logger.info("rid=%s %s %s -> %s %sms", rid, request.method, request.url.path,
response.status_code, round((time.monotonic() - start) * 1000, 1))
return response
# ============================================================================
# 3. АУТЕНТИФИКАЦИЯ
# Bearer — для всех бизнес-запросов. Basic — только на POST /auth/sessions.
# X-User-Id больше ничего не значит и ни на что не влияет.
# ============================================================================
def unauthorized(message: str = "invalid or missing bearer token") -> ApiError:
return ApiError(401, "unauthorized", message, {"WWW-Authenticate": BEARER_CHALLENGE})
def _bearer_token(request: Request) -> str:
auth = request.headers.get("authorization", "")
scheme, _, token = auth.partition(" ")
token = token.strip()
if scheme.lower() != "bearer" or not token or len(token) > 512:
raise unauthorized()
return token
async def current_user(request: Request) -> dict:
"""Зависимость FastAPI: выполняется ДО разбора тела → сначала 401, потом 400."""
token = _bearer_token(request)
user = await sessions.resolve(db.get_pool(), token, repo.get_user)
if user is None:
raise unauthorized()
request.state.token = token
return user
def _parse_basic(request: Request) -> tuple[str, str]:
bad = ApiError(401, "unauthorized", "invalid credentials", {"WWW-Authenticate": BASIC_CHALLENGE})
scheme, _, value = request.headers.get("authorization", "").partition(" ")
if scheme.lower() != "basic" or not value:
raise bad
try:
decoded = base64.b64decode(value.strip(), validate=True).decode("utf-8")
except (binascii.Error, UnicodeDecodeError):
raise bad
username, sep, password = decoded.partition(":") # двоеточие в пароле допустимо
if not sep or not username.isascii() or not (12 <= len(password) <= 128):
raise bad
return username, password
def require_json(request: Request) -> None:
"""Тип тела проверяем ДО валидации тела: не JSON → 415, а не 400.
Подключается после current_user, поэтому без токена по-прежнему сначала 401.
Параметры вроде '; charset=utf-8' допустимы."""
media_type = request.headers.get("content-type", "").split(";", 1)[0].strip().lower()
if media_type != "application/json":
raise ApiError(415, "unsupported_media_type", "Content-Type must be application/json")
# ============================================================================
# 4. МОДЕЛИ ВВОДА
# ============================================================================
class CreateUser(BaseModel):
model_config = {"extra": "forbid"}
username: str
display_name: str
password: str
@field_validator("username")
@classmethod
def check_username(cls, v: str) -> str:
if not USERNAME_RE.match(v):
raise ValueError("username must match [a-z0-9_]{3,32}")
return v
@field_validator("display_name")
@classmethod
def check_display_name(cls, v: str) -> str:
if not (1 <= len(v) <= 100) or not v.strip():
raise ValueError("display_name must be 1..100 non-blank chars")
return v
@field_validator("password")
@classmethod
def check_password(cls, v: str) -> str:
if not (12 <= len(v) <= 128) or not v.strip():
raise ValueError("password must be 12..128 chars")
return v
class CreateChat(BaseModel):
model_config = {"extra": "forbid"}
title: str
member_ids: list[str]
@field_validator("title")
@classmethod
def check_title(cls, v: str) -> str:
if not (1 <= len(v) <= 100) or not v.strip():
raise ValueError("title must be 1..100 non-blank chars")
return v
class CreateMessage(BaseModel):
model_config = {"extra": "forbid"}
text: str
@field_validator("text")
@classmethod
def check_text(cls, v: str) -> str:
if not (1 <= len(v) <= 4000) or not v.strip():
raise ValueError("text must be 1..4000 non-blank chars")
return v
def parse_uuid(value: str, what: str) -> uuid.UUID:
try:
return uuid.UUID(value)
except ValueError:
raise ApiError(400, "invalid_request", f"{what} is not a valid uuid")
# ============================================================================
# 5. ENDPOINTS
# ============================================================================
@app.get("/health/live")
async def health_live():
return {"status": "ok"}
@app.get("/health/ready")
async def health_ready(request: Request):
# Критичная зависимость — только PostgreSQL. Redis — кэш: его отказ не делает API неготовым.
try:
async with db.get_pool().connection() as conn:
await conn.execute("SELECT 1 FROM schema_migrations LIMIT 1")
except (psycopg.Error, PoolTimeout):
return error_response(request, 503, "unavailable", "database is not ready")
return {"status": "ok"}
# -------- users и сессии --------
@app.post("/api/v1/users", status_code=201)
async def create_user(body: CreateUser, _json: None = Depends(require_json)):
# Argon2 намеренно медленный — считаем в пуле потоков, чтобы не блокировать event loop.
password_hash = await run_in_threadpool(security.hash_password, body.password)
async with db.get_pool().connection() as conn:
try:
return await repo.create_user(conn, body.username, body.display_name, password_hash)
except repo.UsernameTaken:
raise ApiError(409, "conflict", "username already taken")
@app.post("/api/v1/auth/sessions", status_code=201)
async def create_session(request: Request):
username, password = _parse_basic(request)
async with db.get_pool().connection() as conn:
row = await repo.get_credentials(conn, username)
stored_hash = row[4] if row else None
# Проверяем хэш даже для несуществующего пользователя — одинаковое время ответа.
ok = await run_in_threadpool(security.verify_password, stored_hash, password)
if not ok:
raise ApiError(401, "unauthorized", "invalid credentials", {"WWW-Authenticate": BASIC_CHALLENGE})
user = repo.user_out(row)
async with db.get_pool().connection() as conn:
if security.needs_rehash(stored_hash):
await repo.update_password_hash(conn, row[0], await run_in_threadpool(security.hash_password, password))
token, expires_at = await sessions.create_session(conn, row[0])
return {"token": token, "token_type": "Bearer", "expires_at": repo.iso(expires_at), "user": user}
@app.delete("/api/v1/auth/sessions/current", status_code=204)
async def delete_session(request: Request, user: dict = Depends(current_user)):
try:
revoked = await sessions.revoke(db.get_pool(), request.state.token)
except sessions.CacheUnavailable:
# 204 только при гарантированном отзыве; иначе ограниченная ошибка, повторить позже.
raise ApiError(503, "unavailable", "session cache unavailable, logout not confirmed")
if not revoked:
raise unauthorized()
return Response(status_code=204)
@app.get("/api/v1/users/me")
async def get_me(user: dict = Depends(current_user)):
return user
# -------- chats --------
@app.post("/api/v1/chats", status_code=201)
async def create_chat(body: CreateChat, user: dict = Depends(current_user),
_json: None = Depends(require_json)):
members = body.member_ids
if not (1 <= len(members) <= 100):
raise ApiError(400, "invalid_request", "member_ids must have 1..100 items")
if len(set(members)) != len(members):
raise ApiError(400, "invalid_request", "duplicate member_ids")
ids = [parse_uuid(m, "member id") for m in members]
if uuid.UUID(user["id"]) not in ids:
raise ApiError(400, "invalid_request", "caller must be a member")
async with db.get_pool().connection() as conn:
# Одна транзакция: чат и все участники создаются вместе или не создаются вовсе.
async with conn.transaction():
if await repo.count_existing_users(conn, ids) != len(ids):
raise ApiError(400, "invalid_request", "unknown member")
return await repo.insert_chat(conn, body.title, ids, user["id"])
@app.get("/api/v1/chats")
async def list_chats(user: dict = Depends(current_user),
limit: int = Query(default=50, ge=1, le=100),
cursor: str | None = Query(default=None, min_length=1)):
async with db.get_pool().connection() as conn:
try:
items, nxt = await repo.list_chats(conn, user["id"], limit, cursor)
except ValueError:
raise ApiError(400, "invalid_request", "bad cursor")
return {"items": items, "next_cursor": nxt}
async def accessible_chat(conn, chat_id: str, user: dict) -> dict:
"""Кривой UUID → 400. Чата нет ИЛИ ты не участник → одинаковый 404."""
cid = parse_uuid(chat_id, "chat_id")
chat = await repo.get_chat_for_member(conn, cid, user["id"])
if chat is None:
raise ApiError(404, "not_found", "chat not found")
return chat
@app.get("/api/v1/chats/{chat_id}")
async def get_chat(chat_id: str, user: dict = Depends(current_user)):
async with db.get_pool().connection() as conn:
return await accessible_chat(conn, chat_id, user)
# -------- messages --------
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
async def send_message(chat_id: str, body: CreateMessage, user: dict = Depends(current_user),
_json: None = Depends(require_json)):
async with db.get_pool().connection() as conn:
chat = await accessible_chat(conn, chat_id, user)
# Отправитель — из сессии, а не из тела запроса.
return await repo.insert_message(conn, chat["id"], user["id"], body.text)
@app.get("/api/v1/chats/{chat_id}/messages")
async def list_messages(chat_id: str, user: dict = Depends(current_user),
limit: int = Query(default=50, ge=1, le=100),
cursor: str | None = Query(default=None, min_length=1)):
async with db.get_pool().connection() as conn:
chat = await accessible_chat(conn, chat_id, user)
try:
items, nxt = await repo.list_messages(conn, chat["id"], limit, cursor)
except ValueError:
raise ApiError(400, "invalid_request", "bad cursor")
return {"items": items, "next_cursor": nxt}
+57
View File
@@ -0,0 +1,57 @@
"""
Версионируемые миграции: migrations/NNNN_name.sql.
- Таблица schema_migrations хранит применённые версии → повторный запуск
ничего не дублирует (идемпотентно).
- Каждая миграция применяется в своей транзакции: либо целиком, либо никак.
- pg_advisory_lock: если стартуют несколько API одновременно, миграции
выполнит только один, остальные подождут.
Запуск вручную: python -m app.migrate
"""
from __future__ import annotations
import asyncio
import logging
from pathlib import Path
import psycopg
from .config import settings
log = logging.getLogger("messenger.migrate")
MIGRATIONS_DIR = Path(__file__).resolve().parent.parent / "migrations"
LOCK_ID = 824_113_2026 # произвольная константа для advisory lock
async def migrate(conninfo: str | None = None) -> list[str]:
applied_now: list[str] = []
async with await psycopg.AsyncConnection.connect(
conninfo or settings.database_url,
connect_timeout=settings.db_connect_timeout, autocommit=True) as conn:
await conn.execute("SELECT pg_advisory_lock(%s)", (LOCK_ID,))
try:
await conn.execute(
"CREATE TABLE IF NOT EXISTS schema_migrations ("
" version text PRIMARY KEY,"
" applied_at timestamptz NOT NULL DEFAULT now())")
cur = await conn.execute("SELECT version FROM schema_migrations")
done = {row[0] for row in await cur.fetchall()}
for path in sorted(MIGRATIONS_DIR.glob("*.sql")):
version = path.stem
if version in done:
continue
async with conn.transaction():
await conn.execute(path.read_text(encoding="utf-8"))
await conn.execute(
"INSERT INTO schema_migrations (version) VALUES (%s)", (version,))
applied_now.append(version)
log.info("migration applied: %s", version)
finally:
await conn.execute("SELECT pg_advisory_unlock(%s)", (LOCK_ID,))
return applied_now
if __name__ == "__main__":
logging.basicConfig(level=logging.INFO)
result = asyncio.run(migrate())
print("applied:", result or "nothing (up to date)")
+176
View File
@@ -0,0 +1,176 @@
"""
Доступ к данным в PostgreSQL. Только параметризованные запросы (%s):
значения передаются отдельно от текста SQL, инъекция невозможна.
"""
from __future__ import annotations
import base64
import json
import uuid
from datetime import datetime, timezone
from psycopg.errors import UniqueViolation
def iso(dt: datetime) -> str:
"""RFC 3339 UTC с Z — формат контракта."""
return dt.astimezone(timezone.utc).isoformat().replace("+00:00", "Z")
def now() -> datetime:
return datetime.now(timezone.utc)
# ---------------------------------------------------------------- курсор
def encode_cursor(scope: str, created_at: datetime, id_) -> str:
raw = json.dumps({"s": scope, "c": iso(created_at), "i": str(id_)}).encode()
return base64.urlsafe_b64encode(raw).decode()
def decode_cursor(cursor: str, scope: str) -> tuple[datetime, uuid.UUID]:
"""(created_at, id) последнего показанного элемента или ValueError → 400."""
try:
data = json.loads(base64.urlsafe_b64decode(cursor.encode()))
if data.get("s") != scope:
raise ValueError("cursor scope mismatch")
return datetime.fromisoformat(data["c"].replace("Z", "+00:00")), uuid.UUID(data["i"])
except (ValueError, KeyError, TypeError, AttributeError) as exc:
raise ValueError("bad cursor") from exc
def _page(rows: list, limit: int, scope: str, key):
"""rows получены с LIMIT limit+1: лишняя строка = есть следующая страница."""
has_more = len(rows) > limit
page = rows[:limit]
next_cursor = encode_cursor(scope, *key(page[-1])) if has_more and page else None
return page, next_cursor
# ---------------------------------------------------------------- users
USER_COLS = "id, username, display_name, created_at"
def user_out(row) -> dict:
return {"id": str(row[0]), "username": row[1], "display_name": row[2], "created_at": iso(row[3])}
class UsernameTaken(Exception):
pass
async def create_user(conn, username: str, display_name: str, password_hash: str) -> dict:
try:
cur = await conn.execute(
f"INSERT INTO users (id, username, display_name, password_hash, created_at) "
f"VALUES (%s, %s, %s, %s, %s) RETURNING {USER_COLS}",
(uuid.uuid4(), username, display_name, password_hash, now()))
except UniqueViolation as exc:
# Уникальность username гарантирует БД, а не проверка «есть ли такой»
# перед вставкой: две одновременные регистрации не пройдут обе.
raise UsernameTaken() from exc
return user_out(await cur.fetchone())
async def get_user(conn, user_id) -> dict | None:
cur = await conn.execute(f"SELECT {USER_COLS} FROM users WHERE id = %s", (user_id,))
row = await cur.fetchone()
return user_out(row) if row else None
async def get_credentials(conn, username: str):
cur = await conn.execute(
f"SELECT {USER_COLS}, password_hash FROM users WHERE username = %s", (username,))
return await cur.fetchone()
async def update_password_hash(conn, user_id, password_hash: str) -> None:
await conn.execute("UPDATE users SET password_hash = %s WHERE id = %s", (password_hash, user_id))
# ---------------------------------------------------------------- chats
CHAT_SELECT = (
"SELECT 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) "
"FROM chats c ")
def chat_out(row) -> dict:
return {"id": str(row[0]), "title": row[1],
"member_ids": [str(x) for x in row[3]], "created_at": iso(row[2])}
async def count_existing_users(conn, ids: list[uuid.UUID]) -> int:
cur = await conn.execute("SELECT count(*) FROM users WHERE id = ANY(%s)", (ids,))
return (await cur.fetchone())[0]
async def insert_chat(conn, title: str, member_ids: list[uuid.UUID], creator) -> dict:
"""Чат + все участники. Вызывать внутри транзакции: либо всё, либо ничего."""
chat_id, created = uuid.uuid4(), now()
await conn.execute(
"INSERT INTO chats (id, title, created_by, created_at) VALUES (%s, %s, %s, %s)",
(chat_id, title, creator, created))
async with conn.cursor() as cur:
await cur.executemany(
"INSERT INTO chat_members (chat_id, user_id, position) VALUES (%s, %s, %s)",
[(chat_id, uid, pos) for pos, uid in enumerate(member_ids)])
return {"id": str(chat_id), "title": title,
"member_ids": [str(x) for x in member_ids], "created_at": iso(created)}
async def get_chat_for_member(conn, chat_id, user_id) -> dict | None:
"""Чат, если он существует И пользователь в нём состоит; иначе None (→ 404)."""
cur = await conn.execute(
CHAT_SELECT + "WHERE c.id = %s AND EXISTS "
"(SELECT 1 FROM chat_members x WHERE x.chat_id = c.id AND x.user_id = %s)",
(chat_id, user_id))
row = await cur.fetchone()
return chat_out(row) if row else None
async def list_chats(conn, user_id, limit: int, cursor: str | None):
scope = f"chats:{user_id}"
params: list = [user_id]
where = ""
if cursor:
c_at, c_id = decode_cursor(cursor, scope)
where = "WHERE (c.created_at, c.id) > (%s, %s) "
params += [c_at, c_id]
cur = await conn.execute(
CHAT_SELECT + "JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s "
+ where + "ORDER BY c.created_at, c.id LIMIT %s", (*params, limit + 1))
rows = await cur.fetchall()
page, nxt = _page(rows, limit, scope, key=lambda r: (r[2], r[0]))
return [chat_out(r) for r in page], nxt
# ---------------------------------------------------------------- messages
MSG_COLS = "id, chat_id, sender_id, text, created_at"
def message_out(row) -> dict:
return {"id": str(row[0]), "chat_id": str(row[1]), "sender_id": str(row[2]),
"text": row[3], "created_at": iso(row[4])}
async def insert_message(conn, chat_id, sender_id, text: str) -> dict:
cur = await conn.execute(
f"INSERT INTO messages ({MSG_COLS}) VALUES (%s, %s, %s, %s, %s) RETURNING {MSG_COLS}",
(uuid.uuid4(), chat_id, sender_id, text, now()))
return message_out(await cur.fetchone())
async def list_messages(conn, chat_id, limit: int, cursor: str | None):
"""Keyset-пагинация по индексу (chat_id, created_at, id): без OFFSET и без скана истории."""
scope = f"messages:{chat_id}"
params: list = [chat_id]
where = ""
if cursor:
c_at, c_id = decode_cursor(cursor, scope)
where = "AND (created_at, id) > (%s, %s) "
params += [c_at, c_id]
cur = await conn.execute(
f"SELECT {MSG_COLS} FROM messages WHERE chat_id = %s " + where
+ "ORDER BY created_at, id LIMIT %s", (*params, limit + 1))
rows = await cur.fetchall()
page, nxt = _page(rows, limit, scope, key=lambda r: (r[4], r[0]))
return [message_out(r) for r in page], nxt
+46
View File
@@ -0,0 +1,46 @@
"""
Пароли и токены.
Пароль: Argon2id (password KDF). Он специально медленный и требует память,
поэтому перебор украденных хэшей дорог. Соль своя у каждого хэша.
Токен сессии: 32 случайных байта (256 бит) из secrets — непрозрачная строка,
не связанная с username/UUID. В БД кладём SHA-256 от токена: для случайного
256-битного значения быстрый хэш достаточен (перебирать нечего), а утечка
таблицы sessions не даёт рабочих токенов.
"""
from __future__ import annotations
import hashlib
import secrets
from argon2 import PasswordHasher
from argon2.exceptions import InvalidHashError, VerificationError, VerifyMismatchError
_hasher = PasswordHasher() # Argon2id, параметры по умолчанию библиотеки (RFC 9106 low-memory)
# Хэш-заглушка: проверяем пароль даже для несуществующего пользователя,
# чтобы по времени ответа нельзя было узнать, существует ли username.
_DUMMY_HASH = _hasher.hash("dummy-password-for-timing")
def hash_password(password: str) -> str:
return _hasher.hash(password)
def verify_password(password_hash: str | None, password: str) -> bool:
try:
return _hasher.verify(password_hash or _DUMMY_HASH, password) and password_hash is not None
except (VerifyMismatchError, VerificationError, InvalidHashError):
return False
def needs_rehash(password_hash: str) -> bool:
return _hasher.check_needs_rehash(password_hash)
def new_token() -> str:
return secrets.token_urlsafe(32) # 256 бит энтропии
def token_hash(token: str) -> bytes:
return hashlib.sha256(token.encode("utf-8")).digest()
+168
View File
@@ -0,0 +1,168 @@
"""
Сессии: PostgreSQL — источник истины, Redis/Valkey — кэш поиска сессии.
Чтение (проверка Bearer):
1. Ищем в Redis ключ sess:<sha256(token)>. Нашли и не истёк → пользователь.
2. Нет в кэше / Redis недоступен → читаем sessions в PostgreSQL
(не отозвана и expires_at > now()) и кладём результат в кэш.
Политика expiry: срок жизни сессии задаёт PostgreSQL (expires_at).
TTL ключа в Redis = min(SESSION_CACHE_TTL_SECONDS, время до expires_at),
поэтому кэш никогда не продлевает сессию.
Инвалидация (logout) — атомарно для БД и кэша:
в одной транзакции UPDATE sessions SET revoked_at (строка блокируется),
затем DEL ключа в Redis. Если Redis не ответил — транзакция откатывается и
клиент получает 503: logout НЕ подтверждён, 204 отдаётся только когда
копии отозванной сессии в кэше гарантированно нет.
Гонка «чтение кладёт старую сессию в кэш после DEL» закрыта блокировкой:
чтение из БД идёт с FOR SHARE и кладёт в кэш, не отпуская строку, поэтому
logout ждёт окончания такого чтения и удаляет ключ уже после него.
Отказ Redis: кэш обходится, всё читается из PostgreSQL (медленнее, но верно).
Flush/рестарт Redis: кэш пустой → сессии восстанавливаются из PostgreSQL.
Отказ PostgreSQL: новые проверки идут в БД → 503, анонимный запрос не принимается.
"""
from __future__ import annotations
import json
import logging
from datetime import datetime, timedelta, timezone
import redis.asyncio as aioredis
from redis.exceptions import RedisError
from .config import settings
from .security import new_token, token_hash
log = logging.getLogger("messenger.sessions")
_redis: aioredis.Redis | None = None
def init_redis() -> None:
global _redis
if settings.redis_url:
_redis = aioredis.Redis.from_url(
settings.redis_url,
socket_timeout=settings.redis_timeout,
socket_connect_timeout=settings.redis_timeout,
decode_responses=True,
)
async def close_redis() -> None:
if _redis is not None:
await _redis.aclose()
def redis_enabled() -> bool:
return _redis is not None
async def redis_ping() -> bool:
if _redis is None:
return False
try:
return bool(await _redis.ping())
except (RedisError, OSError):
return False
def _key(th: bytes) -> str:
return "sess:" + th.hex()
async def _cache_get(th: bytes) -> dict | None:
if _redis is None:
return None
try:
raw = await _redis.get(_key(th))
except (RedisError, OSError) as exc:
log.warning("redis unavailable on read, bypassing cache: %s", type(exc).__name__)
return None
return json.loads(raw) if raw else None
async def _cache_put(th: bytes, user: dict, expires_at: datetime) -> None:
if _redis is None:
return
left = int((expires_at - datetime.now(timezone.utc)).total_seconds())
ttl = min(settings.session_cache_ttl_seconds, left)
if ttl <= 0:
return
try:
await _redis.set(_key(th), json.dumps({"user": user, "exp": expires_at.isoformat()}), ex=ttl)
except (RedisError, OSError) as exc:
log.warning("redis unavailable on write, skipping cache: %s", type(exc).__name__)
class CacheUnavailable(Exception):
"""Redis не подтвердил удаление ключа — отзыв сессии нельзя гарантировать."""
async def _cache_delete_strict(th: bytes) -> None:
"""Удалить копию сессии из кэша или поднять CacheUnavailable.
Молча проглатывать ошибку нельзя: если Redis «приостановлен», ключ
переживёт сбой и после восстановления отозванный токен снова примут."""
if _redis is None:
return
try:
await _redis.delete(_key(th))
except (RedisError, OSError) as exc:
log.warning("redis unavailable on invalidate: %s", type(exc).__name__)
raise CacheUnavailable() from exc
async def create_session(conn, user_id) -> tuple[str, datetime]:
token = new_token()
now = datetime.now(timezone.utc)
expires_at = now + timedelta(seconds=settings.session_ttl_seconds)
await conn.execute(
"INSERT INTO sessions (token_hash, user_id, created_at, expires_at) "
"VALUES (%s, %s, %s, %s)",
(token_hash(token), user_id, now, expires_at))
return token, expires_at
async def resolve(pool, token: str, load_user) -> dict | None:
"""Вернёт пользователя (dict) для действующего токена или None."""
th = token_hash(token)
cached = await _cache_get(th)
if cached is not None:
if datetime.fromisoformat(cached["exp"]) > datetime.now(timezone.utc):
return cached["user"]
return None
async with pool.connection() as conn:
# FOR SHARE: пока эта транзакция не закончилась (вместе с записью в кэш),
# logout не сможет отозвать строку — он дождётся и удалит ключ после нас.
cur = await conn.execute(
"SELECT user_id, expires_at FROM sessions "
"WHERE token_hash = %s AND revoked_at IS NULL AND expires_at > now() "
"FOR SHARE",
(th,))
row = await cur.fetchone()
if row is None:
return None
user = await load_user(conn, row[0])
if user is None:
return None
await _cache_put(th, user, row[1])
return user
async def revoke(pool, token: str) -> bool:
"""Отозвать сессию. True — была действующая и теперь отозвана (и в БД, и в кэше).
False — сессии нет/уже отозвана. CacheUnavailable — Redis не ответил:
транзакция откатана, сессия осталась действующей, logout не подтверждён."""
th = token_hash(token)
async with pool.connection() as conn:
async with conn.transaction():
cur = await conn.execute(
"UPDATE sessions SET revoked_at = now() "
"WHERE token_hash = %s AND revoked_at IS NULL AND expires_at > now() "
"RETURNING 1", (th,))
if await cur.fetchone() is None:
return False
# Внутри транзакции: ошибка Redis → исключение → ROLLBACK отзыва.
await _cache_delete_strict(th)
return True
+76
View File
@@ -0,0 +1,76 @@
# Локальный стенд lab2: API + PostgreSQL (источник истины) + Redis (кэш сессий).
# Запуск: docker compose --env-file .env up -d --build
# Данные лежат в именованном volume pgdata и переживают перезапуск контейнеров.
name: mtusi-messenger
x-api-env: &api-env
DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB}
CACHE_URL: redis://redis:6379/0
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
SESSION_CACHE_TTL_SECONDS: ${SESSION_CACHE_TTL_SECONDS:-60}
DB_POOL_MAX: ${DB_POOL_MAX:-10}
DB_POOL_TIMEOUT: ${DB_POOL_TIMEOUT:-3}
DB_STATEMENT_TIMEOUT_MS: ${DB_STATEMENT_TIMEOUT_MS:-5000}
REDIS_TIMEOUT: ${REDIS_TIMEOUT:-0.5}
LOG_LEVEL: ${LOG_LEVEL:-info}
services:
postgres:
image: postgres:16.4-alpine
environment:
POSTGRES_DB: ${POSTGRES_DB}
POSTGRES_USER: ${POSTGRES_USER}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
interval: 5s
timeout: 3s
retries: 20
restart: unless-stopped
redis:
image: redis:7.4.1-alpine
# Чистый кэш: persistence выключен намеренно. Источник истины сессий — PostgreSQL,
# после рестарта Redis кэш пуст и заполняется заново из базы.
command: ["redis-server", "--save", "", "--appendonly", "no",
"--maxmemory", "64mb", "--maxmemory-policy", "allkeys-lru"]
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 3s
retries: 20
restart: unless-stopped
api:
build: .
image: mtusi-messenger:lab2
environment: *api-env
ports:
- "127.0.0.1:8080:8080"
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_started
restart: unless-stopped
# Второй экземпляр API с коротким TTL — только для теста истечения сессии.
# Запуск: docker compose --env-file .env --profile ttl up -d api-ttl
api-ttl:
image: mtusi-messenger:lab2
environment:
<<: *api-env
SESSION_TTL_SECONDS: "2"
SESSION_CACHE_TTL_SECONDS: "60"
MIGRATE_ON_START: "false"
ports:
- "127.0.0.1:8081:8080"
depends_on:
postgres:
condition: service_healthy
profiles: ["ttl"]
volumes:
pgdata:
+8
View File
@@ -0,0 +1,8 @@
# 2026-10-15T10:02Z, второй экземпляр API с SESSION_TTL_SECONDS=2 (в compose: api-ttl на 8081)
$ python student-tests/expiry.py
ok - login -> 201
ok - expires_at is about 2s ahead (got 2.00s)
ok - token works before expiry
ok - expired token -> 401 (cache does not extend the session)
4 passed, 0 failed
+57
View File
@@ -0,0 +1,57 @@
BEGIN
INSERT 0 1
INSERT 0 10
INSERT 0 10
INSERT 0 60000
ANALYZE
messages_in_target_chat
-------------------------
12000
(1 row)
=== 1. Первая страница (limit 50 + 1) ===
QUERY PLAN
------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.41..14.11 rows=51 width=65) (actual time=0.010..0.018 rows=51 loops=1)
Buffers: shared hit=4
-> Index Scan using messages_chat_created_id_idx on messages (cost=0.41..3252.33 rows=12114 width=65) (actual time=0.010..0.014 rows=51 loops=1)
Index Cond: (chat_id = '00000000-0000-4000-8000-000000000100'::uuid)
Buffers: shared hit=4
Planning:
Buffers: shared hit=18
Planning Time: 0.107 ms
Execution Time: 0.032 ms
(9 rows)
=== 2. Страница из середины истории (keyset-курсор после ~6000-го сообщения) ===
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.42..15.40 rows=51 width=65) (actual time=0.012..0.035 rows=51 loops=1)
Buffers: shared hit=5
-> Index Scan using messages_chat_created_id_idx on messages (cost=0.42..3199.66 rows=10891 width=65) (actual time=0.011..0.030 rows=51 loops=1)
Index Cond: ((chat_id = '00000000-0000-4000-8000-000000000100'::uuid) AND (ROW(created_at, id) > ROW(((now() - '1 day'::interval) + '00:00:06'::interval), '00000000-0000-0000-0000-000000000000'::uuid)))
Buffers: shared hit=5
Planning Time: 0.079 ms
Execution Time: 0.094 ms
(7 rows)
=== 3. Для сравнения: та же страница, если запретить индекс ===
SET
SET
QUERY PLAN
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=2603.40..2603.52 rows=51 width=65) (actual time=6.820..6.826 rows=51 loops=1)
Buffers: shared hit=740
-> Sort (cost=2603.40..2630.62 rows=10891 width=65) (actual time=6.819..6.821 rows=51 loops=1)
Sort Key: created_at, id
Sort Method: top-N heapsort Memory: 31kB
Buffers: shared hit=740
-> Seq Scan on messages (cost=0.00..2240.05 rows=10891 width=65) (actual time=1.638..6.339 rows=6001 loops=1)
Filter: ((chat_id = '00000000-0000-4000-8000-000000000100'::uuid) AND (ROW(created_at, id) > ROW(((now() - '1 day'::interval) + '00:00:06'::interval), '00000000-0000-0000-0000-000000000000'::uuid)))
Rows Removed by Filter: 54001
Buffers: shared hit=740
Planning Time: 0.072 ms
Execution Time: 6.841 ms
(12 rows)
ROLLBACK
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 2,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 15.0,
"elapsed_seconds": 15.11,
"concurrency": 4,
"successful_requests": 6636,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 439.183,
"successful_latency_ms": {
"p50": 8.483,
"p95": 13.092,
"p99": 17.662
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
+27
View File
@@ -0,0 +1,27 @@
# 2026-10-22T10:10Z, Redis приостановлен процессным сигналом (в Docker: docker compose pause/unpause redis)
$ python student-tests/logout_cache.py
ok - session is warmed up in cache
== Redis приостановлен ==
$ kill -STOP 4026
ok - logout is NOT confirmed while cache cannot be invalidated (got 503, expected 503)
$ kill -CONT 4026
== Redis восстановлен ==
ok - unconfirmed logout left the session consistent and valid (got 200)
ok - retry logout after Redis recovery -> 204 (got 204)
ok - old token after confirmed logout -> 401, no stale cache copy (got 401)
ok - old token still rejected on repeat (got 401)
6 passed, 0 failed
# Для сравнения: та же проверка на версии ДО исправления (commit dbdb66456a)
ok - session is warmed up in cache
== Redis приостановлен ==
$ kill -STOP 6663
FAIL - logout is NOT confirmed while cache cannot be invalidated (got 204, expected 503)
$ kill -CONT 6663
== Redis восстановлен ==
FAIL - after a 204 the old token is rejected after Redis recovery (got 200)
FAIL - old token after confirmed logout -> 401, no stale cache copy (got 200)
FAIL - old token still rejected on repeat (got 200)
1 passed, 4 failed
+37
View File
@@ -0,0 +1,37 @@
# 2026-10-15T09:59Z повторный запуск миграций на заполненной БД
$ python -m app.migrate
applied: nothing (up to date)
$ psql: SELECT version, applied_at FROM schema_migrations; SELECT count(*) FROM users
version | applied_at
-----------+------------------------------
0001_init | 2026-10-15 12:50:12.87179+03
(1 row)
users
-------
46
(1 row)
$ python -m app.migrate (ещё раз)
applied: nothing (up to date)
users
-------
46
(1 row)
# миграции с нуля на пустой БД
$ DATABASE_URL=.../fresh python -m app.migrate
INFO:messenger.migrate:migration applied: 0001_init
applied: ['0001_init']
List of relations
Schema | Name | Type | Owner
--------+-------------------+-------+-----------
public | chat_members | table | messenger
public | chats | table | messenger
public | messages | table | messenger
public | schema_migrations | table | messenger
public | sessions | table | messenger
public | users | table | messenger
(6 rows)
+21
View File
@@ -0,0 +1,21 @@
# 2026-10-15T10:02Z, локальный стенд; в Docker тот же скрипт по умолчанию делает docker compose stop/start
== 1. Redis недоступен ==
$ redis-cli shutdown nosave
ok - valid token still works without Redis (cache bypassed)
ok - writes still work without Redis
ok - login works without Redis
ok - forged token still rejected without Redis
$ redis-server --daemonize yes --save '' --appendonly no
== 2. PostgreSQL недоступен ==
$ su postgres -c '/usr/lib/postgresql/16/bin/pg_ctl -D /tmp/pgdata -m fast -w stop'
ok - history without DB -> 503, not a hang (got 503)
ok - unknown token is never trusted without DB (got 503)
ok - anonymous request -> 401
ok - /health/ready -> 503
ok - /health/live -> 200 (process is alive)
$ su postgres -c '/usr/lib/postgresql/16/bin/pg_ctl -D /tmp/pgdata -w start -o "-p 5432 -k /tmp" -l /tmp/pg.log'
== 3. восстановление ==
ok - /health/ready back to 200
ok - same token reads the same history after DB is back
11 passed, 0 failed
+15
View File
@@ -0,0 +1,15 @@
# 2026-10-15T10:02Z
# hook: локальный аналог scripts/restart.sh (Docker недоступен на стенде): остановка API, pg_ctl restart PostgreSQL, перезапуск Redis, старт API; каталоги данных сохраняются
$ python tests/resilience.py --mode persistence --action-script <hook>
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
# процессы до/после (PID меняются => реально перезапущены):
before:
14201 python3 -m app
14621 redis-server *:6379
14632 /usr/lib/postgresql/16/bin/postgres -D /tmp/pgdata -p 5432 -k /tmp
after:
14958 /usr/lib/postgresql/16/bin/postgres -p 5432 -k /tmp
14968 redis-server *:6379
14975 python3 -m app
+5
View File
@@ -0,0 +1,5 @@
# 2026-10-15T10:02Z
$ python student-tests/rollback_check.py
ok - insert of unknown member failed on foreign key
ok - after rollback: chats=0, members=0 (expected 0, 0)
PASS
+7
View File
@@ -0,0 +1,7 @@
# 2026-10-15T10:02Z, local stand (PostgreSQL 16, Redis 7, Python 3.11), API http://127.0.0.1:8092
$ make check
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
$ make validate
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
$ make test
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
+34
View File
@@ -0,0 +1,34 @@
# 2026-10-15T10:02Z
$ python student-tests/run.py
== аутентификация ==
ok - wrong password -> 401 + Basic challenge
ok - unknown user -> 401 (same as wrong password)
ok - no token -> 401 + Bearer challenge
ok - X-User-Id alone gives no access
ok - unknown/forged token -> 401
ok - Basic on business endpoint -> 401
ok - X-User-Id cannot override bearer identity
ok - password shorter than 12 -> 400
== logout ==
ok - logout -> 204
ok - token after logout -> 401
ok - second logout -> 401
== гонка регистрации одного username ==
ok - 20 parallel registrations -> one 201, nineteen 409 (got [201, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409, 409])
== ошибки и доступ (из lab1) ==
ok - malformed JSON -> 400
ok - duplicate username -> 409
ok - blank message -> 400
ok - sender_id in body is rejected
ok - outsider POST to foreign chat -> 404
ok - outsider GET foreign history -> 404
ok - invalid chat uuid -> 400
== пагинация ==
ok - 5 messages / limit 2 -> 3 pages, no duplicates
ok - cursor from another chat -> 400
21 passed, 0 failed
$ python student-tests/race.py
sent=100 accepted=100 received=100 unique_ids=100 all_texts_present=True
PASS
+187
View File
@@ -0,0 +1,187 @@
# Перейти в папку проекта и создать .env (один раз)
cd C:\Users\79152\Desktop\mtusi2026lab2
copy .env.example .env
------------------------------------------------------------
# Запуск: API + PostgreSQL + Redis
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
docker compose ps
------------------------------------------------------------
# Миграции: применились при старте, повтор ничего не дублирует
docker compose logs api --tail 15
docker compose exec api python -m app.migrate
docker compose exec postgres psql -U messenger -d messenger -c "\dt"
docker compose exec postgres psql -U messenger -d messenger -c "SELECT * FROM schema_migrations"
------------------------------------------------------------
# Функции: St печатает код ответа, Login входит через Basic (вставить один раз)
function St($m,$u,$b,$h){ try{ if($b){ $r=Invoke-WebRequest $u -Method $m -ContentType 'application/json' -Body $b -Headers $h -UseBasicParsing } else { $r=Invoke-WebRequest $u -Method $m -Headers $h -UseBasicParsing }; $r.StatusCode } catch { $_.Exception.Response.StatusCode.value__ } }
function Login($u,$p){ $b=[Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes("${u}:${p}")); Invoke-RestMethod http://localhost:8080/api/v1/auth/sessions -Method Post -Headers @{ Authorization = "Basic $b" } }
------------------------------------------------------------
# Health
Invoke-RestMethod http://localhost:8080/health/live
Invoke-RestMethod http://localhost:8080/health/ready
------------------------------------------------------------
# Суффикс для уникальных имён и общий пароль
$s = Get-Random -Maximum 100000
$PW = 'Hockey-pass-2026'
------------------------------------------------------------
# Регистрация: Майк, Артём, Толя (пароля в ответе нет)
$mike = Invoke-RestMethod http://localhost:8080/api/v1/users -Method Post -ContentType application/json -Body "{""username"":""mike_$s"",""display_name"":""Mike"",""password"":""$PW""}"; $M = $mike.id; $mike
$artem = Invoke-RestMethod http://localhost:8080/api/v1/users -Method Post -ContentType application/json -Body "{""username"":""artem_$s"",""display_name"":""Artem"",""password"":""$PW""}"; $A = $artem.id; $artem
$toly = Invoke-RestMethod http://localhost:8080/api/v1/users -Method Post -ContentType application/json -Body "{""username"":""toly_$s"",""display_name"":""Toly"",""password"":""$PW""}"; $T = $toly.id; $toly
------------------------------------------------------------
# Вход (Basic) -> получаем Bearer-токены
$sm = Login "mike_$s" $PW; $sm | ConvertTo-Json -Depth 5
$sa = Login "artem_$s" $PW
$st = Login "toly_$s" $PW
$hM = @{ Authorization = "Bearer $($sm.token)" }
$hA = @{ Authorization = "Bearer $($sa.token)" }
$hT = @{ Authorization = "Bearer $($st.token)" }
------------------------------------------------------------
# Кто я (по Bearer)
Invoke-RestMethod http://localhost:8080/api/v1/users/me -Headers $hM
------------------------------------------------------------
# Майк создаёт чат с Артёмом
$body = "{""title"":""Hockey"",""member_ids"":[""$M"",""$A""]}"; $chat = Invoke-RestMethod http://localhost:8080/api/v1/chats -Method Post -ContentType application/json -Body $body -Headers $hM; $CHAT = $chat.id; $chat
------------------------------------------------------------
# Переписка: Артём, Майк, Артём
Invoke-RestMethod http://localhost:8080/api/v1/chats/$CHAT/messages -Method Post -ContentType 'application/json; charset=utf-8' -Body ([Text.Encoding]::UTF8.GetBytes('{"text":"Привет"}')) -Headers $hA
Invoke-RestMethod http://localhost:8080/api/v1/chats/$CHAT/messages -Method Post -ContentType 'application/json; charset=utf-8' -Body ([Text.Encoding]::UTF8.GetBytes('{"text":"Привет, как дела?"}')) -Headers $hM
Invoke-RestMethod http://localhost:8080/api/v1/chats/$CHAT/messages -Method Post -ContentType 'application/json; charset=utf-8' -Body ([Text.Encoding]::UTF8.GetBytes('{"text":"Хорошо, идём на тренировку?"}')) -Headers $hA
------------------------------------------------------------
# История чата и список чатов
Invoke-RestMethod "http://localhost:8080/api/v1/chats/$CHAT/messages" -Headers $hM | ConvertTo-Json -Depth 5
Invoke-RestMethod "http://localhost:8080/api/v1/chats" -Headers $hA | ConvertTo-Json -Depth 5
------------------------------------------------------------
# Пагинация по курсору
$p = Invoke-RestMethod "http://localhost:8080/api/v1/chats/$CHAT/messages?limit=2" -Headers $hM; $p | ConvertTo-Json -Depth 5; $C = [uri]::EscapeDataString($p.next_cursor)
Invoke-RestMethod "http://localhost:8080/api/v1/chats/$CHAT/messages?limit=2&cursor=$C" -Headers $hM | ConvertTo-Json -Depth 5
------------------------------------------------------------
# Ошибки аутентификации: все 401, кроме последней строки
$bad = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes("mike_${s}:wrong-password-1"))
$good = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes("mike_${s}:$PW"))
"nevernyy parol: " + (St POST "http://localhost:8080/api/v1/auth/sessions" $null @{ Authorization = "Basic $bad" })
"bez tokena: " + (St GET "http://localhost:8080/api/v1/users/me" $null @{})
"Basic na /users/me: " + (St GET "http://localhost:8080/api/v1/users/me" $null @{ Authorization = "Basic $good" })
"tolko X-User-Id: " + (St GET "http://localhost:8080/api/v1/users/me" $null @{ "X-User-Id" = $M })
"poddelnyy token: " + (St GET "http://localhost:8080/api/v1/users/me" $null @{ Authorization = "Bearer fake-token-123" })
(Invoke-RestMethod http://localhost:8080/api/v1/users/me -Headers @{ Authorization = "Bearer $($sm.token)"; "X-User-Id" = $T }).username
------------------------------------------------------------
# Ошибки доступа и данных: 404 / 400 / 400 / 409
"Tolya v chuzhom chate: " + (St GET "http://localhost:8080/api/v1/chats/$CHAT/messages" $null $hT)
"pustoy tekst: " + (St POST "http://localhost:8080/api/v1/chats/$CHAT/messages" '{"text":" "}' $hM)
"korotkiy parol: " + (St POST "http://localhost:8080/api/v1/users" "{""username"":""short_$s"",""display_name"":""S"",""password"":""123""}" @{})
"dubl username: " + (St POST "http://localhost:8080/api/v1/users" "{""username"":""mike_$s"",""display_name"":""Other"",""password"":""$PW""}" @{})
------------------------------------------------------------
# Что лежит в БД: хэш Argon2id вместо пароля, хэш токена вместо токена
docker compose exec postgres psql -U messenger -d messenger -c "SELECT username, left(password_hash, 40) AS hash FROM users ORDER BY created_at DESC LIMIT 3"
docker compose exec postgres psql -U messenger -d messenger -c "SELECT left(encode(token_hash,'hex'),16) AS token_sha256, expires_at, revoked_at FROM sessions ORDER BY created_at DESC LIMIT 3"
------------------------------------------------------------
# Redis: кэш сессий с TTL
Invoke-RestMethod http://localhost:8080/api/v1/users/me -Headers $hA | Out-Null
docker compose exec redis redis-cli --scan --pattern "sess:*"
$k = docker compose exec -T redis redis-cli --scan --pattern "sess:*" | Select-Object -First 1
docker compose exec redis redis-cli TTL $k
------------------------------------------------------------
# Logout Майка: 204, потом его токен 401
"logout: " + (St DELETE "http://localhost:8080/api/v1/auth/sessions/current" $null $hM)
"token posle logout: " + (St GET "http://localhost:8080/api/v1/users/me" $null $hM)
"povtornyy logout: " + (St DELETE "http://localhost:8080/api/v1/auth/sessions/current" $null $hM)
------------------------------------------------------------
# Ручной рестарт API + PostgreSQL + Redis: токен Артёма и история на месте
docker compose restart postgres redis api
docker compose ps
Invoke-RestMethod http://localhost:8080/health/ready
Invoke-RestMethod "http://localhost:8080/api/v1/chats/$CHAT/messages" -Headers $hA | ConvertTo-Json -Depth 5
------------------------------------------------------------
# Публичные тесты
python scripts\check_contract.py
python tests\smoke.py --base-url http://localhost:8080
------------------------------------------------------------
# Тест сохранности (persistence)
python tests\resilience.py --mode persistence --action-script scripts\restart.cmd --base-url http://localhost:8080
docker compose ps
------------------------------------------------------------
# Свои тесты: аутентификация, logout, гонка регистрации, ошибки, пагинация
python student-tests\run.py --base-url http://localhost:8080
------------------------------------------------------------
# Гонка: 10 клиентов x 10 сообщений
python student-tests\race.py --base-url http://localhost:8080
------------------------------------------------------------
# Истечение сессии: второй API с TTL = 2 секунды
docker compose --env-file .env --profile ttl up -d api-ttl
python student-tests\expiry.py --base-url http://localhost:8081
docker compose --profile ttl stop api-ttl
------------------------------------------------------------
# Отказ Redis и PostgreSQL
python student-tests\outage.py --base-url http://localhost:8080
------------------------------------------------------------
# Rollback создания чата
docker compose cp student-tests/rollback_check.py api:/tmp/rollback_check.py
docker compose exec api python /tmp/rollback_check.py
------------------------------------------------------------
# EXPLAIN истории на 60 000 сообщений
docker compose cp student-tests/explain.sql postgres:/tmp/explain.sql
docker compose exec postgres psql -U messenger -d messenger -f /tmp/explain.sql
------------------------------------------------------------
# Нагрузка (по желанию)
python tests\load.py --base-url http://localhost:8080 --duration 15 --concurrency 4
------------------------------------------------------------
# Остановка (данные в volume сохраняются)
docker compose down
+54
View File
@@ -0,0 +1,54 @@
-- 0001: начальная схема мессенджера (lab2).
-- Источник истины для пользователей, чатов, участников, сообщений и сессий.
CREATE TABLE users (
id uuid PRIMARY KEY,
username text NOT NULL,
display_name text NOT NULL,
password_hash text NOT NULL,
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_len CHECK (char_length(display_name) BETWEEN 1 AND 100)
);
CREATE TABLE chats (
id uuid PRIMARY KEY,
title text NOT NULL,
created_by uuid NOT NULL REFERENCES users (id),
created_at timestamptz NOT NULL,
CONSTRAINT chats_title_len CHECK (char_length(title) BETWEEN 1 AND 100)
);
-- Участники чата. position сохраняет порядок member_ids из запроса.
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,
PRIMARY KEY (chat_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,
created_at timestamptz NOT NULL,
CONSTRAINT messages_text_len CHECK (char_length(text) BETWEEN 1 AND 4000)
);
-- Keyset-пагинация истории: WHERE chat_id = $1 AND (created_at, id) > ($2, $3)
-- ORDER BY created_at, id LIMIT n — индекс отдаёт страницу без скана всей истории.
CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id);
-- Сессии. Храним только SHA-256 от токена: утечка таблицы не даёт рабочих токенов.
CREATE TABLE sessions (
token_hash bytea PRIMARY KEY,
user_id uuid NOT NULL REFERENCES users (id),
created_at timestamptz NOT NULL,
expires_at timestamptz NOT NULL,
revoked_at timestamptz
);
CREATE INDEX sessions_user_idx ON sessions (user_id);
CREATE INDEX sessions_expires_idx ON sessions (expires_at);
+8
View File
@@ -0,0 +1,8 @@
# Рантайм-зависимости, версии закреплены для воспроизводимой сборки.
fastapi==0.141.1
uvicorn[standard]==0.46.0
pydantic==2.13.3
psycopg[binary]==3.3.6
psycopg-pool==3.3.3
argon2-cffi==25.1.0
redis==8.1.0
+4
View File
@@ -0,0 +1,4 @@
@echo off
rem Restart hook for Windows: same as restart.sh (volumes are kept).
cd /d "%~dp0.."
docker compose --env-file .env restart postgres redis api
+6
View File
@@ -0,0 +1,6 @@
#!/bin/sh
# Restart hook для make test-persistence: перезапускает API и ВСЕ хранилища
# (PostgreSQL и Redis), сохраняя именованные volumes. Ничего не удаляет и не сидит данные.
set -eu
cd "$(dirname "$0")/.."
docker compose --env-file .env restart postgres redis api
+72
View File
@@ -0,0 +1,72 @@
"""Общий HTTP-клиент для собственных тестов (только стандартная библиотека)."""
import base64
import json
import urllib.error
import urllib.request
import uuid
PASSWORD = "Test-password-" + uuid.uuid4().hex[:8]
class Api:
def __init__(self, base: str):
self.base = base.rstrip("/")
def raw(self, method, path, data=None, headers=None, timeout=10):
req = urllib.request.Request(self.base + path, data=data, headers=headers or {}, method=method)
try:
with urllib.request.urlopen(req, timeout=timeout) as r:
return r.status, r.read(), r.headers
except urllib.error.HTTPError as e:
return e.code, e.read(), e.headers
def call(self, method, path, body=None, token=None, headers=None):
h = dict(headers or {})
data = None
if body is not None:
data = json.dumps(body, ensure_ascii=False).encode()
h["Content-Type"] = "application/json"
if token:
h["Authorization"] = "Bearer " + token
st, raw, rh = self.raw(method, path, data, h)
try:
return st, json.loads(raw or b"null"), rh
except ValueError:
return st, None, rh
def register(self, prefix: str, password: str = PASSWORD) -> dict:
name = (prefix + "_" + uuid.uuid4().hex[:10])[:32]
st, user, _ = self.call("POST", "/api/v1/users",
{"username": name, "display_name": prefix, "password": password})
assert st == 201, f"register {name}: {st} {user}"
user["password"] = password
return user
def login(self, username: str, password: str):
cred = base64.b64encode(f"{username}:{password}".encode()).decode()
st, body, rh = self.call("POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + cred})
return st, body, rh
def new_user(self, prefix: str) -> dict:
user = self.register(prefix)
st, sess, _ = self.login(user["username"], user["password"])
assert st == 201, f"login: {st}"
user["token"] = sess["token"]
return user
class Report:
def __init__(self):
self.passed = self.failed = 0
def check(self, cond, name):
if cond:
self.passed += 1
print(f" ok - {name}")
else:
self.failed += 1
print(f" FAIL - {name}")
def finish(self):
print(f"\n{self.passed} passed, {self.failed} failed")
raise SystemExit(1 if self.failed else 0)
+38
View File
@@ -0,0 +1,38 @@
#!/usr/bin/env python3
"""
Истечение сессии при коротком SESSION_TTL_SECONDS (=2).
Запускается против отдельного экземпляра API с коротким TTL:
docker compose --env-file .env --profile ttl up -d api-ttl
python student-tests/expiry.py --base-url http://localhost:8081
"""
import argparse
import time
from datetime import datetime, timezone
from common import Api, Report
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--base-url", default="http://localhost:8081")
ap.add_argument("--ttl", type=float, default=2)
args = ap.parse_args()
api, r = Api(args.base_url), Report()
user = api.register("ttl")
st, sess, _ = api.login(user["username"], user["password"])
r.check(st == 201, "login -> 201")
exp = datetime.fromisoformat(sess["expires_at"].replace("Z", "+00:00"))
left = (exp - datetime.now(timezone.utc)).total_seconds()
r.check(0 < left <= args.ttl + 1, f"expires_at is about {args.ttl}s ahead (got {left:.2f}s)")
st, _, _ = api.call("GET", "/api/v1/users/me", token=sess["token"])
r.check(st == 200, "token works before expiry") # заодно кладёт сессию в кэш Redis
time.sleep(args.ttl + 1.5)
st, _, rh = api.call("GET", "/api/v1/users/me", token=sess["token"])
r.check(st == 401 and rh.get("WWW-Authenticate", "").startswith("Bearer"),
"expired token -> 401 (cache does not extend the session)")
r.finish()
if __name__ == "__main__":
main()
+60
View File
@@ -0,0 +1,60 @@
-- План запроса истории на ≥10 000 сообщениях (уровень «4»).
-- Всё внутри транзакции с ROLLBACK: учебные данные не остаются в базе.
-- Запуск (одинаково в PowerShell и sh):
-- docker compose cp student-tests/explain.sql postgres:/tmp/explain.sql
-- docker compose exec postgres psql -U messenger -d messenger -f /tmp/explain.sql
BEGIN;
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES ('00000000-0000-4000-8000-000000000001', 'explain_seed', 'Seed', 'x', now());
-- Чат, историю которого читаем, и 9 «соседних» чатов, чтобы в таблице были чужие сообщения.
INSERT INTO chats (id, title, created_by, created_at)
SELECT ('00000000-0000-4000-8000-0000000001' || lpad(g::text, 2, '0'))::uuid, 'seed ' || g,
'00000000-0000-4000-8000-000000000001', now()
FROM generate_series(0, 9) g;
INSERT INTO chat_members (chat_id, user_id, position)
SELECT ('00000000-0000-4000-8000-0000000001' || lpad(g::text, 2, '0'))::uuid,
'00000000-0000-4000-8000-000000000001', 0
FROM generate_series(0, 9) g;
-- 12 000 сообщений в целевом чате + 48 000 в соседних = 60 000 строк.
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(),
('00000000-0000-4000-8000-0000000001' || lpad((CASE WHEN g <= 12000 THEN 0 ELSE g % 9 + 1 END)::text, 2, '0'))::uuid,
'00000000-0000-4000-8000-000000000001',
'msg ' || g,
now() - interval '1 day' + g * interval '1 millisecond'
FROM generate_series(1, 60000) g;
ANALYZE messages;
SELECT count(*) AS messages_in_target_chat
FROM messages WHERE chat_id = '00000000-0000-4000-8000-000000000100';
\echo '=== 1. Первая страница (limit 50 + 1) ==='
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = '00000000-0000-4000-8000-000000000100'
ORDER BY created_at, id LIMIT 51;
\echo '=== 2. Страница из середины истории (keyset-курсор после ~6000-го сообщения) ==='
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = '00000000-0000-4000-8000-000000000100'
AND (created_at, id) > (now() - interval '1 day' + 6000 * interval '1 millisecond',
'00000000-0000-0000-0000-000000000000')
ORDER BY created_at, id LIMIT 51;
\echo '=== 3. Для сравнения: та же страница, если запретить индекс ==='
SET LOCAL enable_indexscan = off;
SET LOCAL enable_bitmapscan = off;
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = '00000000-0000-4000-8000-000000000100'
AND (created_at, id) > (now() - interval '1 day' + 6000 * interval '1 millisecond',
'00000000-0000-0000-0000-000000000000')
ORDER BY created_at, id LIMIT 51;
ROLLBACK;
+68
View File
@@ -0,0 +1,68 @@
#!/usr/bin/env python3
"""
Logout при приостановленном Redis (замечание к app/sessions.py).
Сценарий преподавателя: прогреть сессию в кэше, приостановить Redis, сделать
logout, восстановить Redis и проверить старый токен.
Требование: 204 только при гарантированном отзыве; после 204 старый токен
никогда не принимается, в том числе после восстановления Redis.
python student-tests/logout_cache.py --base-url http://localhost:8080
(по умолчанию сам делает docker compose pause/unpause redis)
"""
import argparse
import shlex
import subprocess
import time
from common import Api, Report
COMPOSE = "docker compose --env-file .env"
def sh(cmd: str):
print(f" $ {cmd}")
subprocess.run(shlex.split(cmd), check=True, stdout=subprocess.DEVNULL)
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--base-url", default="http://localhost:8080")
ap.add_argument("--pause-redis", default=f"{COMPOSE} pause redis")
ap.add_argument("--unpause-redis", default=f"{COMPOSE} unpause redis")
args = ap.parse_args()
api, r = Api(args.base_url), Report()
user = api.new_user("logoutcache")
token = user["token"]
for _ in range(2): # первый запрос кладёт сессию в Redis, второй читает из кэша
st, _, _ = api.call("GET", "/api/v1/users/me", token=token)
r.check(st == 200, "session is warmed up in cache")
print("== Redis приостановлен ==")
sh(args.pause_redis)
try:
st_logout, _, _ = api.call("DELETE", "/api/v1/auth/sessions/current", token=token)
r.check(st_logout != 204,
f"logout is NOT confirmed while cache cannot be invalidated (got {st_logout}, expected 503)")
finally:
sh(args.unpause_redis)
time.sleep(0.5)
print("== Redis восстановлен ==")
st, _, _ = api.call("GET", "/api/v1/users/me", token=token)
if st_logout == 204:
r.check(st == 401, f"after a 204 the old token is rejected after Redis recovery (got {st})")
else:
r.check(st == 200, f"unconfirmed logout left the session consistent and valid (got {st})")
st, _, _ = api.call("DELETE", "/api/v1/auth/sessions/current", token=token)
r.check(st == 204, f"retry logout after Redis recovery -> 204 (got {st})")
st, _, _ = api.call("GET", "/api/v1/users/me", token=token)
r.check(st == 401, f"old token after confirmed logout -> 401, no stale cache copy (got {st})")
st, _, _ = api.call("GET", "/api/v1/users/me", token=token)
r.check(st == 401, f"old token still rejected on repeat (got {st})")
r.finish()
if __name__ == "__main__":
main()
+96
View File
@@ -0,0 +1,96 @@
#!/usr/bin/env python3
"""
Недоступность зависимостей (уровень «4»). Сам останавливает и запускает контейнеры:
python student-tests/outage.py --base-url http://localhost:8080
1. Redis остановлен → API работает в обход кэша (сессии читаются из PostgreSQL).
2. PostgreSQL остановлен → защищённые запросы получают ограниченную ошибку 503,
неизвестный токен НЕ принимается (никогда 200), /health/ready = 503.
3. PostgreSQL запущен снова → тот же токен снова работает, данные на месте.
"""
import argparse
import shlex
import subprocess
import time
import uuid
from common import Api, Report
COMPOSE = "docker compose --env-file .env"
def sh(cmd: str):
print(f" $ {cmd}")
subprocess.run(shlex.split(cmd), check=True, stdout=subprocess.DEVNULL)
def wait_ready(api: Api, seconds=90):
deadline = time.time() + seconds
while time.time() < deadline:
try:
if api.raw("GET", "/health/ready", timeout=3)[0] == 200:
return True
except OSError:
pass
time.sleep(1)
return False
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--base-url", default="http://localhost:8080")
ap.add_argument("--stop-redis", default=f"{COMPOSE} stop redis")
ap.add_argument("--start-redis", default=f"{COMPOSE} start redis")
ap.add_argument("--stop-db", default=f"{COMPOSE} stop postgres")
ap.add_argument("--start-db", default=f"{COMPOSE} start postgres")
args = ap.parse_args()
api, r = Api(args.base_url), Report()
user = api.new_user("outage")
st, chat, _ = api.call("POST", "/api/v1/chats", {"title": "outage", "member_ids": [user["id"]]}, token=user["token"])
path = f"/api/v1/chats/{chat['id']}/messages"
api.call("POST", path, {"text": "before outage"}, token=user["token"])
print("== 1. Redis недоступен ==")
sh(args.stop_redis)
try:
st, _, _ = api.call("GET", "/api/v1/users/me", token=user["token"])
r.check(st == 200, "valid token still works without Redis (cache bypassed)")
st, _, _ = api.call("POST", path, {"text": "without redis"}, token=user["token"])
r.check(st == 201, "writes still work without Redis")
fresh = api.register("noredis")
st, sess, _ = api.login(fresh["username"], fresh["password"])
r.check(st == 201, "login works without Redis")
st, _, _ = api.call("GET", "/api/v1/users/me", token="forged-" + uuid.uuid4().hex)
r.check(st == 401, "forged token still rejected without Redis")
finally:
sh(args.start_redis)
print("== 2. PostgreSQL недоступен ==")
sh(args.stop_db)
try:
time.sleep(1)
st, _, _ = api.call("GET", path, token=user["token"])
r.check(st == 503, f"history without DB -> 503, not a hang (got {st})")
st, _, _ = api.call("GET", "/api/v1/users/me", token="forged-" + uuid.uuid4().hex)
r.check(st in (401, 503), f"unknown token is never trusted without DB (got {st})")
st, _, _ = api.call("GET", "/api/v1/users/me")
r.check(st == 401, "anonymous request -> 401")
st = api.raw("GET", "/health/ready")[0]
r.check(st == 503, "/health/ready -> 503")
st = api.raw("GET", "/health/live")[0]
r.check(st == 200, "/health/live -> 200 (process is alive)")
finally:
sh(args.start_db)
print("== 3. восстановление ==")
r.check(wait_ready(api), "/health/ready back to 200")
st, page, _ = api.call("GET", path, token=user["token"])
texts = [m["text"] for m in (page or {}).get("items", [])]
r.check(st == 200 and "before outage" in texts and "without redis" in texts,
"same token reads the same history after DB is back")
r.finish()
if __name__ == "__main__":
main()
+46
View File
@@ -0,0 +1,46 @@
#!/usr/bin/env python3
"""
Конкурентная запись: 10 клиентов параллельно отправляют по 10 сообщений.
Ожидаем ровно 100 уникальных сообщений в истории.
python student-tests/race.py --base-url http://localhost:8080
"""
import argparse
from concurrent.futures import ThreadPoolExecutor
from common import Api
CLIENTS, PER_CLIENT = 10, 10
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--base-url", default="http://localhost:8080")
api = Api(ap.parse_args().base_url)
user = api.new_user("race")
st, chat, _ = api.call("POST", "/api/v1/chats", {"title": "race", "member_ids": [user["id"]]}, token=user["token"])
mpath = f"/api/v1/chats/{chat['id']}/messages"
def worker(w):
return [api.call("POST", mpath, {"text": f"c{w}-m{i}"}, token=user["token"])[0] for i in range(PER_CLIENT)]
with ThreadPoolExecutor(max_workers=CLIENTS) as pool:
codes = [c for batch in pool.map(worker, range(CLIENTS)) for c in batch]
ids, texts, cursor = [], [], None
while True:
st, page, _ = api.call("GET", f"{mpath}?limit=50" + (f"&cursor={cursor}" if cursor else ""), token=user["token"])
ids += [m["id"] for m in page["items"]]
texts += [m["text"] for m in page["items"]]
cursor = page["next_cursor"]
if cursor is None:
break
expected = {f"c{w}-m{i}" for w in range(CLIENTS) for i in range(PER_CLIENT)}
ok = codes.count(201) == 100 and len(ids) == 100 and len(set(ids)) == 100 and set(texts) == expected
print(f"sent=100 accepted={codes.count(201)} received={len(ids)} unique_ids={len(set(ids))} "
f"all_texts_present={set(texts) == expected}")
print("PASS" if ok else "FAIL")
raise SystemExit(0 if ok else 1)
if __name__ == "__main__":
main()
+52
View File
@@ -0,0 +1,52 @@
"""
Rollback составной операции «создать чат + участников» (уровень «4»).
Создаём чат, где последний участник — несуществующий пользователь. Проверку
приложения нарочно обходим и вызываем запись напрямую: первый INSERT в chats
проходит, а вставка участника падает на внешнем ключе. Ожидаем, что транзакция
откатилась целиком: ни чата, ни участников в базе нет.
Запуск внутри контейнера API (у него есть доступ к БД и коду):
docker compose cp student-tests/rollback_check.py api:/tmp/rollback_check.py
docker compose exec api python /tmp/rollback_check.py
Локально без Docker: python student-tests/rollback_check.py
"""
import asyncio
import sys
import uuid
from pathlib import Path
sys.path.insert(0, str(Path.cwd()))
import psycopg # noqa: E402
from app import repo # noqa: E402
from app.config import settings # noqa: E402
async def main() -> int:
title = "rollback-" + uuid.uuid4().hex[:8]
async with await psycopg.AsyncConnection.connect(settings.database_url) as conn:
creator = await repo.create_user(conn, "rb_" + uuid.uuid4().hex[:10], "rb", "x")
await conn.commit()
ghost = uuid.uuid4() # такого пользователя нет
try:
async with conn.transaction():
await repo.insert_chat(conn, title, [uuid.UUID(creator["id"]), ghost], creator["id"])
print("FAIL - insert unexpectedly succeeded")
return 1
except psycopg.errors.ForeignKeyViolation:
print(" ok - insert of unknown member failed on foreign key")
cur = await conn.execute(
"SELECT count(*) FROM chats WHERE title = %s", (title,))
chats = (await cur.fetchone())[0]
cur = await conn.execute(
"SELECT count(*) FROM chat_members m JOIN chats c ON c.id = m.chat_id WHERE c.title = %s", (title,))
members = (await cur.fetchone())[0]
ok = chats == 0 and members == 0
print(f" {'ok ' if ok else 'FAIL'} - after rollback: chats={chats}, members={members} (expected 0, 0)")
print("PASS" if ok else "FAIL")
return 0 if ok else 1
if __name__ == "__main__":
raise SystemExit(asyncio.run(main()))
+121
View File
@@ -0,0 +1,121 @@
#!/usr/bin/env python3
"""
Собственные тесты lab2 (запуск одной командой):
python student-tests/run.py --base-url http://localhost:8080
Негативные сценарии lab1 на новой аутентификации + проверки уровня «4»:
неверный пароль, logout, X-User-Id/Basic не дают доступ, гонка регистрации.
"""
import argparse
import base64
import json
import uuid
from concurrent.futures import ThreadPoolExecutor
from common import PASSWORD, Api, Report
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--base-url", default="http://localhost:8080")
api = Api(ap.parse_args().base_url)
r = Report()
alice, bob, eve = api.new_user("alice"), api.new_user("bob"), api.new_user("eve")
st, chat, _ = api.call("POST", "/api/v1/chats",
{"title": "own tests", "member_ids": [alice["id"], bob["id"]]}, token=alice["token"])
assert st == 201, st
mpath = f"/api/v1/chats/{chat['id']}/messages"
print("== аутентификация ==")
st, _, rh = api.login(alice["username"], "Wrong-password-123")
r.check(st == 401 and rh.get("WWW-Authenticate", "").startswith("Basic"), "wrong password -> 401 + Basic challenge")
st, _, _ = api.login("no_such_user_" + uuid.uuid4().hex[:8], PASSWORD)
r.check(st == 401, "unknown user -> 401 (same as wrong password)")
st, _, rh = api.call("GET", "/api/v1/users/me")
r.check(st == 401 and rh.get("WWW-Authenticate", "").startswith("Bearer"), "no token -> 401 + Bearer challenge")
st, _, _ = api.call("GET", "/api/v1/users/me", headers={"X-User-Id": alice["id"]})
r.check(st == 401, "X-User-Id alone gives no access")
st, _, _ = api.call("GET", "/api/v1/users/me", token="forged-" + uuid.uuid4().hex)
r.check(st == 401, "unknown/forged token -> 401")
basic = base64.b64encode(f"{alice['username']}:{alice['password']}".encode()).decode()
st, _, _ = api.call("GET", "/api/v1/users/me", headers={"Authorization": "Basic " + basic})
r.check(st == 401, "Basic on business endpoint -> 401")
st, me, _ = api.call("GET", "/api/v1/users/me", token=alice["token"], headers={"X-User-Id": eve["id"]})
r.check(st == 200 and me["id"] == alice["id"], "X-User-Id cannot override bearer identity")
st, _, _ = api.call("POST", "/api/v1/users", {"username": "short_pw_" + uuid.uuid4().hex[:6],
"display_name": "x", "password": "short"})
r.check(st == 400, "password shorter than 12 -> 400")
print("== logout ==")
tmp = api.new_user("logout")
st, _, _ = api.call("DELETE", "/api/v1/auth/sessions/current", token=tmp["token"])
r.check(st == 204, "logout -> 204")
st, _, _ = api.call("GET", "/api/v1/users/me", token=tmp["token"])
r.check(st == 401, "token after logout -> 401")
st, _, _ = api.call("DELETE", "/api/v1/auth/sessions/current", token=tmp["token"])
r.check(st == 401, "second logout -> 401")
print("== гонка регистрации одного username ==")
name = "race_" + uuid.uuid4().hex[:10]
def reg(_):
st, _, _ = api.call("POST", "/api/v1/users", {"username": name, "display_name": "r", "password": PASSWORD})
return st
with ThreadPoolExecutor(max_workers=20) as pool:
codes = list(pool.map(reg, range(20)))
r.check(codes.count(201) == 1 and codes.count(409) == 19,
f"20 parallel registrations -> one 201, nineteen 409 (got {sorted(codes)})")
print("== ошибки и доступ (из lab1) ==")
st, _, _ = api.raw("POST", "/api/v1/users", b"{not json", {"Content-Type": "application/json"})
r.check(st == 400, "malformed JSON -> 400")
st, _, _ = api.call("POST", "/api/v1/users", {"username": alice["username"], "display_name": "d", "password": PASSWORD})
r.check(st == 409, "duplicate username -> 409")
st, _, _ = api.call("POST", mpath, {"text": " "}, token=alice["token"])
r.check(st == 400, "blank message -> 400")
st, _, _ = api.call("POST", mpath, {"text": "x", "sender_id": eve["id"]}, token=alice["token"])
r.check(st == 400, "sender_id in body is rejected")
st, _, _ = api.call("POST", mpath, {"text": "чужое"}, token=eve["token"])
r.check(st == 404, "outsider POST to foreign chat -> 404")
st, _, _ = api.call("GET", mpath, token=eve["token"])
r.check(st == 404, "outsider GET foreign history -> 404")
st, _, _ = api.call("GET", "/api/v1/chats/not-a-uuid", token=alice["token"])
r.check(st == 400, "invalid chat uuid -> 400")
print("== пагинация ==")
for i in range(5):
api.call("POST", mpath, {"text": f"m{i}"}, token=bob["token"])
seen, cursor, pages = [], None, 0
while pages < 10:
st, page, _ = api.call("GET", f"{mpath}?limit=2" + (f"&cursor={cursor}" if cursor else ""), token=alice["token"])
pages += 1
seen += [m["id"] for m in page["items"]]
cursor = page["next_cursor"]
if cursor is None:
break
r.check(len(seen) == 5 and len(set(seen)) == 5 and pages == 3, "5 messages / limit 2 -> 3 pages, no duplicates")
st, other, _ = api.call("POST", "/api/v1/chats", {"title": "other", "member_ids": [alice["id"]]}, token=alice["token"])
st, p, _ = api.call("GET", f"{mpath}?limit=1", token=alice["token"])
st, _, _ = api.call("GET", f"/api/v1/chats/{other['id']}/messages?cursor={p['next_cursor']}", token=alice["token"])
r.check(st == 400, "cursor from another chat -> 400")
print("== Content-Type ==")
body = json.dumps({"username": "ct_" + uuid.uuid4().hex[:8], "display_name": "c", "password": PASSWORD}).encode()
st, _, _ = api.raw("POST", "/api/v1/users", body, {"Content-Type": "text/plain"})
r.check(st == 415, f"valid JSON with text/plain -> 415 (got {st})")
st, _, _ = api.raw("POST", mpath, json.dumps({"text": "x"}).encode(),
{"Content-Type": "text/plain", "Authorization": "Bearer " + alice["token"]})
r.check(st == 415, f"message with text/plain -> 415 (got {st})")
st, _, _ = api.raw("POST", "/api/v1/chats", b"{}", {"Content-Type": "text/plain"})
r.check(st == 401, f"text/plain without token -> 401 first (got {st})")
st, _, _ = api.raw("POST", mpath, json.dumps({"text": "utf8"}).encode(),
{"Content-Type": "application/json; charset=utf-8", "Authorization": "Bearer " + alice["token"]})
r.check(st == 201, f"application/json; charset=utf-8 accepted (got {st})")
r.finish()
if __name__ == "__main__":
main()