forked from mtusi2026/mtusi2026lab2
Compare commits
2
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
7e8e18be16 | ||
|
|
43daf18d04 |
+14
-3
@@ -1,11 +1,22 @@
|
|||||||
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
|
# 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_HOST=0.0.0.0
|
||||||
APP_PORT=8080
|
APP_PORT=8080
|
||||||
APP_ENV=lab
|
APP_ENV=lab
|
||||||
SESSION_TTL_SECONDS=3600
|
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
|
DATABASE_URL_FILE=/run/secrets/database_url
|
||||||
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
|
# Источник истины для сессий — PostgreSQL; Redis — кэш проверок токена
|
||||||
SESSION_STORE=postgres
|
SESSION_STORE=postgres
|
||||||
CACHE_URL_FILE=/run/secrets/cache_url
|
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
|
||||||
|
|||||||
@@ -1,14 +1,14 @@
|
|||||||
## Лабораторная 2
|
## Лабораторная 2
|
||||||
|
|
||||||
Автор / группа: TODO
|
Автор / группа: Попов Константин Дмитриевич, БВТ2303
|
||||||
Целевая оценка (3/4/5): TODO
|
Целевая оценка (3/4/5): 4
|
||||||
Трек 5, если заявлен: TODO
|
Трек 5, если заявлен: не заявлен
|
||||||
|
|
||||||
Что реализовано и что перенесено: TODO
|
Что реализовано и что перенесено: перенесён API lab1 (модели, ошибки, курсоры, Dockerfile, тесты); хранилище — PostgreSQL с миграциями; Argon2id, Basic → opaque Bearer-сессия с TTL и logout; Redis — кэш проверок сессии с обходом при отказе. Подробно — REPORT.md, «Архитектура и решения».
|
||||||
Команды запуска из чистого clone: TODO
|
Команды запуска из чистого clone: `python scripts/init_secrets.py`, `cp .env.example .env`, `docker compose --env-file .env up -d --build --wait` (REPORT.md, «Запуск из чистого clone»).
|
||||||
Результаты проверок и ссылка на REPORT.md: TODO
|
Результаты проверок и ссылка на REPORT.md: smoke, persistence, 32 собственных теста, отзыв при разрыве с Redis, race, отказ Redis/БД, EXPLAIN — evidence/, таблицы в REPORT.md.
|
||||||
Ограничения / известные ошибки: TODO
|
Ограничения / известные ошибки: один host/БД/Redis; при сбое инвалидации кэша другие реплики перестают доверять кэшу не позже чем через 1 с; HTTP только для локального стенда (REPORT.md, «Ограничения»). Исправления по ревью — REPORT.md, «Исправления по ревью».
|
||||||
Источники и использование ИИ: TODO
|
Источники и использование ИИ: см. шапку REPORT.md.
|
||||||
|
|
||||||
- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
|
- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
|
||||||
- [ ] Контракт и публичные тесты не ослаблены.
|
- [ ] Контракт и публичные тесты не ослаблены.
|
||||||
|
|||||||
+29
@@ -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"]
|
||||||
@@ -4,7 +4,7 @@ CA_FILE ?=
|
|||||||
ACTION_SCRIPT ?=
|
ACTION_SCRIPT ?=
|
||||||
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
|
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:
|
help:
|
||||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
|
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
|
||||||
@@ -24,3 +24,41 @@ load:
|
|||||||
test-persistence:
|
test-persistence:
|
||||||
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
|
@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)
|
$(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"
|
||||||
|
|||||||
@@ -1,37 +1,228 @@
|
|||||||
# Отчёт — лабораторная 2
|
# Отчёт — лабораторная 2
|
||||||
|
|
||||||
- Автор, группа: TODO
|
- Автор, группа: Попов Константин Дмитриевич, группа БВТ2303
|
||||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
- Целевая оценка: **4**; трек 5 не заявляется
|
||||||
- Commit/PR: TODO после публикации
|
- 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
|
## Запуск из чистого 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 | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||||
| --- | --- | --- | --- |
|
| --- | --- | --- | --- |
|
||||||
| Публичный smoke | make test | TODO | TODO |
|
| Публичный smoke | `make test` | `PASS: lab2 public API scenario` | `evidence/smoke.txt` |
|
||||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
| Структура/контракт | `make check`, `make validate` | оба PASS | `evidence/check.txt` |
|
||||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
| Данные и действующие сессии переживают рестарт API и хранилищ | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS: persistence preserved confirmed data and existing session` — тот же токен читает те же сообщения | `evidence/persistence.txt` |
|
||||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
| 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
@@ -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
|
||||||
@@ -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.
|
||||||
@@ -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.
@@ -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."
|
||||||
|
}
|
||||||
@@ -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.
|
||||||
@@ -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
|
||||||
@@ -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]
|
||||||
@@ -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.
|
||||||
@@ -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
|
||||||
@@ -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);
|
||||||
@@ -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
|
||||||
@@ -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()
|
||||||
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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'
|
||||||
@@ -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),
|
||||||
|
)
|
||||||
@@ -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
@@ -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)
|
||||||
@@ -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()
|
||||||
@@ -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]
|
||||||
@@ -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
@@ -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
@@ -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
|
||||||
@@ -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
|
||||||
@@ -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()
|
||||||
@@ -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()
|
||||||
@@ -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)
|
||||||
@@ -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)
|
||||||
@@ -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)
|
||||||
@@ -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)
|
||||||
@@ -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)
|
||||||
@@ -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)
|
||||||
@@ -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)
|
||||||
@@ -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)
|
||||||
Reference in New Issue
Block a user