42 changed files with 3385 additions and 25 deletions
+14 -3
View File
@@ -1,11 +1,22 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
# Секреты сюда НЕ пишутся: их создаёт scripts/init_secrets.py в каталоге secrets/.
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
# TTL второго экземпляра API (профиль ttl, порт 8081) для автотеста истечения
SHORT_SESSION_TTL_SECONDS=2
# Файлы с секретами внутри контейнера (Compose secrets)
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
# Источник истины для сессий — PostgreSQL; Redis — кэш проверок токена
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
SESSION_CACHE_TTL_SECONDS=60
# Пул соединений и таймауты
DB_POOL_MIN=1
DB_POOL_MAX=10
DB_POOL_TIMEOUT_SECONDS=3
DB_CONNECT_TIMEOUT_SECONDS=3
DB_STATEMENT_TIMEOUT_MS=5000
CACHE_TIMEOUT_SECONDS=0.25
CACHE_RETRY_AFTER_SECONDS=5
+8 -8
View File
@@ -1,14 +1,14 @@
## Лабораторная 2
Автор / группа: TODO
Целевая оценка (3/4/5): TODO
Трек 5, если заявлен: TODO
Автор / группа: Попов Константин Дмитриевич, БВТ2303
Целевая оценка (3/4/5): 4
Трек 5, если заявлен: не заявлен
Что реализовано и что перенесено: TODO
Команды запуска из чистого clone: TODO
Результаты проверок и ссылка на REPORT.md: TODO
Ограничения / известные ошибки: TODO
Источники и использование ИИ: TODO
Что реализовано и что перенесено: перенесён API lab1 (модели, ошибки, курсоры, Dockerfile, тесты); хранилище — PostgreSQL с миграциями; Argon2id, Basic → opaque Bearer-сессия с TTL и logout; Redis — кэш проверок сессии с обходом при отказе. Подробно — REPORT.md, «Архитектура и решения».
Команды запуска из чистого clone: `python scripts/init_secrets.py`, `cp .env.example .env`, `docker compose --env-file .env up -d --build --wait` (REPORT.md, «Запуск из чистого clone»).
Результаты проверок и ссылка на REPORT.md: smoke, persistence, 32 собственных теста, отзыв при разрыве с Redis, race, отказ Redis/БД, EXPLAIN — evidence/, таблицы в REPORT.md.
Ограничения / известные ошибки: один host/БД/Redis; при сбое инвалидации кэша другие реплики перестают доверять кэшу не позже чем через 1 с; HTTP только для локального стенда (REPORT.md, «Ограничения»). Исправления по ревью — REPORT.md, «Исправления по ревью».
Источники и использование ИИ: см. шапку REPORT.md.
- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
- [ ] Контракт и публичные тесты не ослаблены.
+29
View File
@@ -0,0 +1,29 @@
# Lab2: API мессенджера (FastAPI + PostgreSQL + Redis).
FROM python:3.12.7-slim-bookworm
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
APP_HOST=0.0.0.0 \
APP_PORT=8080 \
APP_ENV=lab
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir --disable-pip-version-check -r requirements.txt
COPY src ./src
COPY migrations ./migrations
RUN useradd --create-home --shell /usr/sbin/nologin appuser \
&& chown -R appuser:appuser /app
USER appuser
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=20s --retries=3 \
CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).read()" || exit 1
# exec-форма: uvicorn — PID 1 и получает SIGTERM напрямую.
CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8080", "--timeout-graceful-shutdown", "10"]
+39 -1
View File
@@ -4,7 +4,7 @@ CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
.PHONY: help check validate test load test-persistence
.PHONY: help check validate test load test-persistence secrets up down migrate test-student test-expiry test-storage test-failures test-revocation explain
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@@ -24,3 +24,41 @@ load:
test-persistence:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
#Решение
COMPOSE ?= docker compose --env-file .env
EXPIRY_URL ?= http://localhost:8081
secrets:
$(PYTHON) scripts/init_secrets.py
@test -f .env || cp .env.example .env
up: secrets
$(COMPOSE) up -d --build --wait
down:
$(COMPOSE) --profile ttl down
migrate:
$(COMPOSE) exec api python -m src.migrate
test-student:
BASE_URL="$(BASE_URL)" $(PYTHON) student-tests/run_all.py --base-url "$(BASE_URL)"
test-expiry:
$(COMPOSE) --profile ttl up -d --wait api-short-ttl
EXPIRY_BASE_URL="$(EXPIRY_URL)" BASE_URL="$(BASE_URL)" $(PYTHON) -m unittest discover -s student-tests -p test_expiry.py -v
test-storage:
$(COMPOSE) run --rm --no-deps -v "$(CURDIR)/student-tests:/app/student-tests:ro" api \
sh -c "python -m unittest discover -s student-tests -p test_storage_rollback.py -v && python -m unittest discover -s student-tests -p test_session_cache.py -v"
test-failures:
$(PYTHON) student-tests/dependency_failure.py --base-url "$(BASE_URL)" --output evidence/dependency_failure.json
test-revocation:
$(PYTHON) student-tests/revocation_partition.py --base-url "$(BASE_URL)" | tee evidence/revocation_partition.txt
explain:
$(COMPOSE) exec -T postgres psql -U messenger -d messenger -v ON_ERROR_STOP=1 < scripts/sql/explain_history.sql > evidence/explain_history.txt
@echo "saved evidence/explain_history.txt"
+204 -13
View File
@@ -1,37 +1,228 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Автор, группа: Попов Константин Дмитриевич, группа БВТ2303
- Целевая оценка: **4**; трек 5 не заявляется
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Использованные источники, библиотеки и помощь ИИ: Python, FastAPI 0.115.6, Uvicorn 0.34.0, Pydantic 2.10.4, psycopg 3.2.3 + psycopg-pool 3.2.4, redis-py 5.2.1, argon2-cffi 23.1.0; PostgreSQL 16, Redis 7; документация PostgreSQL (transactions, EXPLAIN), Redis persistence, RFC 7617. Помощь ИИ использовалась при переносе кода lab1 на PostgreSQL, написании тестов и формулировке отчёта.
## Исправления по ревью
1. **Отозванный токен снова получал доступ после восстановления связи с Redis.** Ошибка записи «надгробия» при logout поглощалась, а положительной записи кэша доверяли до её истечения. Исправлено долгом инвалидации в PostgreSQL: он фиксируется в той же транзакции, что и отзыв, и пока не погашен, кэшу не доверяют. Подробности — в разделе «Роль Redis». Добавлены тесты `test_session_cache.py`, `revocation_partition.py` и фаза partition в `dependency_failure.py`; сравнение до/после — в `evidence/revocation_partition.txt`. Попутно найдена и исправлена регрессия самого исправления: при недоступной БД ответ занимал 2 × 3 с, теперь 3 с.
2. **Вход принимал JSON-тело.** `POST /auth/sessions` с телом теперь возвращает 400 до проверки пароля и до создания сессии; тест `test_login_with_body_rejected`.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
**Версии.** Образ API: `python:3.12.7-slim-bookworm`; `postgres:16.4-alpine`; `redis:7.4.1-alpine`. Зависимости Python закреплены точными версиями в `requirements.txt`. Требуются Docker Desktop (Compose v2) и Python 3.9+ для тестов (только стандартная библиотека).
```powershell
# 1. Локальные секреты (создаются один раз в ./secrets, каталог в .gitignore; значения не печатаются)
python scripts/init_secrets.py
copy .env.example .env # Linux/macOS: cp .env.example .env
# 2. Проверка конфигурации, сборка и запуск API + PostgreSQL + Redis
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build --wait
# 3. Миграции применяются автоматически при старте API (advisory lock).
# Явный повторный запуск ничего не дублирует:
docker compose exec api python -m src.migrate # -> schema is up to date; nothing applied
# 4. Готовность
curl http://localhost:8080/health/ready # {"status":"ok"}
```
Проверки (Linux/macOS — через `make`, Windows — те же команды Python напрямую):
```powershell
python scripts/check_contract.py # make check
python tests/smoke.py --base-url http://localhost:8080 # make test
# Перезапуск API и всех хранилищ с сохранением volumes:
# Linux/macOS/WSL/Git Bash: make test-persistence ACTION_SCRIPT=scripts/restart.sh
# Windows (cmd/PowerShell): python tests/resilience.py --mode persistence --action-script scripts/restart.cmd
python student-tests/run_all.py --base-url http://localhost:8080 # make test-student
# Истечение сессии — второй экземпляр API с SESSION_TTL_SECONDS=2 на порту 8081:
docker compose --profile ttl up -d --wait api-short-ttl
python student-tests/run_all.py --expiry-url http://localhost:8081 # make test-expiry
# Rollback на уровне БД с внедрённым сбоем (внутри compose-сети, БД наружу не публикуется):
make test-storage # + test_session_cache.py: отзыв при сбое инвалидации кэша
# Отказ Redis и PostgreSQL (останавливает и снова запускает контейнеры):
python student-tests/dependency_failure.py --output evidence/dependency_failure.json # make test-failures
# Отзыв токена при разрыве API<->Redis без рестарта Redis (замечание ревью №1):
python student-tests/revocation_partition.py # make test-revocation
# План запроса истории на 52 000 сообщениях (данные создаются и откатываются в одной транзакции):
make explain # PowerShell: Get-Content scripts/sql/explain_history.sql | docker compose exec -T postgres psql -U messenger -d messenger > evidence/explain_history.txt
```
**Остановка.** Безопасная остановка без потери данных: `docker compose --profile ttl down` (volume `pgdata` сохраняется). Намеренное удаление всех учебных данных — только вручную: `docker compose --profile ttl down -v`. Restart-hook и тесты никогда не удаляют volumes.
**Действия оператора:** создать секреты (`init_secrets.py`) до первого запуска. Пароль PostgreSQL задаётся только при инициализации пустого volume, поэтому скрипт не перезаписывает существующие файлы секретов.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
Клиент ──HTTP :8080──► API (FastAPI/Uvicorn, 1 процесс, sync-обработчики в threadpool)
│ пул psycopg: min 1 / max 10, ожидание соединения 3 с,
│ connect_timeout 3 с, statement_timeout 5 с
├──────────► PostgreSQL 16 (источник истины; volume pgdata)
│ users, chats, chat_members, messages, sessions
└──────────► Redis 7 (кэш проверок сессий; без persistence)
таймаут 250 мс, circuit breaker 5 с
```
### Что перенесено из lab1 и что изменено
Перенесены: модели Pydantic со строгой валидацией (`extra="forbid"`), формат ошибок с `X-Request-Id`, keyset-курсор `(created_at, id)` с привязкой к ресурсу, Dockerfile (non-root `appuser`, HEALTHCHECK, exec-форма CMD, graceful shutdown), собственные тесты `test_api.py`, `race.py`, `run_all.py`.
Изменено по объявленному переходу 1 → 2: `POST /users` требует `password`; `POST /auth/sessions` принимает только Basic; все бизнес-endpoint принимают только `Bearer`; `X-User-Id` игнорируется; добавлен `DELETE /auth/sessions/current`. In-memory `Storage` с `RLock` заменён на PostgreSQL; пагинация теперь выполняется в SQL (`LIMIT n+1` по индексу), а не срезом списка в памяти. Исправление базы lab1: заголовок `X-Request-Id` от клиента принимается только по шаблону `[A-Za-z0-9._:-]{1,128}`, иначе генерируется новый.
### Схема данных (`migrations/001_init.sql`)
| Таблица | Ключи и ограничения | Индексы под запросы |
| --- | --- | --- |
| `users` | PK `id`; `UNIQUE(username)`; CHECK формата username и длины display_name | уникальный индекс username — вход и гонка регистрации |
| `chats` | PK `id`; CHECK длины title | — |
| `chat_members` | PK `(chat_id, user_id)`; FK → chats (CASCADE), FK → users; `UNIQUE(chat_id, position)` | `(user_id, chat_id)` — «мои чаты» |
| `messages` | PK `id`; FK → chats, FK → users; CHECK длины text 1–4000 | `(chat_id, created_at, id)` — история и keyset |
| `sessions` | PK `token_hash` (SHA-256 токена, 32 байта); FK → users; `expires_at`, `revoked_at` | `user_id`, `expires_at` |
| `session_cache_invalidations` | PK `token_hash`; `revoked_at` | `revoked_at` — сверка и удаление старых строк |
Миграции: `001_init` (основная схема) и `002_session_cache_invalidations` (долг инвалидации кэша, добавлена по ревью). Они версионируются файлами `migrations/NNN_*.sql` и таблицей `schema_migrations`. Каждая миграция и отметка о ней — одна транзакция; одновременный старт нескольких API сериализуется `pg_advisory_lock`. Повторный запуск — no-op (проверено тестом `test_migrations_are_idempotent`).
### Транзакционные границы
- **Регистрация** — один `INSERT`; уникальность гарантирует `UNIQUE(username)`, приложение лишь переводит `UniqueViolation` в 409 (нет окна «SELECT, потом INSERT»).
- **Создание чата** — одна транзакция: `INSERT chats` → `INSERT chat_members` (в порядке `member_ids`). Существование участников проверяет FK; при неизвестном id откатывается всё, включая строку чата и уже вставленных участников → 400.
- **Отправка сообщения** — один оператор `INSERT … SELECT … WHERE EXISTS(членство)`: проверка доступа и запись атомарны. `created_at` назначает БД (`clock_timestamp()`), ответ отдаётся после COMMIT.
- **Чтение истории** — проверка членства и выборка страницы в одном соединении; snapshot между HTTP-страницами не обещается (как в контракте). При конкурентных вставках порядок определяется часами БД; сообщение с меньшим `created_at`, закоммиченное после чтения страницы, может быть пропущено уже прошедшим курсором — допустимое ограничение keyset по времени.
- **Вход** — `INSERT sessions` (expires_at = `clock_timestamp() + TTL` по часам БД, поэтому рестарт API не продлевает TTL). **Logout** — одна транзакция: `UPDATE sessions SET revoked_at` + строка «долга инвалидации» в `session_cache_invalidations` (момент отзыва = COMMIT); затем «надгробие» в Redis и удаление долга.
### Аутентификация
- Пароли: **Argon2id** (`argon2-cffi`, m = 19 MiB, t = 2, p = 1 — рекомендация OWASP), пароль 12–128 code points хешируется целиком в UTF-8, без усечения. Для несуществующего username выполняется проверка против хеша-«пустышки», чтобы время ответа не выдавало наличие пользователя; ответ 401 одинаковый.
- Basic разбирается строго: base64 → UTF-8 → разделение по **первому** двоеточию (двоеточие в пароле допустимо). Неверные/битые credentials → 401 `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`. Вход принимает **только** заголовок: любое тело запроса (JSON или нет) → 400 `invalid_request` до проверки пароля и до создания сессии (исправлено по ревью, `test_login_with_body_rejected`).
- Токен: `secrets.token_urlsafe(32)` — 256 бит, непрозрачный. В БД и Redis хранится только SHA-256 токена: для 256-битного случайного значения перебор невозможен, а KDF лишь замедлил бы каждый запрос (в отличие от пароля, где KDF защищает низкоэнтропийный секрет).
- Сначала аутентификация (dependency `current_user`), затем доступ к чату: посторонний получает 404, а не 403.
### Роль Redis: кэш проверок сессии
- **Источник истины** для сессий — PostgreSQL. Redis хранит `sess:<sha256>` → `{user, expires_at}`.
- **Заполнение:** промах → запрос в PostgreSQL → `SET NX PX=min(SESSION_CACHE_TTL_SECONDS=60 с, время до expires_at)`. Запись кэша никогда не живёт дольше сессии, поэтому истечение работает и при попадании в кэш (тест `test_session_expires_even_when_cached`).
- **Инвалидация при logout:** после COMMIT отзыва в PostgreSQL выполняется `SET sess:<hash> "revoked" PX=60 с` (обычный SET перезаписывает). Заполнение идёт через `SET NX`, поэтому параллельный запрос, прочитавший сессию до отзыва, не может вернуть в кэш валидную запись поверх «надгробия».
- **Если «надгробие» записать не удалось** (исправлено по ревью). В первой версии ошибка Redis при logout поглощалась, и после восстановления связи с тем же, не перезапущенным Redis старая положительная запись снова пускала отозванный токен до своего истечения (~60 с). Теперь:
1. вместе с `revoked_at` в той же транзакции фиксируется строка в `session_cache_invalidations` (миграция `002`); она удаляется только после успешной записи «надгробия»;
2. пока такие строки есть, положительным попаданиям кэша **не доверяют**: каждый токен проверяется в PostgreSQL, отозванный получает 401. Реплика, выполнившая logout, переключается сразу, до ответа 204;
3. не чаще раза в секунду API сверяется с этой таблицей. Он дописывает недостающие «надгробия» в Redis и гасит долг. Строки старше `SESSION_CACHE_TTL_SECONDS + 5` удаляются без записи: положительная запись к этому моменту уже истекла;
4. долг хранится в PostgreSQL, поэтому он переживает рестарт API. Новый процесс не доверяет кэшу до первой сверки.
Отзыв по-прежнему не зависит от доступности Redis: logout возвращает 204, а PostgreSQL остаётся единственным источником истины.
- **Persistence:** отключена сознательно (`--save "" --appendonly no`), `maxmemory 64mb`, `allkeys-lru`. После flush/рестарта Redis кэш пуст, все проверки идут в PostgreSQL и заново наполняют кэш; сессии не теряются, потому что Redis не единственное их хранилище.
- **Отказ Redis:** таймаут операций 250 мс; при ошибке кэш пропускается на 5 с (circuit breaker), запросы обслуживаются через PostgreSQL. Readiness от Redis не зависит.
- **Эффект:** за 30 с нагрузки (счётчики сброшены перед прогоном) Redis показал `keyspace_hits=8655`, `keyspace_misses=1` — проверки токена обслужены без обращения к PostgreSQL.
### Отказ PostgreSQL
PostgreSQL — критичная зависимость: `/health/ready` → 503; запросы к данным → `503 unavailable` за ≤ 3 с (ожидание соединения из пула) без текста драйвера/SQL. Анонимный запрос отклоняется 401 ещё до обращения к БД; неизвестный токен при недоступной БД не принимается (503). Кэшу без связи с БД не доверяют: сверка долга инвалидации требует PostgreSQL, поэтому при её недоступности и токен из кэша получает 503 (ошибка сверки сразу превращается в 503, без второго ожидания пула). Пул проверяет соединения при выдаче (`check_connection`), поэтому после возврата БД API восстанавливается без рестарта.
### Соответствие `.env.example` и реальной конфигурации
| Переменная | Где используется |
| --- | --- |
| `APP_HOST`, `APP_PORT` | `APP_PORT` — публикуемый порт в compose (`127.0.0.1:${APP_PORT}:8080`); внутри контейнера Uvicorn слушает `0.0.0.0:8080` (CMD) |
| `APP_ENV` | передаётся в API, сейчас только информативно |
| `SESSION_TTL_SECONDS` | TTL сессии основного API (по умолчанию 3600) |
| `SHORT_SESSION_TTL_SECONDS` | TTL экземпляра `api-short-ttl` (профиль `ttl`, порт 8081), по умолчанию 2 |
| `DATABASE_URL_FILE` | `/run/secrets/database_url` — Compose secret, создаётся `init_secrets.py` |
| `SESSION_STORE` | `postgres` — источник истины сессий (другое значение API отвергает при старте) |
| `CACHE_URL_FILE` | `/run/secrets/cache_url` — адрес Redis с паролем; без него API работает без кэша |
| `SESSION_CACHE_TTL_SECONDS` | верхняя граница TTL записи кэша и «надгробия» logout |
| `DB_POOL_MIN/MAX`, `DB_POOL_TIMEOUT_SECONDS` | размер пула и ожидание соединения (→ 503) |
| `DB_CONNECT_TIMEOUT_SECONDS`, `DB_STATEMENT_TIMEOUT_MS` | таймаут подключения и любого SQL-оператора |
| `CACHE_TIMEOUT_SECONDS`, `CACHE_RETRY_AFTER_SECONDS` | таймаут Redis и длительность обхода кэша после ошибки |
### Инфраструктура
| Роль | Service | Версия | Health/readiness | Volume | Сеть/порт | Credentials |
| --- | --- | --- | --- | --- | --- | --- |
| api | `api` (+ `api-short-ttl` в профиле `ttl`) | сборка из `Dockerfile`, `python:3.12.7-slim-bookworm` | HEALTHCHECK `/health/ready` | нет (stateless) | `backend`; `127.0.0.1:8080` (`8081` для ttl) | secrets `database_url`, `cache_url` |
| postgres | `postgres` | `postgres:16.4-alpine` | `pg_isready` | `pgdata` | `backend`, наружу не публикуется | secret `postgres_password` (`POSTGRES_PASSWORD_FILE`) |
| redis | `redis` | `redis:7.4.1-alpine`, user `redis` | `redis-cli ping` | нет (кэш) | `backend`, наружу не публикуется | secret `redis_password` (`--requirepass`) |
Bootstrap: схема создаётся миграциями при первом старте API на пустом volume; повтор безопасен. `scripts/restart.sh` / `scripts/restart.cmd`: `stop api` → `restart postgres redis` → `up -d --wait api`; без `down -v`, flush и повторного seed.
## Доказательства критериев
Стенд, на котором сняты приложенные результаты: Linux x86_64, 2 vCPU Intel Xeon 2.1 GHz, 8 GB RAM; PostgreSQL 16.15 и Redis 7.0.15, запущенные нативно (без Docker), API — тот же код, Uvicorn, Python 3.13; клиент тестов на той же машине. Перед защитой результаты нужно повторить на compose-стенде командами из раздела «Запуск» и обновить файлы в `evidence/`.
### Уровень 3
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Публичный smoke | `make test` | `PASS: lab2 public API scenario` | `evidence/smoke.txt` |
| Структура/контракт | `make check`, `make validate` | оба PASS | `evidence/check.txt` |
| Данные и действующие сессии переживают рестарт API и хранилищ | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS: persistence preserved confirmed data and existing session` — тот же токен читает те же сообщения | `evidence/persistence.txt` |
| Hook реально перезапускает процессы | PID до/после hook | postgres 1212→1269, redis 1222→1279, api 1228→1286; пользователей 51→51, действующих сессий 42→42 | `evidence/restart_processes.txt` |
| PK/FK, UNIQUE(username), миграции с нуля | `migrations/001_init.sql`; старт на пустой БД | на пустой БД: `migrations applied at startup: ['001_init', '002_session_cache_invalidations']` | `migrations/` |
| Повторный запуск миграций без дублирования | `python -m src.migrate`; `test_migrations_are_idempotent` | `schema is up to date; nothing applied`; в `schema_migrations` одна строка | `evidence/student-tests.txt` |
| Атомарное создание чата | `test_unknown_member_rolls_back_whole_chat`, `test_failure_after_inserts_leaves_nothing` | после ошибки нет ни чата, ни участников | `evidence/student-tests.txt` |
| Basic только на `POST /auth/sessions`, остальное Bearer | `test_basic_on_business_endpoint_rejected`, smoke | Basic на `/users/me` → 401 `WWW-Authenticate: Bearer` | `evidence/student-tests.txt` |
| X-User-Id не даёт доступа | `test_x_user_id_gives_no_access`, smoke | 401 без Bearer; с Bearer владелец не меняется | `evidence/student-tests.txt` |
| Срок жизни и отзыв сессии | `test_session_expires_even_when_cached`, `test_logout_revokes_only_current_session` | после TTL и после logout → 401; повторный logout → 401; вход с телом → 400 | `evidence/student-tests.txt` |
| Пароли — password KDF | `test_passwords_stored_as_argon2id` | в БД `$argon2id$…`, plaintext отсутствует | `evidence/student-tests.txt` |
| Secrets/volumes не в Git | `.gitignore` (`secrets/`, `.env`, `volumes/`, `data/`), секреты в отдельных файлах | после `init_secrets.py` и `git add -A` в индекс не попадают `secrets/` и `.env` | `.gitignore` |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
### Уровень 4
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Redis реально используется для сессий с TTL; описаны источник истины, expiry, инвалидация | код `src/sessions.py`; нагрузка | `keyspace_hits=8655 / misses=1` за 30 с нагрузки; TTL записи ≤ min(60 с, остаток сессии); «надгробие» при logout; без persistence — обосновано выше | раздел «Роль Redis», `evidence/load.json` |
| Параметризованные запросы | `src/storage.py` | только плейсхолдеры `%s` psycopg; в SQL подставляются лишь константные фрагменты кода | `src/storage.py` |
| Ограниченный пул и таймауты | `src/db.py`, `.env.example` | пул 1..10, ожидание 3 с, connect 3 с, statement 5 с, Redis 250 мс | `src/db.py`, `src/config.py` |
| Гонка регистрации одинакового username | `test_same_username_parallel_registration` (16 параллельных запросов, Barrier) | ровно 1×201 и 15×409; входит только победитель | `evidence/student-tests.txt` |
| Rollback составной операции | `test_unknown_member_rolls_back_whole_chat` (HTTP, FK-ошибка на 3-м участнике), `test_failure_after_inserts_leaves_nothing` (внедрённый сбой после вставки чата и 3 участников) | внутри транзакции строки были видны (1 чат, 3 участника), после — 0 и 0 | `evidence/student-tests.txt` |
| Индекс истории обоснован EXPLAIN (ANALYZE, BUFFERS) на ≥ 10 000 сообщений | `make explain` | 52 000 сообщений, 12 000 в чате; keyset-страница после 10 000-го: Index Scan, 5 буферов, 0.04 мс; OFFSET: Seq Scan + Sort 10 051 строк, 695 буферов, 5 мс; без индекса: Seq Scan 695 буферов, 3–5 мс | `evidence/explain_history.txt` |
| Пагинация без полного скана | тот же EXPLAIN | `Index Cond: chat_id = … AND ROW(created_at,id) > ROW(…)`, читается limit+1 = 51 строка | `evidence/explain_history.txt` |
| Автотест expiry при коротком TTL | `test_session_expires_even_when_cached` на API с `SESSION_TTL_SECONDS=2` | 200, 200 (из кэша) → через TTL+1.5 с 401; logout истёкшим → 401; новый вход → 201 | `evidence/student-tests.txt` |
| Автотест logout и неверного пароля | `test_logout_revokes_only_current_session`, `test_wrong_password_and_unknown_user_look_the_same`, `test_malformed_basic_headers` | все PASS | `evidence/student-tests.txt` |
| Автотест недоступности Redis | `dependency_failure.py` | API обходит кэш: чтение/запись/вход/logout работают, max задержка 8 мс, readiness 200 | `evidence/dependency_failure.json` |
| Отзыв при разрыве связи с живым Redis (замечание ревью №1) | `dependency_failure.py`, фаза partition; `revocation_partition.py`; `test_session_cache.py` (заглушка Redis, реальная PostgreSQL) | logout → 204; отозванный токен — только 401 во время разрыва, сразу после восстановления и 8 с после (дольше circuit breaker). Первая версия на том же сценарии: `[200, 401]`. Тест с заглушкой падает, если вернуть доверие положительному кэшу (проверено мутацией) | `evidence/revocation_partition.txt`, `evidence/dependency_failure.json`, `evidence/student-tests.txt` |
| Строгий формат входа (замечание ревью №2) | `test_login_with_body_rejected` | правильный Basic + `{"unexpected":true}` / `{}` / не-JSON / form → 400, без тела → 201 | `evidence/student-tests.txt` |
| Автотест недоступности БД | `dependency_failure.py` | live 200, ready 503; запись/чтение/вход → 503 `unavailable` за 3.0 с; анонимный → 401; неизвестный токен → 503; восстановление 0.6 с; отклонённая запись не сохранилась | `evidence/dependency_failure.json` |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
**Гипотеза 1.** Если PostgreSQL — единственный источник истины для данных и сессий, а Redis только кэш, то перезапуск всех процессов с сохранением volumes не теряет ни подтверждённых сообщений, ни действующих сессий, а потеря Redis не влияет на корректность. Подтверждено `test-persistence` (тот же токен после рестарта) и `dependency_failure.py`.
**Гипотеза 2.** Составной индекс `(chat_id, created_at, id)` делает стоимость страницы истории независимой от глубины курсора. На 52 000 сообщениях первая и «10 000-я» страница стоят одинаково (4–5 буферов, < 0.1 мс), тогда как OFFSET и запрос без индекса читают весь чат/таблицу (695 буферов) и растут линейно с объёмом.
**Нагрузка** (`tests/load.py`, closed-loop POST сообщений, без retry): 30 с, concurrency 4, без прогрева; 8 655 успешных запросов, 0 ошибок, 287 RPS; p50 13.2 мс, p95 20.2 мс, p99 24.3 мс (только успешные). До исправлений ревью тот же прогон давал 327 RPS, p95 17.4 мс. Разница в пределах разброса между запусками на общей виртуальной машине: повторов для статистики не делалось. Сверка долга добавляет не больше одного запроса к PostgreSQL в секунду. Стенд: 2 vCPU / 8 GB, без CPU/RAM-лимитов, клиент на той же машине; CPU/RAM процессов не измерялись. Это пропускная способность HTTP-подтверждений в этом профиле, а не максимум системы. Для сравнения, lab1 (in-memory) на другом ноутбуке давала 254 RPS — значения разных машин несопоставимы.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Рестарт API + PostgreSQL + Redis (hook) | данные и сессии сохраняются | тот же токен читает ту же историю; пользователей и сессий столько же | готовность через 2.6 с после начала hook; потерь нет |
| Остановка Redis | обход кэша, работа через PostgreSQL | все операции 200/201/204, max 8 мс, readiness 200 | без восстановления; после возврата кэш наполняется заново |
| Остановка PostgreSQL | 503 на данные, 401 анониму, live 200 | 503 `unavailable` за 3.0 с, ready 503, аноним 401 | 0.6 с после старта БД; запись во время отказа не сохранена (клиент получил 503) |
| 16 одинаковых регистраций одновременно | ровно одна успешна | 1×201, 15×409 | — |
| Сбой между INSERT chats и chat_members | полный откат | 0 строк чата и участников | — |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Один API, одна PostgreSQL, один Redis на одном Docker-host: отказ host или диска БД не выдерживается; репликации и бэкапов нет (бэкап/восстановление — трек 2 уровня 5, не заявлен).
- Durability зависит от настроек PostgreSQL по умолчанию (`fsync=on`, `synchronous_commit=on`): подтверждённый 201 означает COMMIT, записанный в WAL на локальный диск.
- Отзыв при сбое Redis: для реплики, выполнившей logout, окна нет. Другая реплика (в compose это `api-short-ttl`, в lab3 — реплики за LB), у которой связь с Redis не рвалась, узнаёт о долге при следующей сверке, то есть не позже чем через 1 с после ответа 204. Если logout прошёл успешно, окна нет ни у кого.
- Пока долг инвалидации не погашен (Redis недоступен), все проверки токена идут в PostgreSQL: кэш не разгружает базу до восстановления связи.
- Basic/Bearer идут по HTTP — допустимо только на локальном учебном стенде; TLS — lab7.
- Пароль Redis передаётся в `redis-server` аргументом командной строки внутри контейнера (виден в списке процессов контейнера); hardening — lab7.
- Приложенные результаты сняты на нативном стенде без Docker (см. «Доказательства»); compose-конфигурация проверена `docker compose config`, перед сдачей нужно прогнать те же сценарии на compose.
- Следующие шаги (lab3): несколько реплик API за балансировщиком уже совместимы с выбранной схемой (сессии в общей БД, кэш в общем Redis, миграции под advisory lock); нужно добавить `Idempotency-Key` и `X-Instance-Id`.
## Вопросы защиты — кратко
- **Что подтверждает COMMIT?** Что транзакция записана в WAL и после сбоя процесса/рестарта будет видна. Гарантия зависит от `fsync`, `synchronous_commit` и от того, что диск действительно сбрасывает кэш; потеря самого volume не покрывается.
- **Где сессии и что после flush/restart Redis?** В PostgreSQL. Redis — кэш; после flush следующие запросы проверяют токен в PostgreSQL и заново кладут его в кэш, пользователи не разлогиниваются.
- **Аутентификация vs доступ к чату:** аутентификация отвечает «кто это» (Bearer → user_id), авторизация — «может ли этот пользователь работать с этим чатом» (строка в `chat_members`); посторонний получает 404.
- **Hash пароля vs checksum:** KDF (Argon2id) намеренно медленный и с солью, чтобы перебор слабого пароля по утёкшей базе был дорогим; быстрый checksum (SHA-256) нужен для целостности/поиска и годится для токена только потому, что токен — 256 случайных бит.
+104
View File
@@ -0,0 +1,104 @@
# Лабораторная 2: API + PostgreSQL + Redis.
# Перед первым запуском: python scripts/init_secrets.py && cp .env.example .env
name: messenger-lab2
x-api: &api
build: .
image: messenger-api:lab2
restart: unless-stopped
environment: &api-env
APP_ENV: ${APP_ENV:-lab}
SESSION_STORE: postgres
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
SESSION_CACHE_TTL_SECONDS: ${SESSION_CACHE_TTL_SECONDS:-60}
DATABASE_URL_FILE: /run/secrets/database_url
CACHE_URL_FILE: /run/secrets/cache_url
DB_POOL_MIN: ${DB_POOL_MIN:-1}
DB_POOL_MAX: ${DB_POOL_MAX:-10}
DB_POOL_TIMEOUT_SECONDS: ${DB_POOL_TIMEOUT_SECONDS:-3}
DB_CONNECT_TIMEOUT_SECONDS: ${DB_CONNECT_TIMEOUT_SECONDS:-3}
DB_STATEMENT_TIMEOUT_MS: ${DB_STATEMENT_TIMEOUT_MS:-5000}
CACHE_TIMEOUT_SECONDS: ${CACHE_TIMEOUT_SECONDS:-0.25}
CACHE_RETRY_AFTER_SECONDS: ${CACHE_RETRY_AFTER_SECONDS:-5}
secrets:
- database_url
- cache_url
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
networks: [backend]
stop_grace_period: 15s
services:
api:
<<: *api
ports:
- "127.0.0.1:${APP_PORT:-8080}:8080"
# Второй экземпляр с коротким TTL — только для автотеста истечения сессии.
# Запуск: docker compose --profile ttl up -d api-short-ttl
api-short-ttl:
<<: *api
profiles: [ttl]
environment:
<<: *api-env
SESSION_TTL_SECONDS: ${SHORT_SESSION_TTL_SECONDS:-2}
ports:
- "127.0.0.1:8081:8080"
postgres:
image: postgres:16.4-alpine
restart: unless-stopped
environment:
POSTGRES_USER: messenger
POSTGRES_DB: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
secrets:
- postgres_password
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger -h 127.0.0.1"]
interval: 3s
timeout: 3s
retries: 20
start_period: 10s
networks: [backend]
stop_grace_period: 30s
redis:
image: redis:7.4.1-alpine
restart: unless-stopped
user: redis
# Только кэш: без RDB/AOF, ограничение памяти и LRU-вытеснение.
# Пароль читается из secret, в compose.yaml и env его нет.
command:
- sh
- -c
- exec redis-server --requirepass "$$(cat /run/secrets/redis_password)" --save "" --appendonly no --maxmemory 64mb --maxmemory-policy allkeys-lru
secrets:
- redis_password
healthcheck:
test: ["CMD-SHELL", "REDISCLI_AUTH=\"$$(cat /run/secrets/redis_password)\" redis-cli ping | grep -q PONG"]
interval: 3s
timeout: 3s
retries: 20
networks: [backend]
volumes:
pgdata:
networks:
backend:
secrets:
postgres_password:
file: ./secrets/postgres_password
redis_password:
file: ./secrets/redis_password
database_url:
file: ./secrets/database_url
cache_url:
file: ./secrets/cache_url
+4
View File
@@ -0,0 +1,4 @@
$ 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.
+137
View File
@@ -0,0 +1,137 @@
{
"base_url": "http://127.0.0.1:8080",
"timings": {
"redis_down_first_request_s": 0.015,
"redis_down_max_write_s": 0.047,
"postgres_down_write_s": 3.015,
"postgres_recovery_s": -1
},
"checks": [
{
"check": "redis down: existing token still valid via PostgreSQL",
"ok": true,
"detail": "0.015s"
},
{
"check": "redis down: writes succeed",
"ok": true,
"detail": ""
},
{
"check": "redis down: bounded latency",
"ok": true,
"detail": "max 0.047s over 10 requests"
},
{
"check": "redis down: readiness stays 200 (cache is not critical)",
"ok": true,
"detail": ""
},
{
"check": "redis down: login works",
"ok": true,
"detail": ""
},
{
"check": "redis down: logout works",
"ok": true,
"detail": ""
},
{
"check": "redis down: revoked token rejected",
"ok": true,
"detail": ""
},
{
"check": "redis down: anonymous rejected",
"ok": true,
"detail": ""
},
{
"check": "redis down: unknown token rejected",
"ok": true,
"detail": ""
},
{
"check": "redis back: requests ok",
"ok": true,
"detail": ""
},
{
"check": "redis partition: logout -> 204",
"ok": true,
"detail": "status 204, 0.000s"
},
{
"check": "redis partition: revoked token -> 401",
"ok": true,
"detail": ""
},
{
"check": "redis healed (same data): revoked token stays 401 for 8 s",
"ok": true,
"detail": "[401]"
},
{
"check": "redis healed: valid token works",
"ok": true,
"detail": ""
},
{
"check": "postgres down: liveness 200",
"ok": true,
"detail": ""
},
{
"check": "postgres down: readiness 503 unavailable",
"ok": true,
"detail": "3.000s"
},
{
"check": "postgres down: anonymous -> 401 (not trusted)",
"ok": true,
"detail": "status 401"
},
{
"check": "postgres down: unknown token is not accepted (503)",
"ok": true,
"detail": "status 503, 3.016s"
},
{
"check": "postgres down: write -> 503 within bound",
"ok": true,
"detail": "status 503, 3.015s"
},
{
"check": "postgres down: history read -> 503",
"ok": true,
"detail": "status 503"
},
{
"check": "postgres down: login -> 503 (not 401, not 201)",
"ok": true,
"detail": "status 503"
},
{
"check": "postgres down: error hides internals",
"ok": true,
"detail": ""
},
{
"check": "postgres back: readiness recovered",
"ok": true,
"detail": "0.0s"
},
{
"check": "postgres back: same token reads intact history",
"ok": true,
"detail": ""
},
{
"check": "postgres back: rejected write was not stored",
"ok": true,
"detail": ""
}
],
"passed": true
}
Binary file not shown.
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 2,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 30.0,
"elapsed_seconds": 30.122,
"concurrency": 4,
"successful_requests": 8655,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 287.333,
"successful_latency_ms": {
"p50": 13.173,
"p95": 20.194,
"p99": 24.284
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
+3
View File
@@ -0,0 +1,3 @@
$ make test-persistence ACTION_SCRIPT=<restart 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.
+3
View File
@@ -0,0 +1,3 @@
# Локальный стенд без Docker (PID процессов до/после restart hook; volumes = каталоги данных сохраняются)
before: postgres=1212 redis=1222 api=1228 users_in_db=51 sessions_in_db=42
after: postgres=1269 redis=1279 api=1286 users_in_db=51 sessions_in_db=42
+9
View File
@@ -0,0 +1,9 @@
# Регрессия замечания ревью №1: прогрев кэша -> разрыв API<->Redis (iptables REJECT tcp-reset, Redis НЕ перезапускается)
# -> logout -> восстановление связи -> опрос старого токена 8 с (дольше circuit breaker 5 с).
# Скрипт: student-tests/revocation_partition.py --partition/--heal "iptables ... tcp-reset" (тот же сценарий входит в student-tests/dependency_failure.py)
--- до исправления (первая сдача)
logout during partition: 204
revoked token statuses over 8 s after heal: [200, 401]
--- после исправления
logout during partition: 204
revoked token statuses over 8 s after heal: [401]
+2
View File
@@ -0,0 +1,2 @@
$ make test BASE_URL=http://127.0.0.1:8080
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
+50
View File
@@ -0,0 +1,50 @@
$ python student-tests/run_all.py --base-url http://127.0.0.1:8080 --expiry-url http://127.0.0.1:8081
== API, auth, concurrency, rollback, expiry tests
test_chat_list_pagination (test_api.ApiBehaviorTests.test_chat_list_pagination) ... ok
test_cursor_from_other_chat_returns_400 (test_api.ApiBehaviorTests.test_cursor_from_other_chat_returns_400) ... ok
test_duplicate_username_returns_409 (test_api.ApiBehaviorTests.test_duplicate_username_returns_409) ... ok
test_empty_message_returns_400 (test_api.ApiBehaviorTests.test_empty_message_returns_400) ... ok
test_malformed_json_returns_400 (test_api.ApiBehaviorTests.test_malformed_json_returns_400) ... ok
test_naive_timestamp_cursor_returns_400 (test_api.ApiBehaviorTests.test_naive_timestamp_cursor_returns_400) ... ok
test_outsider_cannot_access_chat (test_api.ApiBehaviorTests.test_outsider_cannot_access_chat) ... ok
test_pagination_returns_all_messages_without_duplicates (test_api.ApiBehaviorTests.test_pagination_returns_all_messages_without_duplicates) ... ok
test_password_never_returned (test_api.ApiBehaviorTests.test_password_never_returned) ... ok
test_registration_without_password_returns_400 (test_api.ApiBehaviorTests.test_registration_without_password_returns_400) ... ok
test_sender_id_in_body_rejected (test_api.ApiBehaviorTests.test_sender_id_in_body_rejected) ... ok
test_short_password_returns_400 (test_api.ApiBehaviorTests.test_short_password_returns_400) ... ok
test_basic_on_business_endpoint_rejected (test_auth.AuthTests.test_basic_on_business_endpoint_rejected) ... ok
test_login_with_body_rejected (test_auth.AuthTests.test_login_with_body_rejected)
Контракт: вход — только заголовок Basic, без тела. Лишний ввод -> 400, сессии нет. ... ok
test_logout_revokes_only_current_session (test_auth.AuthTests.test_logout_revokes_only_current_session) ... ok
test_malformed_basic_headers (test_auth.AuthTests.test_malformed_basic_headers) ... ok
test_password_with_colon_and_unicode (test_auth.AuthTests.test_password_with_colon_and_unicode) ... ok
test_session_shape_and_token_entropy (test_auth.AuthTests.test_session_shape_and_token_entropy) ... ok
test_unknown_and_garbage_tokens (test_auth.AuthTests.test_unknown_and_garbage_tokens) ... ok
test_wrong_password_and_unknown_user_look_the_same (test_auth.AuthTests.test_wrong_password_and_unknown_user_look_the_same) ... ok
test_x_user_id_gives_no_access (test_auth.AuthTests.test_x_user_id_gives_no_access) ... ok
test_duplicate_and_missing_caller_rejected (test_concurrency.ChatRollbackTests.test_duplicate_and_missing_caller_rejected) ... ok
test_unknown_member_rolls_back_whole_chat (test_concurrency.ChatRollbackTests.test_unknown_member_rolls_back_whole_chat)
Чат вставляется первым, затем участники по порядку (сначала сам владелец). ... ok
test_same_username_parallel_registration (test_concurrency.RegistrationRaceTests.test_same_username_parallel_registration) ... ok
test_session_expires_even_when_cached (test_expiry.ExpiryTests.test_session_expires_even_when_cached) ... ok
test_debt_survives_api_restart (test_session_cache.SessionRevocationCacheTests.test_debt_survives_api_restart)
Процесс, выполнивший logout, умер до восстановления связи — новый процесс не доверяет кэшу. ... logout: cache invalidation deferred; positive cache disabled
ok
test_normal_logout_leaves_no_debt (test_session_cache.SessionRevocationCacheTests.test_normal_logout_leaves_no_debt) ... ok
test_revoked_token_rejected_after_partition_heals (test_session_cache.SessionRevocationCacheTests.test_revoked_token_rejected_after_partition_heals) ... logout: cache invalidation deferred; positive cache disabled
ok
test_failure_after_inserts_leaves_nothing (test_storage_rollback.StorageRollbackTests.test_failure_after_inserts_leaves_nothing) ... ok
test_migrations_are_idempotent (test_storage_rollback.StorageRollbackTests.test_migrations_are_idempotent) ... ok
test_no_orphan_chats_in_database (test_storage_rollback.StorageRollbackTests.test_no_orphan_chats_in_database) ... ok
test_passwords_stored_as_argon2id (test_storage_rollback.StorageRollbackTests.test_passwords_stored_as_argon2id) ... ok
----------------------------------------------------------------------
Ran 32 tests in 7.657s
OK
== Concurrent write test
PASS: concurrent write test; 10 clients x 10 messages = 100 messages; no lost or duplicate messages
ALL STUDENT TESTS PASSED
+66
View File
@@ -0,0 +1,66 @@
-- 001_init: базовая схема мессенджера lab2.
-- Применяется src/migrate.py ровно один раз (таблица schema_migrations),
-- внутри одной транзакции; повторный запуск миграций ничего не дублирует.
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 DEFAULT clock_timestamp(),
CONSTRAINT users_username_key UNIQUE (username),
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
CONSTRAINT users_display_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100)
);
CREATE TABLE chats (
id uuid PRIMARY KEY,
title text NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
CONSTRAINT chats_title_len CHECK (char_length(title) BETWEEN 1 AND 100)
);
-- Список чатов пользователя: WHERE user_id = ? ORDER BY (created_at, id)
CREATE INDEX chats_created_at_id_idx ON chats (created_at, id);
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
user_id uuid NOT NULL REFERENCES users (id) ON DELETE RESTRICT,
position smallint NOT NULL,
PRIMARY KEY (chat_id, user_id),
CONSTRAINT chat_members_position_key UNIQUE (chat_id, position)
);
-- "В каких чатах состоит пользователь" (GET /chats)
CREATE INDEX chat_members_user_id_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) ON DELETE RESTRICT,
text text NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
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 $4
-- Обоснование и EXPLAIN (ANALYZE, BUFFERS): evidence/explain_history.txt
CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id);
-- Серверные сессии. Источник истины для сессий — PostgreSQL;
-- Redis хранит только кэш проверок токена (см. REPORT.md).
-- Хранится SHA-256 от токена, сам токен в БД не попадает.
CREATE TABLE sessions (
token_hash bytea PRIMARY KEY,
user_id uuid NOT NULL REFERENCES users (id) ON DELETE CASCADE,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
expires_at timestamptz NOT NULL,
revoked_at timestamptz,
CONSTRAINT sessions_token_hash_len CHECK (octet_length(token_hash) = 32),
CONSTRAINT sessions_expiry_after_create CHECK (expires_at > created_at)
);
CREATE INDEX sessions_user_id_idx ON sessions (user_id);
CREATE INDEX sessions_expires_at_idx ON sessions (expires_at);
@@ -0,0 +1,13 @@
-- 002: надёжная инвалидация кэша сессий.
-- Строка вставляется В ТОЙ ЖЕ транзакции, что и sessions.revoked_at, и удаляется
-- только после того, как в Redis записано «надгробие» для этого токена.
-- Пока в таблице есть строки, API не доверяет положительным записям кэша
-- и проверяет каждый токен в PostgreSQL (см. src/sessions.py).
CREATE TABLE session_cache_invalidations (
token_hash bytea PRIMARY KEY,
revoked_at timestamptz NOT NULL DEFAULT clock_timestamp(),
CONSTRAINT session_cache_invalidations_hash_len CHECK (octet_length(token_hash) = 32)
);
CREATE INDEX session_cache_invalidations_revoked_at_idx
ON session_cache_invalidations (revoked_at);
+7
View File
@@ -0,0 +1,7 @@
fastapi==0.115.6
uvicorn==0.34.0
pydantic==2.10.4
psycopg[binary]==3.2.3
psycopg-pool==3.2.4
redis==5.2.1
argon2-cffi==23.1.0
+45
View File
@@ -0,0 +1,45 @@
#!/usr/bin/env python3
"""Создаёт локальные учебные секреты в ./secrets (каталог в .gitignore).
Повторный запуск ничего не перезаписывает: пароль PostgreSQL задаётся только
при первой инициализации volume, и смена файла сломала бы подключение.
Значения секретов не печатаются.
"""
import os
import secrets
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
DIR = ROOT / "secrets"
def write(name: str, value: str) -> None:
path = DIR / name
if path.exists():
print("keep secrets/%s" % name)
return
path.write_text(value + "\n", encoding="utf-8")
# Каталог 0700, файлы 0644: внутри контейнера их читают непривилегированные
# пользователи (appuser, redis), а на хосте каталог закрыт.
os.chmod(path, 0o644)
print("create secrets/%s" % name)
def read(name: str) -> str:
return (DIR / name).read_text(encoding="utf-8").strip()
def main() -> None:
DIR.mkdir(exist_ok=True)
try:
os.chmod(DIR, 0o700)
except OSError:
pass
write("postgres_password", secrets.token_hex(24))
write("redis_password", secrets.token_hex(24))
write("database_url", "postgresql://messenger:%s@postgres:5432/messenger" % read("postgres_password"))
write("cache_url", "redis://:%s@redis:6379/0" % read("redis_password"))
if __name__ == "__main__":
main()
+10
View File
@@ -0,0 +1,10 @@
@echo off
rem Windows-вариант restart.sh (Docker Desktop): API и все хранилища, volumes сохраняются.
setlocal
cd /d "%~dp0.."
set ENVARG=
if exist .env set ENVARG=--env-file .env
docker compose %ENVARG% stop api >nul || exit /b 1
docker compose %ENVARG% restart postgres redis >nul || exit /b 1
docker compose %ENVARG% up -d --wait api >nul || exit /b 1
exit /b 0
+16
View File
@@ -0,0 +1,16 @@
#!/bin/sh
# Restart hook для make test-persistence: перезапускает API и ВСЕ хранилища
# (PostgreSQL, Redis), сохраняя volumes. Никаких down -v / flush / повторного seed.
set -eu
cd "$(dirname "$0")/.."
COMPOSE="docker compose --env-file ${ENV_FILE:-.env}"
[ -f "${ENV_FILE:-.env}" ] || COMPOSE="docker compose"
# 1. Останавливаем API, чтобы он не писал во время рестарта хранилищ.
$COMPOSE stop api >/dev/null
# 2. Перезапуск хранилищ: PostgreSQL выполняет штатный shutdown (checkpoint),
# данные остаются в именованном volume pgdata; Redis-кэш стартует пустым.
$COMPOSE restart postgres redis >/dev/null
# 3. API стартует после healthcheck зависимостей (depends_on: service_healthy).
$COMPOSE up -d --wait api >/dev/null
exit 0
+93
View File
@@ -0,0 +1,93 @@
-- Обоснование индекса истории: EXPLAIN (ANALYZE, BUFFERS) на >= 10 000 сообщений.
-- Всё выполняется в ОДНОЙ транзакции и откатывается (ROLLBACK): синтетические
-- данные и временное удаление индекса не остаются в БД.
-- Запуск (compose):
-- docker compose exec -T postgres psql -U messenger -d messenger -v ON_ERROR_STOP=1 \
-- < scripts/sql/explain_history.sql > evidence/explain_history.txt
-- Внимание: DROP INDEX внутри транзакции берёт эксклюзивную блокировку messages
-- до ROLLBACK (несколько секунд) — запускать на учебном стенде.
\set ON_ERROR_STOP 1
\timing off
SET TimeZone = 'UTC';
-- Убираем мёртвые версии строк от прошлых запусков (VACUUM нельзя внутри транзакции).
VACUUM (ANALYZE) messages, chat_members, chats, users;
BEGIN;
INSERT INTO users (id, username, display_name, password_hash)
VALUES ('00000000-0000-4000-8000-00000000e001', 'explain_alice', 'Explain', 'x'),
('00000000-0000-4000-8000-00000000e002', 'explain_bob', 'Explain', 'x');
-- 1 большой чат (12 000 сообщений) + 40 чатов по 1 000 = 52 000 сообщений.
INSERT INTO chats (id, title, created_at)
SELECT CASE WHEN g = 0 THEN '00000000-0000-4000-8000-0000000c0000'::uuid ELSE gen_random_uuid() END,
'explain-' || g, timestamptz '2026-01-01 00:00:00+00' + g * interval '1 second'
FROM generate_series(0, 40) AS g;
INSERT INTO chat_members (chat_id, user_id, position)
SELECT c.id, u.id, u.pos
FROM chats c
CROSS JOIN (VALUES ('00000000-0000-4000-8000-00000000e001'::uuid, 0),
('00000000-0000-4000-8000-00000000e002'::uuid, 1)) AS u(id, pos)
WHERE c.title LIKE 'explain-%';
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(), c.id,
CASE WHEN g % 2 = 0 THEN '00000000-0000-4000-8000-00000000e001'::uuid
ELSE '00000000-0000-4000-8000-00000000e002'::uuid END,
'synthetic message ' || g,
timestamptz '2026-01-02 00:00:00+00' + g * interval '1 millisecond' + (c.created_at - timestamptz '2026-01-01 00:00:00+00')
FROM chats c
CROSS JOIN LATERAL generate_series(1, CASE WHEN c.title = 'explain-0' THEN 12000 ELSE 1000 END) AS g
WHERE c.title LIKE 'explain-%';
ANALYZE users, chats, chat_members, messages;
\echo '=== dataset'
SELECT count(*) AS total_messages,
count(*) FILTER (WHERE chat_id = '00000000-0000-4000-8000-0000000c0000') AS big_chat_messages
FROM messages;
-- Позиция курсора после 10 000-го сообщения большого чата (как в next_cursor).
SELECT created_at AS cur_ts, id AS cur_id
FROM messages
WHERE chat_id = '00000000-0000-4000-8000-0000000c0000'
ORDER BY created_at, id OFFSET 9999 LIMIT 1 \gset
\echo '=== 1. first page (no cursor), LIMIT 51 = limit+1'
EXPLAIN (ANALYZE, BUFFERS, COSTS, TIMING)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = '00000000-0000-4000-8000-0000000c0000'
ORDER BY created_at, id
LIMIT 51;
\echo '=== 2. deep page: keyset cursor after message #10000 (query used by API)'
EXPLAIN (ANALYZE, BUFFERS, COSTS, TIMING)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = '00000000-0000-4000-8000-0000000c0000'
AND (created_at, id) > (:'cur_ts'::timestamptz, :'cur_id'::uuid)
ORDER BY created_at, id
LIMIT 51;
\echo '=== 3. for comparison: OFFSET pagination to the same page (NOT used by API)'
EXPLAIN (ANALYZE, BUFFERS, COSTS, TIMING)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = '00000000-0000-4000-8000-0000000c0000'
ORDER BY created_at, id
OFFSET 10000 LIMIT 51;
\echo '=== 4. same keyset query WITHOUT messages_chat_created_id_idx (index dropped inside the transaction)'
DROP INDEX messages_chat_created_id_idx;
EXPLAIN (ANALYZE, BUFFERS, COSTS, TIMING)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = '00000000-0000-4000-8000-0000000c0000'
AND (created_at, id) > (:'cur_ts'::timestamptz, :'cur_id'::uuid)
ORDER BY created_at, id
LIMIT 51;
ROLLBACK;
\echo '=== rolled back: synthetic data removed, index restored'
View File
+84
View File
@@ -0,0 +1,84 @@
"""Конфигурация из переменных окружения.
Секреты (строки подключения с паролями) читаются из файлов *_FILE,
которые Compose монтирует как secrets в /run/secrets/. Для локального
запуска без Docker допускаются и прямые переменные DATABASE_URL / CACHE_URL.
"""
import os
from dataclasses import dataclass
from typing import Optional
def _read_secret(name: str) -> Optional[str]:
path = os.environ.get(name + "_FILE")
if path:
with open(path, "r", encoding="utf-8") as handle:
value = handle.read().strip()
return value or None
value = os.environ.get(name, "").strip()
return value or None
def _int(name: str, default: int) -> int:
raw = os.environ.get(name)
if raw is None or raw.strip() == "":
return default
return int(raw)
def _float(name: str, default: float) -> float:
raw = os.environ.get(name)
if raw is None or raw.strip() == "":
return default
return float(raw)
@dataclass(frozen=True)
class Settings:
app_env: str
database_url: str
cache_url: Optional[str]
session_store: str
session_ttl_seconds: int
session_cache_ttl_seconds: int
db_pool_min: int
db_pool_max: int
db_pool_timeout: float
db_connect_timeout: int
db_statement_timeout_ms: int
cache_timeout_seconds: float
cache_retry_after_seconds: float
migrate_wait_seconds: int
def load_settings() -> Settings:
database_url = _read_secret("DATABASE_URL")
if not database_url:
raise RuntimeError("DATABASE_URL or DATABASE_URL_FILE must be set")
ttl = _int("SESSION_TTL_SECONDS", 3600)
if ttl < 1:
raise RuntimeError("SESSION_TTL_SECONDS must be positive")
session_store = os.environ.get("SESSION_STORE", "postgres").strip().lower()
# Источник истины для сессий в этой реализации всегда PostgreSQL;
# Redis (CACHE_URL) — только кэш проверок токена.
if session_store != "postgres":
raise RuntimeError("only SESSION_STORE=postgres is supported")
return Settings(
app_env=os.environ.get("APP_ENV", "lab"),
database_url=database_url,
cache_url=_read_secret("CACHE_URL"),
session_store=session_store,
session_ttl_seconds=ttl,
session_cache_ttl_seconds=_int("SESSION_CACHE_TTL_SECONDS", 60),
db_pool_min=_int("DB_POOL_MIN", 1),
db_pool_max=_int("DB_POOL_MAX", 10),
db_pool_timeout=_float("DB_POOL_TIMEOUT_SECONDS", 3.0),
db_connect_timeout=_int("DB_CONNECT_TIMEOUT_SECONDS", 3),
db_statement_timeout_ms=_int("DB_STATEMENT_TIMEOUT_MS", 5000),
cache_timeout_seconds=_float("CACHE_TIMEOUT_SECONDS", 0.25),
cache_retry_after_seconds=_float("CACHE_RETRY_AFTER_SECONDS", 5.0),
migrate_wait_seconds=_int("MIGRATE_WAIT_SECONDS", 60),
)
+108
View File
@@ -0,0 +1,108 @@
"""Пул соединений PostgreSQL и версионируемые миграции."""
import logging
import time
from pathlib import Path
from typing import Optional
import psycopg
from psycopg_pool import ConnectionPool
from .config import Settings
log = logging.getLogger("messenger.db")
MIGRATIONS_DIR = Path(__file__).resolve().parent.parent / "migrations"
# Произвольная константа: один процесс за раз применяет миграции,
# даже если одновременно стартуют несколько реплик API (lab3).
MIGRATION_LOCK_ID = 2026_0002
def conninfo_kwargs(settings: Settings) -> dict:
return {
"connect_timeout": settings.db_connect_timeout,
# Все timestamptz приходят в UTC; любой запрос ограничен по времени.
"options": "-c TimeZone=UTC -c statement_timeout=%d"
% settings.db_statement_timeout_ms,
"application_name": "messenger-api",
}
def create_pool(settings: Settings) -> ConnectionPool:
pool = ConnectionPool(
conninfo=settings.database_url,
kwargs=conninfo_kwargs(settings),
min_size=settings.db_pool_min,
max_size=settings.db_pool_max,
# Сколько запрос ждёт свободное соединение, прежде чем получить 503.
timeout=settings.db_pool_timeout,
# Битые после рестарта БД соединения отбрасываются при выдаче из пула.
check=ConnectionPool.check_connection,
max_idle=300,
reconnect_timeout=3600,
open=False,
name="messenger",
)
# wait=False: процесс поднимается, даже если БД ещё/уже недоступна;
# readiness это покажет, а запросы получат 503.
pool.open(wait=False)
return pool
def _migration_files():
files = sorted(MIGRATIONS_DIR.glob("*.sql"))
if not files:
raise RuntimeError("no migrations found in %s" % MIGRATIONS_DIR)
return files
def apply_migrations(settings: Settings) -> list:
"""Применяет недостающие миграции; возвращает список применённых версий."""
applied_now = []
with psycopg.connect(
settings.database_url, autocommit=True, **conninfo_kwargs(settings)
) as conn:
conn.execute("SELECT pg_advisory_lock(%s)", (MIGRATION_LOCK_ID,))
try:
conn.execute(
"""
CREATE TABLE IF NOT EXISTS schema_migrations (
version text PRIMARY KEY,
applied_at timestamptz NOT NULL DEFAULT now()
)
"""
)
done = {
row[0]
for row in conn.execute("SELECT version FROM schema_migrations")
}
for path in _migration_files():
version = path.stem
if version in done:
continue
sql = path.read_text(encoding="utf-8")
# DDL и отметка о версии — одна транзакция: либо всё, либо ничего.
with conn.transaction():
conn.execute(sql)
conn.execute(
"INSERT INTO schema_migrations (version) VALUES (%s)",
(version,),
)
applied_now.append(version)
log.info("applied migration %s", version)
finally:
conn.execute("SELECT pg_advisory_unlock(%s)", (MIGRATION_LOCK_ID,))
return applied_now
def wait_and_migrate(settings: Settings) -> list:
deadline = time.monotonic() + settings.migrate_wait_seconds
last_error: Optional[Exception] = None
while time.monotonic() < deadline:
try:
return apply_migrations(settings)
except psycopg.OperationalError as exc:
last_error = exc
log.warning("database not ready for migrations, retrying")
time.sleep(1)
raise RuntimeError("database unavailable for migrations") from last_error
+378
View File
@@ -0,0 +1,378 @@
import base64
import json
import logging
import re
from contextlib import asynccontextmanager
from datetime import datetime
from typing import Any, Callable, Dict, Optional, Tuple
from uuid import UUID, uuid4
import psycopg
from fastapi import Depends, FastAPI, Query, Request, Response
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from psycopg_pool import PoolTimeout
from starlette.exceptions import HTTPException as StarletteHTTPException
from starlette.middleware.base import BaseHTTPMiddleware
from .config import load_settings
from .db import create_pool, wait_and_migrate
from .models import (
Chat,
ChatCreate,
ChatPage,
Message,
MessageCreate,
MessagePage,
Session,
User,
UserCreate,
)
from .security import hash_password, parse_basic, parse_bearer, verify_password
from .sessions import SessionCache, SessionService
from .storage import Storage, UnknownMember, UsernameTaken
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s")
log = logging.getLogger("messenger.api")
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
BEARER_CHALLENGE = 'Bearer realm="messenger"'
REQUEST_ID_RE = re.compile(r"^[A-Za-z0-9._:-]{1,128}$")
@asynccontextmanager
async def lifespan(app: FastAPI):
settings = load_settings()
applied = wait_and_migrate(settings)
log.info("migrations applied at startup: %s", applied or "none")
pool = create_pool(settings)
storage = Storage(pool)
cache = SessionCache(settings)
app.state.settings = settings
app.state.storage = storage
app.state.cache = cache
app.state.sessions = SessionService(storage, cache, settings)
log.info(
"started: session_ttl=%ss cache=%s pool=%s..%s",
settings.session_ttl_seconds,
"redis" if cache.client is not None else "disabled",
settings.db_pool_min,
settings.db_pool_max,
)
try:
yield
finally:
pool.close()
if cache.client is not None:
cache.client.close()
app = FastAPI(
title="MTUSI Messenger (PostgreSQL + Redis)",
version="2.0.0",
lifespan=lifespan,
)
# Request ID
class RequestIdMiddleware(BaseHTTPMiddleware):
async def dispatch(self, request: Request, call_next: Callable):
incoming = request.headers.get("X-Request-Id", "")
request_id = incoming if REQUEST_ID_RE.match(incoming) else str(uuid4())
request.state.request_id = request_id
response = await call_next(request)
response.headers["X-Request-Id"] = request_id
return response
app.add_middleware(RequestIdMiddleware)
# errors
class ApiError(Exception):
def __init__(self, status_code: int, code: str, message: str, headers: Optional[Dict[str, str]] = None):
self.status_code = status_code
self.code = code
self.message = message
self.headers = headers or {}
def unauthorized(challenge: str = BEARER_CHALLENGE) -> ApiError:
return ApiError(401, "unauthorized", "Authentication required", {"WWW-Authenticate": challenge})
def bad_request(message: str = "Invalid request") -> ApiError:
return ApiError(400, "invalid_request", message)
def not_found() -> ApiError:
return ApiError(404, "not_found", "Not found")
def error_response(
request: Request,
status_code: int,
code: str,
message: str,
headers: Optional[Dict[str, str]] = None,
) -> JSONResponse:
request_id = getattr(request.state, "request_id", None) or str(uuid4())
all_headers = {"X-Request-Id": request_id}
all_headers.update(headers or {})
return JSONResponse(
status_code=status_code,
content={"error": {"code": code, "message": message, "request_id": request_id}},
headers=all_headers,
)
@app.exception_handler(ApiError)
async def api_error_handler(request: Request, exc: ApiError) -> JSONResponse:
return error_response(request, exc.status_code, exc.code, exc.message, exc.headers)
@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request: Request, exc: RequestValidationError) -> JSONResponse:
return error_response(request, 400, "invalid_request", "Invalid request")
@app.exception_handler(StarletteHTTPException)
async def http_exception_handler(request: Request, exc: StarletteHTTPException) -> JSONResponse:
status_to_code = {
400: "invalid_request",
401: "unauthorized",
404: "not_found",
409: "conflict",
413: "payload_too_large",
415: "unsupported_media_type",
429: "rate_limited",
503: "unavailable",
}
status_code = exc.status_code if exc.status_code in status_to_code else 500
code = status_to_code.get(status_code, "internal_error")
message = str(exc.detail) if status_code != 500 else "Internal server error"
return error_response(request, status_code, code, message)
async def dependency_unavailable(request: Request, exc: Exception) -> JSONResponse:
# Наружу — только общий 503, без SQL, адресов и текста драйвера.
log.warning("database unavailable: %s", type(exc).__name__)
return error_response(request, 503, "unavailable", "Service temporarily unavailable")
app.add_exception_handler(psycopg.OperationalError, dependency_unavailable)
app.add_exception_handler(psycopg.InterfaceError, dependency_unavailable)
app.add_exception_handler(PoolTimeout, dependency_unavailable)
@app.exception_handler(Exception)
async def unexpected_exception_handler(request: Request, exc: Exception) -> JSONResponse:
log.exception("unexpected error")
return error_response(request, 500, "internal_error", "Internal server error")
# helpers
def require_json_content_type(request: Request) -> None:
content_type = request.headers.get("content-type", "")
if not content_type.lower().startswith("application/json"):
raise ApiError(415, "unsupported_media_type", "Unsupported media type")
def ensure_not_blank(value: str) -> None:
if not value.strip():
raise bad_request()
def storage_of(request: Request) -> Storage:
return request.app.state.storage
def current_user(request: Request) -> User:
"""Только Authorization: Bearer. Basic и X-User-Id здесь не дают доступа."""
token = parse_bearer(request.headers.get("Authorization"))
if token is None:
raise unauthorized()
user = request.app.state.sessions.resolve(token)
if user is None:
raise unauthorized()
request.state.token = token
return user
def encode_cursor(resource_id: UUID, created_at: datetime, item_id: UUID) -> str:
payload = {
"resource_id": str(resource_id),
"created_at": created_at.isoformat(),
"item_id": str(item_id),
}
raw = json.dumps(payload, separators=(",", ":")).encode("utf-8")
return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")
def decode_cursor(cursor: Optional[str], expected_resource_id: UUID) -> Optional[Tuple[datetime, UUID]]:
if cursor is None:
return None
try:
padding = "=" * (-len(cursor) % 4)
raw = base64.urlsafe_b64decode(cursor + padding)
payload = json.loads(raw.decode("utf-8"))
resource_id = UUID(payload["resource_id"])
created_at = datetime.fromisoformat(payload["created_at"])
item_id = UUID(payload["item_id"])
if created_at.tzinfo is None or created_at.utcoffset() is None:
raise ValueError("invalid_cursor")
except (ValueError, KeyError, TypeError, AttributeError, json.JSONDecodeError):
raise bad_request("Invalid cursor")
if resource_id != expected_resource_id:
raise bad_request("Invalid cursor")
return created_at, item_id
# health
@app.get("/health/live", response_model=Dict[str, str])
def liveness() -> Dict[str, str]:
return {"status": "ok"}
@app.get("/health/ready", response_model=Dict[str, str])
def readiness(request: Request) -> Dict[str, str]:
# Критична только PostgreSQL. Redis — кэш с обходом, его отказ не делает
# API неготовым (см. REPORT.md).
try:
storage_of(request).ping()
except (psycopg.Error, PoolTimeout):
raise ApiError(503, "unavailable", "Database is not available")
return {"status": "ok"}
# users
@app.post("/api/v1/users", response_model=User, status_code=201)
def register_user(request: Request, data: UserCreate) -> User:
require_json_content_type(request)
ensure_not_blank(data.display_name)
ensure_not_blank(data.password)
password_hash = hash_password(data.password)
try:
return storage_of(request).create_user(data.username, data.display_name, password_hash)
except UsernameTaken:
raise ApiError(409, "conflict", "Username already exists")
@app.get("/api/v1/users/me", response_model=User)
def get_current_user(user: User = Depends(current_user)) -> User:
return user
# sessions
async def require_empty_body(request: Request) -> None:
"""Вход — только заголовок Authorization: Basic, без тела (контракт).
Любые байты в теле (JSON или нет) — 400. Проверка выполняется до
дорогой проверки пароля и до создания сессии.
"""
if await request.body():
raise bad_request("Request body is not allowed")
@app.post("/api/v1/auth/sessions", response_model=Session, status_code=201,
dependencies=[Depends(require_empty_body)])
def create_session(request: Request) -> Session:
credentials = parse_basic(request.headers.get("Authorization"))
if credentials is None:
raise unauthorized(BASIC_CHALLENGE)
username, password = credentials
found = storage_of(request).get_credentials(username)
user, password_hash = found if found else (None, None)
# verify_password выполняется и для несуществующего username (с хешем-пустышкой).
if not verify_password(password_hash, password) or user is None:
raise unauthorized(BASIC_CHALLENGE)
token, expires_at = request.app.state.sessions.create(user)
return Session(token=token, token_type="Bearer", expires_at=expires_at, user=user)
@app.delete("/api/v1/auth/sessions/current", status_code=204)
def delete_current_session(request: Request, user: User = Depends(current_user)) -> Response:
if not request.app.state.sessions.revoke(request.state.token):
raise unauthorized()
return Response(status_code=204)
# chats
@app.post("/api/v1/chats", response_model=Chat, status_code=201)
def create_chat(request: Request, data: ChatCreate, user: User = Depends(current_user)) -> Chat:
require_json_content_type(request)
ensure_not_blank(data.title)
if len(data.member_ids) != len(set(data.member_ids)):
raise bad_request("Duplicate member ids")
if user.id not in data.member_ids:
raise bad_request("Caller must be a chat member")
try:
return storage_of(request).create_chat(data.title, data.member_ids)
except UnknownMember:
raise bad_request("Unknown member")
@app.get("/api/v1/chats", response_model=ChatPage)
def list_chats(
request: Request,
user: User = Depends(current_user),
limit: int = Query(default=50, ge=1, le=100),
cursor: Optional[str] = Query(default=None, min_length=1),
) -> ChatPage:
after = decode_cursor(cursor, user.id)
items, has_more = storage_of(request).list_user_chats(user.id, limit, after)
next_cursor = None
if has_more and items:
next_cursor = encode_cursor(user.id, items[-1].created_at, items[-1].id)
return ChatPage(items=items, next_cursor=next_cursor)
@app.get("/api/v1/chats/{chat_id}", response_model=Chat)
def get_chat(request: Request, chat_id: UUID, user: User = Depends(current_user)) -> Chat:
chat = storage_of(request).get_chat_for_member(chat_id, user.id)
if chat is None:
raise not_found()
return chat
# messages
@app.post("/api/v1/chats/{chat_id}/messages", response_model=Message, status_code=201)
def create_message(
request: Request,
chat_id: UUID,
data: MessageCreate,
user: User = Depends(current_user),
) -> Message:
require_json_content_type(request)
ensure_not_blank(data.text)
message = storage_of(request).create_message(chat_id, user.id, data.text)
if message is None:
raise not_found()
return message
@app.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePage)
def list_messages(
request: Request,
chat_id: UUID,
user: User = Depends(current_user),
limit: int = Query(default=50, ge=1, le=100),
cursor: Optional[str] = Query(default=None, min_length=1),
) -> MessagePage:
after = decode_cursor(cursor, chat_id)
result = storage_of(request).list_messages(chat_id, user.id, limit, after)
if result is None:
raise not_found()
items, has_more = result
next_cursor = None
if has_more and items:
next_cursor = encode_cursor(chat_id, items[-1].created_at, items[-1].id)
return MessagePage(items=items, next_cursor=next_cursor)
+22
View File
@@ -0,0 +1,22 @@
"""Ручной запуск миграций: python -m src.migrate
API применяет миграции и сам при старте; команда нужна для явного bootstrap
и для демонстрации, что повторный запуск ничего не меняет.
"""
import logging
from .config import load_settings
from .db import wait_and_migrate
def main() -> None:
logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s %(message)s")
applied = wait_and_migrate(load_settings())
if applied:
print("applied migrations: " + ", ".join(applied))
else:
print("schema is up to date; nothing applied")
if __name__ == "__main__":
main()
+83
View File
@@ -0,0 +1,83 @@
from datetime import datetime
from typing import List, Optional
from uuid import UUID
from pydantic import BaseModel, ConfigDict, Field
class StrictModel(BaseModel):
model_config = ConfigDict(extra="forbid")
class UserCreate(StrictModel):
username: str = Field(
min_length=3,
max_length=32,
pattern=r"^[a-z0-9_]{3,32}$",
)
display_name: str = Field(
min_length=1,
max_length=100,
)
# lab2: пароль обязателен; длина в Unicode code points (len() в Python).
password: str = Field(
min_length=12,
max_length=128,
)
class User(StrictModel):
id: UUID
username: str
display_name: str
created_at: datetime
class Session(StrictModel):
token: str
token_type: str = "Bearer"
expires_at: datetime
user: User
class ChatCreate(StrictModel):
title: str = Field(
min_length=1,
max_length=100,
)
member_ids: List[UUID] = Field(
min_length=1,
max_length=100,
)
class Chat(StrictModel):
id: UUID
title: str
member_ids: List[UUID]
created_at: datetime
class MessageCreate(StrictModel):
text: str = Field(
min_length=1,
max_length=4000,
)
class Message(StrictModel):
id: UUID
chat_id: UUID
sender_id: UUID
text: str
created_at: datetime
class ChatPage(StrictModel):
items: List[Chat]
next_cursor: Optional[str]
class MessagePage(StrictModel):
items: List[Message]
next_cursor: Optional[str]
+82
View File
@@ -0,0 +1,82 @@
"""Пароли, разбор Basic/Bearer и генерация токенов."""
import base64
import binascii
import hashlib
import re
import secrets
from typing import Optional, Tuple
from argon2 import PasswordHasher
from argon2.exceptions import InvalidHashError, VerificationError, VerifyMismatchError
USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$")
# Argon2id (библиотека argon2-cffi). Параметры — рекомендация OWASP для
# Argon2id: m=19 MiB, t=2, p=1. Пароль хешируется целиком в UTF-8, без усечения.
_hasher = PasswordHasher(time_cost=2, memory_cost=19 * 1024, parallelism=1)
# Хеш-«пустышка»: проверка для несуществующего пользователя стоит столько же,
# сколько для существующего, — время ответа не выдаёт наличие username.
_DUMMY_HASH = _hasher.hash("dummy-password-for-timing-equalization")
# 32 байта случайности = 256 бит энтропии; base64url без padding = 43 символа.
TOKEN_BYTES = 32
MAX_TOKEN_LENGTH = 256
def hash_password(password: str) -> str:
return _hasher.hash(password)
def verify_password(password_hash: Optional[str], password: str) -> bool:
try:
return _hasher.verify(password_hash or _DUMMY_HASH, password) and bool(
password_hash
)
except (VerifyMismatchError, VerificationError, InvalidHashError):
return False
def new_token() -> str:
return secrets.token_urlsafe(TOKEN_BYTES)
def token_digest(token: str) -> bytes:
"""Токен высокоэнтропийный, поэтому для поиска достаточно быстрого SHA-256.
В отличие от пароля, перебор 256-битного токена невозможен, и KDF здесь
только замедлил бы каждый запрос.
"""
return hashlib.sha256(token.encode("ascii")).digest()
def parse_basic(header: Optional[str]) -> Optional[Tuple[str, str]]:
"""Authorization: Basic base64(username:password) -> (username, password)."""
if not header:
return None
scheme, _, value = header.strip().partition(" ")
if scheme.lower() != "basic" or not value.strip():
return None
try:
raw = base64.b64decode(value.strip(), validate=True)
decoded = raw.decode("utf-8")
except (binascii.Error, ValueError, UnicodeDecodeError):
return None
username, sep, password = decoded.partition(":") # двоеточие в пароле допустимо
if not sep or not USERNAME_RE.match(username):
return None
if not 12 <= len(password) <= 128:
return None
return username, password
def parse_bearer(header: Optional[str]) -> Optional[str]:
if not header:
return None
scheme, _, value = header.strip().partition(" ")
token = value.strip()
if scheme.lower() != "bearer" or not token or len(token) > MAX_TOKEN_LENGTH:
return None
if not token.isascii() or any(ch.isspace() for ch in token):
return None
return token
+240
View File
@@ -0,0 +1,240 @@
"""Сессии: PostgreSQL — источник истины, Redis — кэш проверок токена.
Роль Redis
----------
Каждый защищённый запрос сначала ищет `sess:<sha256(token)>` в Redis.
* попадание -> пользователь берётся из кэша, PostgreSQL не трогаем;
* промах -> читаем sessions JOIN users в PostgreSQL и кладём результат
в Redis через SET NX с TTL = min(SESSION_CACHE_TTL_SECONDS,
время до expires_at). Запись кэша никогда не переживает сессию.
Инвалидация (logout)
--------------------
1. UPDATE sessions SET revoked_at (COMMIT в PostgreSQL — момент отзыва);
2. SET sess:<hash> = "revoked" PX=SESSION_CACHE_TTL (обычный SET, перезаписывает).
Заполнение кэша идёт через SET NX, поэтому параллельный запрос, прочитавший
сессию до отзыва, не может перезаписать «надгробие» валидной записью.
Надёжность отзыва при сбое Redis
--------------------------------
Отзыв в PostgreSQL и строка-«долг» в session_cache_invalidations пишутся
ОДНОЙ транзакцией (миграция 002). Строка удаляется только после успешной
записи «надгробия» в Redis. Если записать его не удалось (таймаут, обрыв
связи, Redis заморожен), на кэш больше нельзя полагаться: в нём могла
остаться положительная запись отозванного токена. Поэтому:
* пока долг не погашен, положительные попадания кэша НЕ принимаются —
каждый токен проверяется в PostgreSQL (отозванный -> 401);
* не чаще раза в секунду API пытается погасить долг: пишет надгробия в
Redis и удаляет строки; строки старше SESSION_CACHE_TTL + 5 с удаляются
без записи (любая положительная запись к этому моменту уже истекла);
* наличие долга перечитывается из PostgreSQL не реже раза в секунду, так что
и другие реплики (lab3) перестают доверять кэшу не позже чем через 1 с;
реплика, выполнившая logout, — сразу, до ответа 204.
Отказ Redis
-----------
Любая ошибка Redis (таймаут 250 мс) -> кэш пропускается, проверка идёт в
PostgreSQL; на CACHE_RETRY_AFTER_SECONDS Redis выключается (простой
circuit breaker), чтобы не платить таймаут на каждом запросе.
Redis работает без persistence: после рестарта кэш пуст, и это безопасно —
следующие запросы просто заполнят его из PostgreSQL.
"""
import json
import logging
import threading
import time
from datetime import datetime, timezone
from typing import Optional, Tuple
import redis
from .config import Settings
from .models import User
from .security import new_token, token_digest
from .storage import Storage
log = logging.getLogger("messenger.sessions")
REVOKED = "revoked"
class SessionCache:
def __init__(self, settings: Settings) -> None:
self.ttl_ms = settings.session_cache_ttl_seconds * 1000
self.retry_after = settings.cache_retry_after_seconds
self._down_until = 0.0
self._lock = threading.Lock()
self.client: Optional[redis.Redis] = None
if settings.cache_url:
self.client = redis.Redis.from_url(
settings.cache_url,
socket_timeout=settings.cache_timeout_seconds,
socket_connect_timeout=settings.cache_timeout_seconds,
retry_on_timeout=False,
health_check_interval=30,
max_connections=20,
decode_responses=True,
)
# Счётчики для наблюдения и тестов (GET /health/cache не нужен контракту,
# поэтому они только логируются).
self.hits = 0
self.misses = 0
self.errors = 0
@staticmethod
def key(digest: bytes) -> str:
return "sess:" + digest.hex()
def _available(self) -> bool:
return self.client is not None and time.monotonic() >= self._down_until
def _failed(self, exc: Exception) -> None:
with self._lock:
self.errors += 1
if time.monotonic() >= self._down_until:
log.warning("redis unavailable (%s); bypassing cache for %.0fs",
type(exc).__name__, self.retry_after)
self._down_until = time.monotonic() + self.retry_after
def get(self, digest: bytes):
"""None — промах/кэш недоступен; REVOKED — отозвано; иначе (User, expires_at)."""
if not self._available():
return None
try:
raw = self.client.get(self.key(digest))
except redis.RedisError as exc:
self._failed(exc)
return None
if raw is None:
self.misses += 1
return None
self.hits += 1
if raw == REVOKED:
return REVOKED
try:
data = json.loads(raw)
expires_at = datetime.fromisoformat(data["expires_at"])
return User(**data["user"]), expires_at
except (ValueError, KeyError, TypeError):
return None
def put(self, digest: bytes, user: User, expires_at: datetime) -> None:
if not self._available():
return
remaining_ms = int((expires_at - datetime.now(timezone.utc)).total_seconds() * 1000)
ttl = min(self.ttl_ms, remaining_ms)
if ttl <= 0:
return
value = json.dumps({"user": user.model_dump(mode="json"), "expires_at": expires_at.isoformat()})
try:
self.client.set(self.key(digest), value, px=ttl, nx=True)
except redis.RedisError as exc:
self._failed(exc)
def revoke(self, digest: bytes) -> bool:
"""True — надгробие записано (или кэша нет вовсе); False — не удалось."""
if self.client is None:
return True
if not self._available():
return False
try:
self.client.set(self.key(digest), REVOKED, px=self.ttl_ms)
return True
except redis.RedisError as exc:
self._failed(exc)
return False
def ping(self) -> bool:
if self.client is None:
return False
try:
return bool(self.client.ping())
except redis.RedisError:
return False
class SessionService:
# Как часто перечитывать из PostgreSQL наличие непогашенных инвалидаций.
RECHECK_SECONDS = 1.0
def __init__(self, storage: Storage, cache: SessionCache, settings: Settings) -> None:
self.storage = storage
self.cache = cache
self.ttl = settings.session_ttl_seconds
# Строки старше этого возраста можно удалять без записи в Redis.
self.stale_after = settings.session_cache_ttl_seconds + 5
self._lock = threading.Lock()
self._pending = True # до первой сверки с БД кэшу не доверяем
self._checked_at = float("-inf")
def create(self, user: User) -> Tuple[str, datetime]:
token = new_token()
expires_at = self.storage.create_session(token_digest(token), user.id, self.ttl)
return token, expires_at
def _reconcile(self) -> None:
"""Погасить долг инвалидации; вызывается под self._lock."""
try:
rows = self.storage.pending_invalidations()
done = []
for digest, age in rows:
if age > self.stale_after or self.cache.revoke(digest):
done.append(digest)
else:
break # Redis всё ещё недоступен — попробуем позже
self.storage.delete_invalidations(done)
self._pending = len(done) < len(rows) or len(rows) >= 500
if rows and not self._pending:
log.info("cache invalidation backlog cleared (%d)", len(done))
except Exception as exc: # PostgreSQL недоступна: доверять кэшу нельзя
log.warning("cannot verify cache invalidations: %s", type(exc).__name__)
self._pending = True
# Пробрасываем сразу (-> 503): иначе запрос ждал бы пул второй раз
# в find_session и отвечал за 2 x DB_POOL_TIMEOUT_SECONDS.
raise
def cache_trusted(self) -> bool:
now = time.monotonic()
if now - self._checked_at < self.RECHECK_SECONDS:
return not self._pending
with self._lock:
if now - self._checked_at >= self.RECHECK_SECONDS:
self._reconcile()
self._checked_at = time.monotonic()
return not self._pending
def resolve(self, token: str) -> Optional[User]:
digest = token_digest(token)
# Сначала сверка (она может дописать надгробия в Redis), и только
# потом чтение кэша — иначе прочитанная до сверки запись устарела бы.
trusted = self.cache_trusted()
cached = self.cache.get(digest)
if cached == REVOKED:
return None
if cached is not None and trusted:
user, expires_at = cached
if expires_at > datetime.now(timezone.utc):
return user
found = self.storage.find_session(digest) # PostgreSQL недоступна -> исключение -> 503
if found is None:
return None
user, expires_at = found
self.cache.put(digest, user, expires_at)
return user
def revoke(self, token: str) -> bool:
digest = token_digest(token)
if not self.storage.revoke_session(digest): # COMMIT: отзыв + долг инвалидации
return False
if self.cache.revoke(digest):
try:
self.storage.delete_invalidations([digest])
except Exception:
pass # строка останется и будет удалена при следующей сверке
else:
# Надгробие не записано: до погашения долга кэшу не доверяем.
with self._lock:
self._pending = True
self._checked_at = time.monotonic()
log.warning("logout: cache invalidation deferred; positive cache disabled")
return True
+301
View File
@@ -0,0 +1,301 @@
"""Доступ к PostgreSQL. Все запросы параметризованы (%s), SQL не склеивается
со значениями пользователя. Каждая публичная операция — одна транзакция
(`with pool.connection()` делает COMMIT при успехе и ROLLBACK при исключении).
"""
from datetime import datetime, timedelta
from typing import List, Optional, Sequence, Tuple
from uuid import UUID, uuid4
from psycopg import errors
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool
from .models import Chat, Message, User
class UsernameTaken(Exception):
pass
class UnknownMember(Exception):
pass
Position = Optional[Tuple[datetime, UUID]]
def _user(row) -> User:
return User(
id=row["id"],
username=row["username"],
display_name=row["display_name"],
created_at=row["created_at"],
)
class Storage:
def __init__(self, pool: ConnectionPool) -> None:
self.pool = pool
def ping(self) -> None:
with self.pool.connection() as conn:
conn.execute("SELECT 1")
# users
def create_user(self, username: str, display_name: str, password_hash: str) -> User:
try:
with self.pool.connection() as conn:
row = conn.cursor(row_factory=dict_row).execute(
"""
INSERT INTO users (id, username, display_name, password_hash)
VALUES (%s, %s, %s, %s)
RETURNING id, username, display_name, created_at
""",
(uuid4(), username, display_name, password_hash),
).fetchone()
except errors.UniqueViolation:
# Гонку двух одинаковых регистраций решает UNIQUE(username) в БД,
# а не проверка «SELECT, потом INSERT» в приложении.
raise UsernameTaken()
return _user(row)
def get_credentials(self, username: str) -> Optional[Tuple[User, str]]:
with self.pool.connection() as conn:
row = conn.cursor(row_factory=dict_row).execute(
"""
SELECT id, username, display_name, created_at, password_hash
FROM users WHERE username = %s
""",
(username,),
).fetchone()
if row is None:
return None
return _user(row), row["password_hash"]
# sessions (источник истины)
def create_session(self, token_hash: bytes, user_id: UUID, ttl_seconds: int) -> datetime:
with self.pool.connection() as conn:
# Заодно убираем давно истёкшие сессии этого пользователя.
conn.execute(
"DELETE FROM sessions WHERE user_id = %s AND expires_at < now() - interval '1 day'",
(user_id,),
)
row = conn.execute(
"""
INSERT INTO sessions (token_hash, user_id, expires_at)
VALUES (%s, %s, clock_timestamp() + make_interval(secs => %s))
RETURNING expires_at
""",
(token_hash, user_id, ttl_seconds),
).fetchone()
return row[0]
def find_session(self, token_hash: bytes) -> Optional[Tuple[User, datetime]]:
with self.pool.connection() as conn:
row = conn.cursor(row_factory=dict_row).execute(
"""
SELECT u.id, u.username, u.display_name, u.created_at, s.expires_at
FROM sessions s JOIN users u ON u.id = s.user_id
WHERE s.token_hash = %s
AND s.revoked_at IS NULL
AND s.expires_at > clock_timestamp()
""",
(token_hash,),
).fetchone()
if row is None:
return None
return _user(row), row["expires_at"]
def revoke_session(self, token_hash: bytes) -> bool:
"""Отзыв и долг «инвалидировать кэш» фиксируются одним COMMIT."""
with self.pool.connection() as conn:
with conn.transaction():
row = conn.execute(
"""
UPDATE sessions SET revoked_at = clock_timestamp()
WHERE token_hash = %s
AND revoked_at IS NULL
AND expires_at > clock_timestamp()
RETURNING 1
""",
(token_hash,),
).fetchone()
if row is not None:
conn.execute(
"""
INSERT INTO session_cache_invalidations (token_hash)
VALUES (%s) ON CONFLICT (token_hash) DO NOTHING
""",
(token_hash,),
)
return row is not None
# долг инвалидации кэша
def has_pending_invalidations(self) -> bool:
with self.pool.connection() as conn:
return conn.execute(
"SELECT EXISTS (SELECT 1 FROM session_cache_invalidations)"
).fetchone()[0]
def pending_invalidations(self, limit: int = 500) -> List[Tuple[bytes, float]]:
"""[(token_hash, возраст в секундах)] — самые старые первыми."""
with self.pool.connection() as conn:
rows = conn.execute(
"""
SELECT token_hash, EXTRACT(EPOCH FROM clock_timestamp() - revoked_at)
FROM session_cache_invalidations
ORDER BY revoked_at LIMIT %s
""",
(limit,),
).fetchall()
return [(bytes(h), float(age)) for h, age in rows]
def delete_invalidations(self, token_hashes: Sequence[bytes]) -> None:
if not token_hashes:
return
with self.pool.connection() as conn:
conn.execute(
"DELETE FROM session_cache_invalidations WHERE token_hash = ANY(%s)",
(list(token_hashes),),
)
# chats
def _insert_members(self, conn, chat_id: UUID, member_ids: Sequence[UUID]) -> None:
with conn.cursor() as cur:
cur.executemany(
"INSERT INTO chat_members (chat_id, user_id, position) VALUES (%s, %s, %s)",
[(chat_id, member_id, pos) for pos, member_id in enumerate(member_ids)],
)
def create_chat(self, title: str, member_ids: Sequence[UUID]) -> Chat:
"""Чат и все участники создаются в одной транзакции.
Существование участников проверяет внешний ключ chat_members.user_id:
если хоть один id неизвестен, INSERT падает, и откатывается вся
транзакция, включая уже вставленную строку chats и других участников.
"""
chat_id = uuid4()
try:
with self.pool.connection() as conn:
with conn.transaction():
created_at = conn.execute(
"INSERT INTO chats (id, title) VALUES (%s, %s) RETURNING created_at",
(chat_id, title),
).fetchone()[0]
self._insert_members(conn, chat_id, member_ids)
except errors.ForeignKeyViolation:
raise UnknownMember()
return Chat(id=chat_id, title=title, member_ids=list(member_ids), created_at=created_at)
def _members_for(self, conn, chat_ids: List[UUID]) -> dict:
members = {chat_id: [] for chat_id in chat_ids}
if not chat_ids:
return members
rows = conn.execute(
"""
SELECT chat_id, user_id FROM chat_members
WHERE chat_id = ANY(%s) ORDER BY chat_id, position
""",
(chat_ids,),
).fetchall()
for chat_id, user_id in rows:
members[chat_id].append(user_id)
return members
def get_chat_for_member(self, chat_id: UUID, user_id: UUID) -> Optional[Chat]:
with self.pool.connection() as conn:
row = conn.cursor(row_factory=dict_row).execute(
"""
SELECT c.id, c.title, c.created_at
FROM chats c
JOIN chat_members m ON m.chat_id = c.id AND m.user_id = %s
WHERE c.id = %s
""",
(user_id, chat_id),
).fetchone()
if row is None:
return None
members = self._members_for(conn, [row["id"]])
return Chat(id=row["id"], title=row["title"], member_ids=members[row["id"]], created_at=row["created_at"])
def list_user_chats(self, user_id: UUID, limit: int, after: Position) -> Tuple[List[Chat], bool]:
params: list = [user_id]
keyset = ""
if after is not None:
keyset = "AND (c.created_at, c.id) > (%s, %s)"
params.extend(after)
params.append(limit + 1)
with self.pool.connection() as conn:
rows = conn.cursor(row_factory=dict_row).execute(
"""
SELECT c.id, c.title, c.created_at
FROM chat_members m JOIN chats c ON c.id = m.chat_id
WHERE m.user_id = %s {keyset}
ORDER BY c.created_at, c.id
LIMIT %s
""".format(keyset=keyset),
params,
).fetchall()
has_more = len(rows) > limit
rows = rows[:limit]
members = self._members_for(conn, [r["id"] for r in rows])
chats = [
Chat(id=r["id"], title=r["title"], member_ids=members[r["id"]], created_at=r["created_at"])
for r in rows
]
return chats, has_more
# messages
def create_message(self, chat_id: UUID, sender_id: UUID, text: str) -> Optional[Message]:
"""Проверка членства и вставка — один оператор, без окна гонки."""
with self.pool.connection() as conn:
row = conn.cursor(row_factory=dict_row).execute(
"""
INSERT INTO messages (id, chat_id, sender_id, text)
SELECT %s, %s, %s, %s
WHERE EXISTS (
SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s
)
RETURNING id, chat_id, sender_id, text, created_at
""",
(uuid4(), chat_id, sender_id, text, chat_id, sender_id),
).fetchone()
if row is None:
return None
return Message(**row)
def list_messages(
self, chat_id: UUID, user_id: UUID, limit: int, after: Position
) -> Optional[Tuple[List[Message], bool]]:
params: list = [chat_id]
keyset = ""
if after is not None:
keyset = "AND (created_at, id) > (%s, %s)"
params.extend(after)
params.append(limit + 1)
with self.pool.connection() as conn:
member = conn.execute(
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
(chat_id, user_id),
).fetchone()
if member is None:
return None
# Keyset-пагинация по индексу messages_chat_created_id_idx:
# Index Scan сразу с позиции курсора, читается limit+1 строк.
rows = conn.cursor(row_factory=dict_row).execute(
"""
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = %s {keyset}
ORDER BY created_at, id
LIMIT %s
""".format(keyset=keyset),
params,
).fetchall()
has_more = len(rows) > limit
return [Message(**r) for r in rows[:limit]], has_more
+101
View File
@@ -0,0 +1,101 @@
"""Общие HTTP-помощники собственных тестов (только стандартная библиотека)."""
import base64
import json
import os
import uuid
from urllib.error import HTTPError, URLError
from urllib.request import Request, urlopen
BASE_URL = os.environ.get("BASE_URL", "http://127.0.0.1:8080").rstrip("/")
class Resp:
def __init__(self, status, data, headers, elapsed=0.0):
self.status = status
self.json = data
self.headers = headers
self.elapsed = elapsed
def request(method, path, token=None, payload=None, raw=None, headers=None,
base_url=None, timeout=10):
import time
h = {"Accept": "application/json"}
if token is not None:
h["Authorization"] = "Bearer " + token
body = None
if payload is not None:
body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
h["Content-Type"] = "application/json"
elif raw is not None:
body = raw
h["Content-Type"] = "application/json"
h.update(headers or {})
req = Request((base_url or BASE_URL) + path, data=body, headers=h, method=method)
started = time.monotonic()
try:
response = urlopen(req, timeout=timeout)
except HTTPError as error:
response = error
with response:
content = response.read()
status = response.status if hasattr(response, "status") else response.code
rh = response.headers
try:
data = json.loads(content.decode("utf-8")) if content else None
except (UnicodeDecodeError, json.JSONDecodeError):
data = None
return Resp(status, data, rh, time.monotonic() - started)
def basic(username, password):
raw = (username + ":" + password).encode("utf-8")
return "Basic " + base64.b64encode(raw).decode("ascii")
def new_password():
return "Pw-" + uuid.uuid4().hex
def register(prefix="t", password=None, base_url=None):
username = (prefix + "_" + uuid.uuid4().hex[:16])[:32]
password = password or new_password()
r = request("POST", "/api/v1/users", base_url=base_url, payload={
"username": username,
"display_name": "Test " + prefix,
"password": password,
})
assert r.status == 201, (r.status, r.json)
user = r.json
user["_password"] = password
return user
def login(user, base_url=None):
r = request("POST", "/api/v1/auth/sessions", base_url=base_url,
headers={"Authorization": basic(user["username"], user["_password"])})
assert r.status == 201, (r.status, r.json)
return r.json["token"]
def actor(prefix="t", base_url=None):
user = register(prefix, base_url=base_url)
user["_token"] = login(user, base_url=base_url)
return user
def create_chat(owner, *members, base_url=None):
r = request("POST", "/api/v1/chats", token=owner["_token"], base_url=base_url, payload={
"title": "Test chat " + uuid.uuid4().hex[:8],
"member_ids": [owner["id"]] + [m["id"] for m in members],
})
assert r.status == 201, (r.status, r.json)
return r.json
def reachable(base_url):
try:
urlopen(base_url.rstrip("/") + "/health/live", timeout=2).read()
return True
except (URLError, OSError, HTTPError):
return False
+206
View File
@@ -0,0 +1,206 @@
#!/usr/bin/env python3
"""Автоматическая проверка недоступности Redis и PostgreSQL.
Сценарий явно останавливает зависимости, поэтому не входит в discovery
unittest. По умолчанию использует docker compose из корня репозитория:
python student-tests/dependency_failure.py --base-url http://127.0.0.1:8080
Команды остановки/запуска можно переопределить (--stop-redis и т.д.), например
для стенда без Docker. Результат — JSON-сводка (без токенов) в stdout и,
при --output, в файл.
Ожидаемое поведение:
* Redis недоступен -> API обходит кэш, всё работает через PostgreSQL,
readiness = 200, задержка ограничена таймаутом Redis (250 мс) и
circuit breaker'ом; logout по-прежнему отзывает сессию.
* Разрыв сети API <-> Redis БЕЗ рестарта Redis (данные кэша живы) и logout
во время разрыва -> logout 204, и отозванный токен получает 401 и во время
разрыва, и сразу после восстановления связи, и после закрытия circuit
breaker (регрессия: раньше доверяли старой положительной записи ~60 с).
* PostgreSQL недоступна -> /health/live = 200, /health/ready = 503,
запросы к данным -> 503 unavailable за ограниченное время; анонимный
запрос -> 401; неизвестный токен не принимается (503, а не 200).
* После возврата зависимости тот же токен снова работает, данные на месте.
"""
import argparse
import json
import shlex
import subprocess
import sys
import time
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parent))
import common # noqa: E402
from common import actor, basic, create_chat, login, request # noqa: E402
ROOT = Path(__file__).resolve().parents[1]
MAX_FAIL_SECONDS = 6.0 # верхняя граница ответа при отказе зависимости
MAX_DEGRADED_SECONDS = 1.5 # верхняя граница ответа при отказе Redis
class Check:
def __init__(self):
self.results = []
def __call__(self, name, condition, detail=""):
self.results.append({"check": name, "ok": bool(condition), "detail": detail})
print(("PASS " if condition else "FAIL ") + name + (" — " + detail if detail else ""), flush=True)
return condition
@property
def ok(self):
return all(r["ok"] for r in self.results)
def run(cmd):
print("$ " + cmd, flush=True)
subprocess.run(shlex.split(cmd), cwd=ROOT, check=True,
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
def wait_ready(timeout=90):
deadline = time.monotonic() + timeout
started = time.monotonic()
while time.monotonic() < deadline:
try:
if request("GET", "/health/ready", timeout=3).status == 200:
return time.monotonic() - started
except OSError:
pass
time.sleep(0.5)
return None
def is_unavailable(r):
return (r.status == 503 and r.json and r.json["error"]["code"] == "unavailable"
and r.json["error"]["request_id"] == r.headers.get("X-Request-Id"))
def main():
p = argparse.ArgumentParser(description=__doc__.split("\n")[0])
p.add_argument("--base-url", default="http://127.0.0.1:8080")
p.add_argument("--stop-redis", default="docker compose stop redis")
p.add_argument("--start-redis", default="docker compose up -d --wait redis")
p.add_argument("--partition-redis",
default="docker network disconnect messenger-lab2_backend messenger-lab2-redis-1",
help="cut API<->Redis network WITHOUT restarting Redis")
p.add_argument("--heal-redis",
default="docker network connect --alias redis messenger-lab2_backend messenger-lab2-redis-1")
p.add_argument("--stop-postgres", default="docker compose stop postgres")
p.add_argument("--start-postgres", default="docker compose up -d --wait postgres")
p.add_argument("--output")
args = p.parse_args()
common.BASE_URL = args.base_url.rstrip("/")
check = Check()
summary = {"base_url": common.BASE_URL, "timings": {}}
alice, bob = actor("dep"), actor("dep")
chat = create_chat(alice, bob)
path = "/api/v1/chats/%s/messages" % chat["id"]
first = request("POST", path, token=alice["_token"], payload={"text": "до отказов"}).json
request("GET", "/api/v1/users/me", token=alice["_token"]) # прогрев кэша
# 1. Redis недоступен
run(args.stop_redis)
try:
r = request("GET", "/api/v1/users/me", token=alice["_token"])
check("redis down: existing token still valid via PostgreSQL", r.status == 200, "%.3fs" % r.elapsed)
summary["timings"]["redis_down_first_request_s"] = round(r.elapsed, 3)
timings = []
for i in range(10):
r = request("POST", path, token=bob["_token"], payload={"text": "redis down %d" % i})
timings.append(r.elapsed)
if r.status != 201:
break
check("redis down: writes succeed", r.status == 201)
check("redis down: bounded latency", max(timings) < MAX_DEGRADED_SECONDS,
"max %.3fs over %d requests" % (max(timings), len(timings)))
summary["timings"]["redis_down_max_write_s"] = round(max(timings), 3)
check("redis down: readiness stays 200 (cache is not critical)",
request("GET", "/health/ready").status == 200)
token = login(bob)
check("redis down: login works", bool(token))
check("redis down: logout works",
request("DELETE", "/api/v1/auth/sessions/current", token=token).status == 204)
check("redis down: revoked token rejected",
request("GET", "/api/v1/users/me", token=token).status == 401)
check("redis down: anonymous rejected", request("GET", "/api/v1/users/me").status == 401)
check("redis down: unknown token rejected",
request("GET", "/api/v1/users/me", token="x" * 43).status == 401)
finally:
run(args.start_redis)
time.sleep(6) # больше CACHE_RETRY_AFTER_SECONDS: API снова пробует Redis
check("redis back: requests ok",
request("GET", "/api/v1/users/me", token=alice["_token"]).status == 200)
# 2. Разрыв связи с живым Redis + logout (замечание ревью №1)
carol = actor("dep")
for _ in range(2): # промах -> запись в кэш, затем попадание
request("GET", "/api/v1/users/me", token=carol["_token"])
run(args.partition_redis)
try:
r = request("DELETE", "/api/v1/auth/sessions/current", token=carol["_token"])
check("redis partition: logout -> 204", r.status == 204, "status %d, %.3fs" % (r.status, r.elapsed))
check("redis partition: revoked token -> 401",
request("GET", "/api/v1/users/me", token=carol["_token"]).status == 401)
finally:
run(args.heal_redis)
# Опрашиваем дольше CACHE_RETRY_AFTER_SECONDS (5 с): после закрытия circuit
# breaker API снова читает Redis, где жила положительная запись этого токена.
statuses = set()
deadline = time.monotonic() + 8
while time.monotonic() < deadline:
statuses.add(request("GET", "/api/v1/users/me", token=carol["_token"]).status)
statuses.add(request("POST", path, token=carol["_token"], payload={"text": "revoked"}).status)
time.sleep(0.25)
check("redis healed (same data): revoked token stays 401 for 8 s", statuses == {401}, str(sorted(statuses)))
check("redis healed: valid token works", request("GET", "/api/v1/users/me", token=alice["_token"]).status == 200)
# 3. PostgreSQL недоступна
run(args.stop_postgres)
try:
check("postgres down: liveness 200", request("GET", "/health/live").status == 200)
r = request("GET", "/health/ready")
check("postgres down: readiness 503 unavailable", is_unavailable(r), "%.3fs" % r.elapsed)
r = request("GET", "/api/v1/users/me")
check("postgres down: anonymous -> 401 (not trusted)", r.status == 401, "status %d" % r.status)
r = request("GET", "/api/v1/users/me", token="y" * 43)
check("postgres down: unknown token is not accepted (503)", is_unavailable(r),
"status %d, %.3fs" % (r.status, r.elapsed))
r = request("POST", path, token=alice["_token"], payload={"text": "должно не записаться"})
check("postgres down: write -> 503 within bound", is_unavailable(r) and r.elapsed < MAX_FAIL_SECONDS,
"status %d, %.3fs" % (r.status, r.elapsed))
summary["timings"]["postgres_down_write_s"] = round(r.elapsed, 3)
r = request("GET", path, token=alice["_token"])
check("postgres down: history read -> 503", is_unavailable(r), "status %d" % r.status)
r = request("POST", "/api/v1/auth/sessions",
headers={"Authorization": basic(alice["username"], alice["_password"])})
check("postgres down: login -> 503 (not 401, not 201)", is_unavailable(r), "status %d" % r.status)
body = json.dumps(r.json, ensure_ascii=False)
check("postgres down: error hides internals",
not any(s in body.lower() for s in ("psycopg", "postgres", "select", "traceback", "5432")))
finally:
run(args.start_postgres)
recovered = wait_ready()
check("postgres back: readiness recovered", recovered is not None,
"%.1fs" % recovered if recovered is not None else "timeout")
summary["timings"]["postgres_recovery_s"] = round(recovered or -1, 2)
r = request("GET", path + "?limit=100", token=alice["_token"])
ok = r.status == 200 and r.json["items"][0] == first
texts = [m["text"] for m in r.json["items"]] if r.status == 200 else []
check("postgres back: same token reads intact history", ok)
check("postgres back: rejected write was not stored", "должно не записаться" not in texts)
summary["checks"] = check.results
summary["passed"] = check.ok
if args.output:
Path(args.output).write_text(json.dumps(summary, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
print(("PASS" if check.ok else "FAIL") + ": dependency failure scenario")
sys.exit(0 if check.ok else 1)
if __name__ == "__main__":
main()
+201
View File
@@ -0,0 +1,201 @@
#!/usr/bin/env python3
"""Конкурентная запись: 10 клиентов x 10 сообщений (перенесено из lab1, Bearer)."""
import argparse
import base64
import json
import threading
import urllib.request
import uuid
from concurrent.futures import ThreadPoolExecutor
from urllib.parse import urlencode
def request(base_url, method, path, token=None, body=None, headers=None):
headers = dict(headers or {})
headers["Accept"] = "application/json"
if token:
headers["Authorization"] = "Bearer " + token
data = None
if body is not None:
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
headers["Content-Type"] = "application/json"
request = urllib.request.Request(
base_url + path,
data=data,
headers=headers,
method=method,
)
with urllib.request.urlopen(request, timeout=10) as response:
return response.status, json.loads(response.read().decode("utf-8"))
def create_user(base_url, name):
username = "race_%s_%s" % (name, uuid.uuid4().hex[:8])
password = "Race-password-" + uuid.uuid4().hex
status, user = request(
base_url,
"POST",
"/api/v1/users",
body={
"username": username,
"display_name": "Race " + name,
"password": password,
},
)
assert status == 201
credential = base64.b64encode((username + ":" + password).encode()).decode()
status, session = request(
base_url,
"POST",
"/api/v1/auth/sessions",
headers={"Authorization": "Basic " + credential},
)
assert status == 201
user["token"] = session["token"]
return user
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"--base-url",
default="http://127.0.0.1:8080",
)
args = parser.parse_args()
base_url = args.base_url.rstrip("/")
users = [
create_user(base_url, str(i))
for i in range(10)
]
owner = users[0]
status, chat = request(
base_url,
"POST",
"/api/v1/chats",
token=owner["token"],
body={
"title": "Concurrent race test",
"member_ids": [user["id"] for user in users],
},
)
assert status == 201
chat_id = chat["id"]
barrier = threading.Barrier(10)
def worker(worker_id):
user = users[worker_id]
created = []
barrier.wait()
for message_id in range(10):
text = "race-%d-%d" % (worker_id, message_id)
status, message = request(
base_url,
"POST",
"/api/v1/chats/%s/messages" % chat_id,
token=user["token"],
body={"text": text},
)
assert status == 201
created.append(message)
return created
with ThreadPoolExecutor(max_workers=10) as executor:
results = list(executor.map(worker, range(10)))
created = [
message
for worker_messages in results
for message in worker_messages
]
assert len(created) == 100
created_ids = {message["id"] for message in created}
created_texts = {message["text"] for message in created}
assert len(created_ids) == 100
assert len(created_texts) == 100
messages = []
seen_cursors = set()
cursor = None
page_limit = 13
while True:
path = (
"/api/v1/chats/%s/messages?limit=%d"
% (chat_id, page_limit)
)
if cursor is not None:
path += "&" + urlencode({"cursor": cursor})
status, page = request(
base_url,
"GET",
path,
token=owner["token"],
)
assert status == 200
page_messages = page["items"]
messages.extend(page_messages)
next_cursor = page["next_cursor"]
if next_cursor is None:
break
assert next_cursor not in seen_cursors, (
"Cursor повторился: возможен бесконечный цикл пагинации"
)
seen_cursors.add(next_cursor)
cursor = next_cursor
assert len(messages) == 100
history_ids = {message["id"] for message in messages}
history_texts = {message["text"] for message in messages}
assert len(history_ids) == 100
assert len(history_texts) == 100
assert history_ids == created_ids
assert history_texts == created_texts
user_ids = {user["id"] for user in users}
assert all(
message["sender_id"] in user_ids
for message in messages
)
print(
"PASS: concurrent write test; "
"10 clients x 10 messages = 100 messages; "
"no lost or duplicate messages"
)
if __name__ == "__main__":
main()
+37
View File
@@ -0,0 +1,37 @@
#!/usr/bin/env python3
"""Минимальное воспроизведение замечания ревью №1 (отзыв токена при разрыве с Redis).
Прогрев кэша -> разрыв сети API<->Redis без рестарта Redis -> logout ->
восстановление связи -> 8 с опроса старого токена (дольше circuit breaker).
Ожидается только 401. По умолчанию — команды docker compose-стенда:
python student-tests/revocation_partition.py --base-url http://127.0.0.1:8080
"""
import argparse, shlex, subprocess, sys, time
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parent))
import common
from common import actor, request
p = argparse.ArgumentParser()
p.add_argument("--base-url", default="http://127.0.0.1:8080")
p.add_argument("--partition", default="docker network disconnect messenger-lab2_backend messenger-lab2-redis-1")
p.add_argument("--heal", default="docker network connect --alias redis messenger-lab2_backend messenger-lab2-redis-1")
args = p.parse_args()
common.BASE_URL = args.base_url.rstrip("/")
ROOT = Path(__file__).resolve().parents[1]
def run(cmd):
subprocess.run(shlex.split(cmd), cwd=ROOT, check=True)
a = actor("repro"); t = a["_token"]
for _ in range(2): request("GET","/api/v1/users/me",token=t)
run(args.partition)
try:
print("logout during partition:", request("DELETE","/api/v1/auth/sessions/current",token=t).status)
finally:
run(args.heal)
seen=set(); end=time.monotonic()+8
while time.monotonic()<end:
seen.add(request("GET","/api/v1/users/me",token=t).status); time.sleep(0.25)
print("revoked token statuses over 8 s after heal:", sorted(seen))
ok = seen == {401}
print("PASS" if ok else "FAIL", ": revoked token never accepted after partition heals")
sys.exit(0 if ok else 1)
+43
View File
@@ -0,0 +1,43 @@
"""Запуск собственных тестов.
python student-tests/run_all.py --base-url http://127.0.0.1:8080
# + истечение сессии на экземпляре с коротким TTL:
python student-tests/run_all.py --expiry-url http://127.0.0.1:8081
# + отказ Redis/PostgreSQL (останавливает контейнеры!):
python student-tests/run_all.py --expiry-url http://127.0.0.1:8081 --with-failures
"""
import argparse
import os
import subprocess
import sys
parser = argparse.ArgumentParser()
parser.add_argument("--base-url", default="http://127.0.0.1:8080")
parser.add_argument("--expiry-url", default=os.environ.get("EXPIRY_BASE_URL", ""))
parser.add_argument("--with-failures", action="store_true",
help="run student-tests/dependency_failure.py (stops redis/postgres)")
parser.add_argument("--failure-args", default="",
help="extra arguments for dependency_failure.py (custom stop/start commands)")
args = parser.parse_args()
env = os.environ.copy()
env["BASE_URL"] = args.base_url.rstrip("/")
if args.expiry_url:
env["EXPIRY_BASE_URL"] = args.expiry_url.rstrip("/")
def step(title, cmd):
print("\n== " + title, flush=True)
subprocess.run(cmd, env=env, check=True)
step("API, auth, concurrency, rollback, expiry tests",
[sys.executable, "-m", "unittest", "discover", "-s", "student-tests", "-p", "test_*.py", "-v"])
step("Concurrent write test", [sys.executable, "student-tests/race.py", "--base-url", args.base_url])
if args.with_failures:
import shlex
step("Dependency failure scenario",
[sys.executable, "student-tests/dependency_failure.py", "--base-url", args.base_url]
+ shlex.split(args.failure_args))
print("\nALL STUDENT TESTS PASSED", flush=True)
+138
View File
@@ -0,0 +1,138 @@
"""Поведенческие тесты API, перенесённые из lab1 и переведённые на Bearer."""
import base64
import json
import unittest
import uuid
from urllib.parse import urlencode
from common import actor, create_chat, request
class ApiBehaviorTests(unittest.TestCase):
def test_malformed_json_returns_400(self):
r = request("POST", "/api/v1/users", raw=b'{"username": ')
self.assertEqual(r.status, 400, r.json)
self.assertIn("request_id", r.json["error"])
self.assertEqual(r.json["error"]["request_id"], r.headers.get("X-Request-Id"))
def test_registration_without_password_returns_400(self):
r = request("POST", "/api/v1/users", payload={
"username": "nopass_" + uuid.uuid4().hex[:10],
"display_name": "No password",
})
self.assertEqual(r.status, 400, r.json)
def test_short_password_returns_400(self):
r = request("POST", "/api/v1/users", payload={
"username": "short_" + uuid.uuid4().hex[:10],
"display_name": "Short",
"password": "elevenchars",
})
self.assertEqual(r.status, 400, r.json)
def test_password_never_returned(self):
r = request("POST", "/api/v1/users", payload={
"username": "secret_" + uuid.uuid4().hex[:10],
"display_name": "Secret",
"password": "Very-secret-password-42",
})
self.assertEqual(r.status, 201, r.json)
self.assertEqual(set(r.json), {"id", "username", "display_name", "created_at"})
def test_duplicate_username_returns_409(self):
payload = {
"username": "duplicate_" + uuid.uuid4().hex[:10],
"display_name": "First User",
"password": "Duplicate-pass-123",
}
self.assertEqual(request("POST", "/api/v1/users", payload=payload).status, 201)
self.assertEqual(request("POST", "/api/v1/users", payload=payload).status, 409)
def test_empty_message_returns_400(self):
owner = actor()
chat = create_chat(owner)
r = request("POST", "/api/v1/chats/%s/messages" % chat["id"],
token=owner["_token"], payload={"text": " "})
self.assertEqual(r.status, 400, r.json)
def test_sender_id_in_body_rejected(self):
owner = actor()
chat = create_chat(owner)
r = request("POST", "/api/v1/chats/%s/messages" % chat["id"], token=owner["_token"],
payload={"text": "hi", "sender_id": owner["id"]})
self.assertEqual(r.status, 400, r.json)
def test_outsider_cannot_access_chat(self):
owner, member, outsider = actor(), actor(), actor()
chat = create_chat(owner, member)
chat_path = "/api/v1/chats/%s" % chat["id"]
self.assertEqual(request("GET", chat_path, token=outsider["_token"]).status, 404)
self.assertEqual(request("GET", chat_path + "/messages", token=outsider["_token"]).status, 404)
r = request("POST", chat_path + "/messages", token=outsider["_token"],
payload={"text": "Unauthorized message"})
self.assertEqual(r.status, 404)
self.assertEqual(request("GET", chat_path, token=member["_token"]).status, 200)
def test_naive_timestamp_cursor_returns_400(self):
owner = actor()
chat = create_chat(owner)
payload = {
"resource_id": chat["id"],
"created_at": "2026-10-02T12:00:00",
"item_id": str(uuid.uuid4()),
}
encoded = base64.urlsafe_b64encode(json.dumps(payload).encode()).decode().rstrip("=")
r = request("GET", "/api/v1/chats/%s/messages?%s" % (chat["id"], urlencode({"cursor": encoded})),
token=owner["_token"])
self.assertEqual(r.status, 400, r.json)
def test_cursor_from_other_chat_returns_400(self):
owner = actor()
chat_a, chat_b = create_chat(owner), create_chat(owner)
for i in range(3):
request("POST", "/api/v1/chats/%s/messages" % chat_a["id"], token=owner["_token"],
payload={"text": "m%d" % i})
page = request("GET", "/api/v1/chats/%s/messages?limit=1" % chat_a["id"], token=owner["_token"]).json
self.assertTrue(page["next_cursor"])
r = request("GET", "/api/v1/chats/%s/messages?%s" % (chat_b["id"], urlencode({"cursor": page["next_cursor"]})),
token=owner["_token"])
self.assertEqual(r.status, 400, r.json)
def test_pagination_returns_all_messages_without_duplicates(self):
owner = actor()
chat = create_chat(owner)
path = "/api/v1/chats/%s/messages" % chat["id"]
expected = []
for index in range(8):
r = request("POST", path, token=owner["_token"], payload={"text": "page-%d" % index})
self.assertEqual(r.status, 201, r.json)
expected.append(r.json["id"])
received, cursor = [], None
while True:
query = {"limit": 3}
if cursor:
query["cursor"] = cursor
page = request("GET", path + "?" + urlencode(query), token=owner["_token"]).json
received.extend(m["id"] for m in page["items"])
cursor = page["next_cursor"]
if cursor is None:
break
self.assertEqual(received, expected)
def test_chat_list_pagination(self):
owner = actor()
created = [create_chat(owner)["id"] for _ in range(5)]
got, cursor = [], None
while True:
q = "?limit=2" + ("&" + urlencode({"cursor": cursor}) if cursor else "")
page = request("GET", "/api/v1/chats" + q, token=owner["_token"]).json
got.extend(c["id"] for c in page["items"])
cursor = page["next_cursor"]
if cursor is None:
break
self.assertEqual(got, created)
if __name__ == "__main__":
unittest.main(verbosity=2)
+109
View File
@@ -0,0 +1,109 @@
"""Аутентификация: Basic только для входа, Bearer для остального, logout."""
import base64
import unittest
import uuid
from common import actor, basic, login, register, request
def assert_challenge(test, r, scheme):
test.assertEqual(r.status, 401, r.json)
test.assertTrue(r.headers.get("WWW-Authenticate", "").startswith(scheme), r.headers.get("WWW-Authenticate"))
test.assertEqual(r.json["error"]["code"], "unauthorized")
class AuthTests(unittest.TestCase):
def test_wrong_password_and_unknown_user_look_the_same(self):
user = register("wp")
wrong = request("POST", "/api/v1/auth/sessions",
headers={"Authorization": basic(user["username"], "Wrong-password-000")})
unknown = request("POST", "/api/v1/auth/sessions",
headers={"Authorization": basic("nouser_" + uuid.uuid4().hex[:10], "Wrong-password-000")})
for r in (wrong, unknown):
assert_challenge(self, r, 'Basic realm="messenger"')
self.assertIn('charset="UTF-8"', r.headers.get("WWW-Authenticate"))
self.assertEqual(wrong.json["error"]["message"], unknown.json["error"]["message"])
def test_malformed_basic_headers(self):
for header in (None, "Basic", "Basic !!!notbase64", "Bearer abc",
"Basic " + base64.b64encode(b"no-colon-here").decode()):
headers = {"Authorization": header} if header else {}
r = request("POST", "/api/v1/auth/sessions", headers=headers)
assert_challenge(self, r, "Basic")
def test_session_shape_and_token_entropy(self):
user = register("shape")
r = request("POST", "/api/v1/auth/sessions",
headers={"Authorization": basic(user["username"], user["_password"])})
self.assertEqual(r.status, 201, r.json)
self.assertEqual(set(r.json), {"token", "token_type", "expires_at", "user"})
self.assertEqual(r.json["token_type"], "Bearer")
token = r.json["token"]
# 32 случайных байта в base64url = 43 символа (256 бит)
self.assertGreaterEqual(len(token), 43)
self.assertNotIn(user["username"], token)
self.assertNotIn(user["id"], token)
self.assertTrue(r.json["expires_at"].endswith("Z"))
self.assertNotEqual(token, login(user), "each login must issue a new token")
def test_password_with_colon_and_unicode(self):
password = "пароль:с:двоеточием-🙂"
user = register("colon", password=password)
token = login(user)
self.assertEqual(request("GET", "/api/v1/users/me", token=token).json["id"], user["id"])
def test_login_with_body_rejected(self):
"""Контракт: вход — только заголовок Basic, без тела. Лишний ввод -> 400, сессии нет."""
user = register("body")
auth = {"Authorization": basic(user["username"], user["_password"])}
cases = [
dict(payload={"unexpected": True}),
dict(payload={}),
dict(raw=b"not json at all"),
dict(raw=b"username=x&password=y", headers={"Content-Type": "application/x-www-form-urlencoded"}),
]
for case in cases:
headers = dict(auth)
headers.update(case.pop("headers", {}))
r = request("POST", "/api/v1/auth/sessions", headers=headers, **case)
self.assertEqual(r.status, 400, (case, r.json))
self.assertEqual(r.json["error"]["code"], "invalid_request")
self.assertNotIn("token", r.json)
# Без тела тот же заголовок работает.
self.assertEqual(request("POST", "/api/v1/auth/sessions", headers=auth).status, 201)
def test_basic_on_business_endpoint_rejected(self):
user = register("basic")
r = request("GET", "/api/v1/users/me",
headers={"Authorization": basic(user["username"], user["_password"])})
assert_challenge(self, r, 'Bearer realm="messenger"')
def test_x_user_id_gives_no_access(self):
user = actor("xuid")
other = actor("xuid")
assert_challenge(self, request("GET", "/api/v1/users/me", headers={"X-User-Id": user["id"]}), "Bearer")
r = request("GET", "/api/v1/users/me", token=user["_token"], headers={"X-User-Id": other["id"]})
self.assertEqual(r.json["id"], user["id"])
def test_unknown_and_garbage_tokens(self):
for token in ("x" * 43, "", "a b", "z" * 1000):
r = request("GET", "/api/v1/users/me", headers={"Authorization": "Bearer " + token})
assert_challenge(self, r, "Bearer")
def test_logout_revokes_only_current_session(self):
user = register("logout")
t1, t2 = login(user), login(user)
# Прогреваем кэш Redis для t1, чтобы проверить инвалидацию кэша.
self.assertEqual(request("GET", "/api/v1/users/me", token=t1).status, 200)
self.assertEqual(request("GET", "/api/v1/users/me", token=t1).status, 200)
r = request("DELETE", "/api/v1/auth/sessions/current", token=t1)
self.assertEqual(r.status, 204)
self.assertIsNone(r.json)
assert_challenge(self, request("GET", "/api/v1/users/me", token=t1), "Bearer")
assert_challenge(self, request("DELETE", "/api/v1/auth/sessions/current", token=t1), "Bearer")
self.assertEqual(request("GET", "/api/v1/users/me", token=t2).status, 200)
if __name__ == "__main__":
unittest.main(verbosity=2)
+80
View File
@@ -0,0 +1,80 @@
"""Гонка регистрации одинакового username и rollback составной операции."""
import threading
import unittest
import uuid
from concurrent.futures import ThreadPoolExecutor
from common import actor, basic, request
PARALLEL = 16
class RegistrationRaceTests(unittest.TestCase):
def test_same_username_parallel_registration(self):
username = "race_" + uuid.uuid4().hex[:12]
barrier = threading.Barrier(PARALLEL)
def attempt(i):
password = "Race-password-%02d-%s" % (i, uuid.uuid4().hex[:6])
barrier.wait()
r = request("POST", "/api/v1/users", timeout=30, payload={
"username": username, "display_name": "Racer %d" % i, "password": password,
})
return r.status, r.json, password
with ThreadPoolExecutor(max_workers=PARALLEL) as pool:
results = list(pool.map(attempt, range(PARALLEL)))
statuses = sorted(s for s, _, _ in results)
self.assertEqual(statuses.count(201), 1, statuses)
self.assertEqual(statuses.count(409), PARALLEL - 1, statuses)
for status, body, _ in results:
if status == 409:
self.assertEqual(body["error"]["code"], "conflict")
# Победитель входит своим паролем; пароли проигравших не подходят.
winner = next(r for r in results if r[0] == 201)
loser = next(r for r in results if r[0] == 409)
ok = request("POST", "/api/v1/auth/sessions", headers={"Authorization": basic(username, winner[2])})
self.assertEqual(ok.status, 201)
self.assertEqual(ok.json["user"]["id"], winner[1]["id"])
bad = request("POST", "/api/v1/auth/sessions", headers={"Authorization": basic(username, loser[2])})
self.assertEqual(bad.status, 401)
class ChatRollbackTests(unittest.TestCase):
def _chat_ids(self, owner):
r = request("GET", "/api/v1/chats?limit=100", token=owner["_token"])
self.assertEqual(r.status, 200)
return [c["id"] for c in r.json["items"]]
def test_unknown_member_rolls_back_whole_chat(self):
"""Чат вставляется первым, затем участники по порядку (сначала сам владелец).
Неизвестный участник вызывает нарушение внешнего ключа на 2-й строке
chat_members. Без транзакции у владельца остался бы чат с одним
участником; с транзакцией не остаётся ничего.
"""
owner, member = actor("rb"), actor("rb")
before = self._chat_ids(owner)
r = request("POST", "/api/v1/chats", token=owner["_token"], payload={
"title": "Must roll back",
"member_ids": [owner["id"], member["id"], str(uuid.uuid4())],
})
self.assertEqual(r.status, 400, r.json)
self.assertEqual(self._chat_ids(owner), before, "partial chat is visible after failed creation")
self.assertEqual(self._chat_ids(member), [], "partial membership is visible to other member")
def test_duplicate_and_missing_caller_rejected(self):
owner, member = actor("rb"), actor("rb")
for ids in ([owner["id"], owner["id"]], [member["id"]]):
r = request("POST", "/api/v1/chats", token=owner["_token"],
payload={"title": "bad", "member_ids": ids})
self.assertEqual(r.status, 400, r.json)
self.assertEqual(self._chat_ids(owner), [])
if __name__ == "__main__":
unittest.main(verbosity=2)
+49
View File
@@ -0,0 +1,49 @@
"""Истечение сессии при коротком SESSION_TTL_SECONDS.
Нужен отдельный экземпляр API с коротким TTL (compose-профиль ttl, порт 8081):
docker compose --profile ttl up -d api-short-ttl
EXPIRY_BASE_URL=http://127.0.0.1:8081 python -m unittest discover -s student-tests -p test_expiry.py
Без EXPIRY_BASE_URL тест пропускается (основной стенд работает с TTL >= 300).
"""
import datetime as dt
import os
import time
import unittest
from common import basic, register, request
EXPIRY_BASE_URL = os.environ.get("EXPIRY_BASE_URL", "").rstrip("/")
@unittest.skipUnless(EXPIRY_BASE_URL, "set EXPIRY_BASE_URL to the short-TTL API instance")
class ExpiryTests(unittest.TestCase):
def test_session_expires_even_when_cached(self):
user = register("exp", base_url=EXPIRY_BASE_URL)
r = request("POST", "/api/v1/auth/sessions", base_url=EXPIRY_BASE_URL,
headers={"Authorization": basic(user["username"], user["_password"])})
self.assertEqual(r.status, 201, r.json)
token = r.json["token"]
expires_at = dt.datetime.fromisoformat(r.json["expires_at"].replace("Z", "+00:00"))
ttl = (expires_at - dt.datetime.now(dt.timezone.utc)).total_seconds()
self.assertLess(ttl, 30, "EXPIRY_BASE_URL must point to a short-TTL instance")
# Два запроса подряд: первый кладёт сессию в Redis, второй читает из кэша.
for _ in range(2):
self.assertEqual(request("GET", "/api/v1/users/me", token=token, base_url=EXPIRY_BASE_URL).status, 200)
time.sleep(max(ttl, 0) + 1.5)
r = request("GET", "/api/v1/users/me", token=token, base_url=EXPIRY_BASE_URL)
self.assertEqual(r.status, 401, r.json)
self.assertTrue(r.headers.get("WWW-Authenticate", "").startswith("Bearer"))
r = request("DELETE", "/api/v1/auth/sessions/current", token=token, base_url=EXPIRY_BASE_URL)
self.assertEqual(r.status, 401, "logout with expired token must be 401")
# Новый вход после истечения работает.
r = request("POST", "/api/v1/auth/sessions", base_url=EXPIRY_BASE_URL,
headers={"Authorization": basic(user["username"], user["_password"])})
self.assertEqual(r.status, 201)
if __name__ == "__main__":
unittest.main(verbosity=2)
+149
View File
@@ -0,0 +1,149 @@
"""Отзыв сессии при сбое инвалидации кэша (регрессия замечания ревью №1).
Сценарий ревью: прогретый кэш -> связь API с Redis разорвана -> logout (204)
-> связь восстановлена с ТЕМ ЖЕ Redis, без его рестарта, положительная запись
отозванного токена ещё жива. Ожидание: токен отклоняется сразу, а не через
SESSION_CACHE_TTL_SECONDS.
Redis здесь заменён управляемой заглушкой с тем же интерфейсом, что и
SessionCache (get/put/revoke): «разрыв» = операции падают, но данные заглушки
сохраняются — ровно как у живого Redis за сетевым разрывом. PostgreSQL —
настоящая (нужен DATABASE_URL/DATABASE_URL_FILE, иначе тест пропускается):
make test-storage
"""
import os
import sys
import time
import unittest
import uuid
from datetime import datetime, timezone
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
HAS_DB = bool(os.environ.get("DATABASE_URL") or os.environ.get("DATABASE_URL_FILE"))
class PartitionableCache:
"""Кэш, который «помнит» данные во время разрыва, но недоступен для API."""
def __init__(self):
self.data = {}
self.partitioned = False
def get(self, digest):
from src.sessions import REVOKED
if self.partitioned:
return None
value = self.data.get(digest)
if value is None:
return None
if value == REVOKED:
return REVOKED
user, expires_at = value
return (user, expires_at) if expires_at > datetime.now(timezone.utc) else None
def put(self, digest, user, expires_at):
if not self.partitioned:
self.data.setdefault(digest, (user, expires_at)) # SET NX
def revoke(self, digest):
from src.sessions import REVOKED
if self.partitioned:
return False
self.data[digest] = REVOKED
return True
@unittest.skipUnless(HAS_DB, "DATABASE_URL is not configured")
class SessionRevocationCacheTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
from src.config import load_settings
from src.db import create_pool, wait_and_migrate
from src.security import hash_password
from src.storage import Storage
cls.settings = load_settings()
wait_and_migrate(cls.settings)
cls.pool = create_pool(cls.settings)
cls.pool.wait(timeout=10)
cls.storage = Storage(cls.pool)
cls.user = cls.storage.create_user("rvk_" + uuid.uuid4().hex[:12], "Revoke",
hash_password("Revoke-test-password"))
@classmethod
def tearDownClass(cls):
cls.pool.close()
def service(self, cache):
from src.sessions import SessionService
return SessionService(self.storage, cache, self.settings)
def pending(self, digest):
with self.pool.connection() as conn:
return conn.execute("SELECT count(*) FROM session_cache_invalidations WHERE token_hash = %s",
(digest,)).fetchone()[0]
def warm(self, svc, cache, token):
from src.security import token_digest
self.assertEqual(svc.resolve(token).id, self.user.id)
self.assertIsInstance(cache.data.get(token_digest(token)), tuple, "cache was not warmed")
def test_revoked_token_rejected_after_partition_heals(self):
from src.security import token_digest
cache = PartitionableCache()
svc = self.service(cache)
token, _ = svc.create(self.user)
digest = token_digest(token)
self.warm(svc, cache, token)
cache.partitioned = True
self.assertTrue(svc.revoke(token), "logout must succeed (PostgreSQL is the source of truth)")
self.assertIsInstance(cache.data[digest], tuple, "precondition: stale positive entry survived")
self.assertEqual(self.pending(digest), 1, "invalidation debt must be committed with revoked_at")
self.assertIsNone(svc.resolve(token), "during partition")
cache.partitioned = False # тот же «Redis», данные не потеряны
self.assertIsNone(svc.resolve(token), "immediately after partition heals")
time.sleep(svc.RECHECK_SECONDS + 0.1)
self.assertIsNone(svc.resolve(token), "after reconciliation")
self.assertEqual(cache.data[digest], "revoked", "reconciliation must write the tombstone")
self.assertEqual(self.pending(digest), 0, "debt must be cleared after the tombstone")
# После погашения долга кэшу снова доверяют: другой токен обслуживается из кэша.
other, _ = svc.create(self.user)
self.warm(svc, cache, other)
def test_debt_survives_api_restart(self):
"""Процесс, выполнивший logout, умер до восстановления связи — новый процесс не доверяет кэшу."""
from src.security import token_digest
cache = PartitionableCache()
svc = self.service(cache)
token, _ = svc.create(self.user)
self.warm(svc, cache, token)
cache.partitioned = True
self.assertTrue(svc.revoke(token))
del svc # «рестарт API»: состояние процесса потеряно
cache.partitioned = False
restarted = self.service(cache)
self.assertIsNone(restarted.resolve(token))
self.assertEqual(cache.data[token_digest(token)], "revoked")
def test_normal_logout_leaves_no_debt(self):
from src.security import token_digest
cache = PartitionableCache()
svc = self.service(cache)
token, _ = svc.create(self.user)
self.warm(svc, cache, token)
self.assertTrue(svc.revoke(token))
self.assertEqual(cache.data[token_digest(token)], "revoked")
self.assertEqual(self.pending(token_digest(token)), 0)
self.assertIsNone(svc.resolve(token))
self.assertFalse(svc.revoke(token), "second logout must fail")
if __name__ == "__main__":
unittest.main(verbosity=2)
+101
View File
@@ -0,0 +1,101 @@
"""Rollback на уровне хранилища с внедрённым сбоем (нужен прямой доступ к БД).
Сбой вызывается ПОСЛЕ того, как строки chats и chat_members уже вставлены
внутри транзакции. Проверяем, что в БД не осталось ни чата, ни участников.
Запуск внутри compose-сети (БД наружу не публикуется):
docker compose run --rm --no-deps -v "$PWD/student-tests:/app/student-tests:ro" \
api python -m unittest discover -s student-tests -p test_storage_rollback.py -v
Без DATABASE_URL/DATABASE_URL_FILE тест пропускается.
"""
import os
import sys
import unittest
import uuid
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
HAS_DB = bool(os.environ.get("DATABASE_URL") or os.environ.get("DATABASE_URL_FILE"))
class InjectedFailure(RuntimeError):
pass
@unittest.skipUnless(HAS_DB, "DATABASE_URL is not configured")
class StorageRollbackTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
from src.config import load_settings
from src.db import create_pool, wait_and_migrate
from src.security import hash_password
from src.storage import Storage
settings = load_settings()
wait_and_migrate(settings)
cls.pool = create_pool(settings)
cls.pool.wait(timeout=10)
cls.storage = Storage(cls.pool)
h = hash_password("Rollback-test-password")
cls.users = [
cls.storage.create_user("rbk_" + uuid.uuid4().hex[:12], "Rollback", h)
for _ in range(3)
]
@classmethod
def tearDownClass(cls):
cls.pool.close()
def count(self, sql, params):
with self.pool.connection() as conn:
return conn.execute(sql, params).fetchone()[0]
def test_failure_after_inserts_leaves_nothing(self):
title = "rollback-" + uuid.uuid4().hex
original = self.storage._insert_members
seen = {}
def insert_then_fail(conn, chat_id, member_ids):
original(conn, chat_id, member_ids)
# Внутри транзакции строки видны — значит вставка действительно была.
seen["chats"] = conn.execute("SELECT count(*) FROM chats WHERE title = %s", (title,)).fetchone()[0]
seen["members"] = conn.execute("SELECT count(*) FROM chat_members WHERE chat_id = %s", (chat_id,)).fetchone()[0]
seen["chat_id"] = chat_id
raise InjectedFailure("simulated crash between statements")
self.storage._insert_members = insert_then_fail
try:
with self.assertRaises(InjectedFailure):
self.storage.create_chat(title, [u.id for u in self.users])
finally:
self.storage._insert_members = original
self.assertEqual(seen["chats"], 1)
self.assertEqual(seen["members"], 3)
self.assertEqual(self.count("SELECT count(*) FROM chats WHERE title = %s", (title,)), 0)
self.assertEqual(self.count("SELECT count(*) FROM chat_members WHERE chat_id = %s", (seen["chat_id"],)), 0)
def test_no_orphan_chats_in_database(self):
orphans = self.count(
"SELECT count(*) FROM chats c WHERE NOT EXISTS "
"(SELECT 1 FROM chat_members m WHERE m.chat_id = c.id)", ())
self.assertEqual(orphans, 0)
def test_migrations_are_idempotent(self):
from src.config import load_settings
from src.db import apply_migrations
self.assertEqual(apply_migrations(load_settings()), [])
self.assertEqual(self.count("SELECT count(*) FROM schema_migrations WHERE version = %s", ("001_init",)), 1)
def test_passwords_stored_as_argon2id(self):
with self.pool.connection() as conn:
stored = conn.execute("SELECT password_hash FROM users WHERE id = %s",
(self.users[0].id,)).fetchone()[0]
self.assertTrue(stored.startswith("$argon2id$"), stored[:10])
self.assertNotIn("Rollback-test-password", stored)
if __name__ == "__main__":
unittest.main(verbosity=2)