ЛР 2 - БВТ2304 - Осипов Артём - на 4 #146
@@ -18,3 +18,5 @@ __pycache__
|
||||
node_modules
|
||||
evidence
|
||||
.DS_Store
|
||||
.venv
|
||||
venv
|
||||
|
||||
+29
@@ -0,0 +1,29 @@
|
||||
FROM python:3.12-slim
|
||||
|
||||
WORKDIR /app
|
||||
ENV PYTHONPATH=/app
|
||||
|
||||
RUN apt-get update && apt-get install -y --no-install-recommends \
|
||||
make \
|
||||
curl \
|
||||
&& rm -rf /var/lib/apt/lists/*
|
||||
|
||||
RUN groupadd -r appgroup && useradd -r -g appgroup appuser
|
||||
|
||||
COPY requirements.txt requirements-dev.txt ./
|
||||
RUN pip install --no-cache-dir -r requirements.txt -r requirements-dev.txt
|
||||
|
||||
COPY src/ ./src/
|
||||
COPY alembic.ini ./
|
||||
COPY alembic/ ./alembic/
|
||||
COPY tests/ ./tests/
|
||||
COPY scripts/ ./scripts/
|
||||
COPY contracts/ ./contracts/
|
||||
COPY Makefile lab.json ./
|
||||
|
||||
RUN chown -R appuser:appgroup /app
|
||||
|
||||
USER appuser
|
||||
|
||||
# Exec-форма для корректного получения SIGTERM
|
||||
CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8080"]
|
||||
@@ -24,3 +24,6 @@ load:
|
||||
test-persistence:
|
||||
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
|
||||
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
test-own:
|
||||
bash scripts/test_own.sh
|
||||
@@ -1,105 +1,17 @@
|
||||
# Лабораторная 2. PostgreSQL, сессии и Redis/Valkey
|
||||
|
||||
Перенести состояние в постоянное хранилище и связать запросы с аутентифицированным пользователем. Подтверждённые сообщения и действующие сессии переживают перезапуск.
|
||||
---
|
||||
|
||||
Это **skeleton**, а не готовый сервер. Здесь есть задание, контракт и публичные проверки. Реализацию приложения, Dockerfile и требуемую инфраструктуру пишет студент. Язык и framework свободные; UI не обязателен.
|
||||
## Реализация студента (lab2)
|
||||
|
||||
[Карта курса](COURSE.md) · [Процесс fork/PR](CONTRIBUTING.md) · [OpenAPI](contracts/openapi.json) · [Семантика API](contracts/README.md) · [Проверки](tests/README.md) · [Отчёт](REPORT.md) · [Примеры JSON](contracts/examples.json) · [Памятка преподавателю](MAINTAINERS.md)
|
||||
|
||||
## Откуда начинаем
|
||||
|
||||
Перенесите собственный минимум lab1. Изменения API: password при регистрации, Basic для создания сессии, Bearer вместо X-User-Id для бизнес-запросов.
|
||||
|
||||
**Архитектура:** Клиент → API → PostgreSQL; на 4 появляется Redis ИЛИ Valkey для сессий/кэша.
|
||||
|
||||
## Что сделать
|
||||
|
||||
1. Опишите таблицы, ограничения, индексы и транзакционные границы до написания запросов. Добавьте версионируемые миграции.
|
||||
2. Перенесите пользователей, чаты, членство и сообщения в PostgreSQL. Не используйте SQLite как замену PostgreSQL в принимаемом стенде.
|
||||
3. Реализуйте регистрацию с password KDF, вход через Basic, opaque Bearer-сессию, expiry и logout. Действующие сессии тоже должны сохраняться.
|
||||
4. Подготовьте единый локальный запуск API и БД (Compose рекомендуется уже здесь), подключите именованные volumes.
|
||||
5. Пройдите smoke и тест полного перезапуска. На 4 добавьте Redis/Valkey с конкретной ролью и повторите эксперимент отказа.
|
||||
|
||||
## Оценка «3»: работающий минимум
|
||||
|
||||
- Минимум lab1 сохранён с объявленным переходом на новую аутентификацию. Все обязательные данные и ещё действующие сессии переживают рестарт API и хранилищ без удаления volumes.
|
||||
- PostgreSQL содержит пользователей, чаты, участников и сообщения. Есть первичные/внешние ключи, уникальность username и миграции с нуля. Составная операция создания чата выполняется атомарно.
|
||||
- Basic применяется только на POST /auth/sessions, остальные endpoint требуют Bearer. Есть срок жизни сессии и отзыв; X-User-Id не даёт доступ. Пароли уже хешируются password KDF.
|
||||
- make test и make test-persistence ACTION_SCRIPT=scripts/restart.sh проходят. Миграции повторно запускаются без дублирования данных. Secrets/volumes не попадают в Git.
|
||||
|
||||
## Оценка «4»: уровень стажёра/джуна
|
||||
|
||||
Весь уровень 3 **и все** пункты ниже:
|
||||
|
||||
- Redis ИЛИ Valkey реально используется для сессий с TTL либо осмысленного кэша. Опишите источник истины, политику expiry и инвалидации. Если это единственное хранилище сессий, включите persistence, выдерживающее проверяемый рестарт; один TTL не сохраняет данные.
|
||||
- Используются параметризованные запросы/безопасный ORM, ограниченный connection pool и таймауты. Проверены гонка регистрации одинакового username и rollback составной операции.
|
||||
- Индекс истории обоснован запросом и EXPLAIN (ANALYZE, BUFFERS) на ≥10 000 сообщениях; пагинация не использует полный scan всей истории на каждую страницу.
|
||||
- Есть автоматическая проверка expiry при коротком SESSION_TTL_SECONDS, logout, неверного пароля и недоступности Redis/БД. При потере сервиса приложение возвращает ограниченную ошибку/корректно обходит кэш, не принимает запрос от анонимного пользователя как доверенный.
|
||||
|
||||
## Оценка «5»: исследование и доказанный результат
|
||||
|
||||
Весь уровень 4 **и один законченный трек на выбор**. Приведите гипотезу, повторяемую методику, результаты и ограничения.
|
||||
|
||||
**Трек 1. Согласованность кэша.** Покажите на конкурентном сценарии stale read или cache stampede, реализуйте защиту и измерьте число SQL-запросов/latency до и после. Докажите read-after-write из контракта и восстановление после рестарта кэша; одной установки Redis недостаточно.
|
||||
|
||||
**Трек 2. План запроса и восстановление.** Исследуйте ≥100 000 сообщений с неравномерными размерами чатов, сравните ≥2 индекса/запроса и стоимость записи. Сделайте backup → восстановление в новое хранилище → сверку количества и выбранных сообщений. Обсудите время восстановления и границы потери данных.
|
||||
|
||||
## Как начать и проверить
|
||||
Работающая реализация лабораторной: FastAPI + PostgreSQL 16 + Valkey (кэш сессий), миграции Alembic, пароли Argon2id. Подробности, схема, результаты EXPLAIN и ограничения в [REPORT.md](REPORT.md).
|
||||
|
||||
```sh
|
||||
# Работает прямо в skeleton, Python 3.9+; приложение не запускается:
|
||||
make check
|
||||
|
||||
# После реализации запустите свой сервер/стенд по REPORT.md.
|
||||
# По умолчанию тест использует http://localhost:8080.
|
||||
make test
|
||||
cp .env.example .env
|
||||
docker compose up -d --build # db -> migrate -> app, valkey
|
||||
make test # публичный smoke
|
||||
make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
make test-own # собственные тесты (pip install pytest httpx)
|
||||
bash scripts/explain_history.sh # EXPLAIN (ANALYZE, BUFFERS) на 24 000 сообщений
|
||||
```
|
||||
|
||||
`.env.example`, `compose.example.yaml` и `contracts/infrastructure.json` описывают настройки и роли компонентов. **compose.example.yaml — список ролей с пустым services, не запускаемый стенд.** Реализуйте свой `compose.yaml`/`stack.yaml`, закрепите версии образов, заполните локальный `.env` и опишите bootstrap/миграции. Все зависимости поднимаются из этого репозитория; ссылка «у меня БД уже установлена» не заменяет воспроизводимость.
|
||||
|
||||
```sh
|
||||
# Compose-вариант после реализации:
|
||||
docker compose --env-file .env config --quiet
|
||||
docker compose --env-file .env up -d --build
|
||||
# Дождитесь /health/ready; затем make test.
|
||||
# Для Swarm укажите эквивалентные build/push/deploy-команды в REPORT.md.
|
||||
```
|
||||
|
||||
|
||||
Примеры запросов доступны в `examples/requests.http`, примеры JSON — в `contracts/examples.json`. Для полной проверки схемы (по желанию локально; CI делает её автоматически):
|
||||
|
||||
```sh
|
||||
python3 -m venv .venv
|
||||
.venv/bin/python -m pip install -r requirements-dev.txt
|
||||
make validate PYTHON=.venv/bin/python
|
||||
```
|
||||
|
||||
Smoke не выставляет оценку автоматически. Проверку сохранности/отказов запускайте явно по [tests/README.md](tests/README.md), остальные доказательства приведите в отчёте.
|
||||
|
||||
## Сценарий защиты
|
||||
|
||||
1. Применить миграции к пустому volume, создать пользователей, войти, отправить сообщение.
|
||||
2. Запустить persistence-сценарий: он держит токен только в памяти тестового процесса; action script перезапускает API и все используемые хранилища, сохраняя volumes.
|
||||
3. После готовности тот же токен читает те же данные; после logout — 401. Повторить с отдельным коротким TTL для проверки expiry.
|
||||
4. Для 4: показать роль Redis/Valkey, план SQL и ошибку зависимости. Для 5: выполнить выбранный эксперимент.
|
||||
|
||||
## Что должно быть в PR
|
||||
|
||||
Исходники, Dockerfile, миграции, compose.yaml либо эквивалентный воспроизводимый запуск, scripts/restart.sh, собственные тесты и отчёт.
|
||||
|
||||
Заполните `REPORT.md` и [шаблон PR](.github/pull_request_template.md), укажите целевую оценку/трек. Не меняйте обязательный контракт и публичные tests ради зелёного результата. Сохраняйте возможности предыдущих лабораторных в пределах [объявленных переходов](COURSE.md).
|
||||
|
||||
## Вопросы на защите
|
||||
|
||||
- Что подтверждает COMMIT и какие гарантии зависят от настройки durability?
|
||||
- Где хранятся сессии и что будет после flush/restart Redis?
|
||||
- Чем аутентификация отличается от доступа к конкретному чату?
|
||||
- Почему hash пароля и быстрый checksum имеют разные задачи?
|
||||
|
||||
## Первичные материалы
|
||||
|
||||
- [PostgreSQL transactions](https://www.postgresql.org/docs/current/tutorial-transactions.html)
|
||||
- [PostgreSQL EXPLAIN](https://www.postgresql.org/docs/current/using-explain.html)
|
||||
- [Valkey persistence](https://valkey.io/topics/persistence/)
|
||||
- [Redis persistence](https://redis.io/docs/latest/operate/oss_and_stack/management/persistence/)
|
||||
- [Basic authentication](https://www.rfc-editor.org/info/rfc7617/)
|
||||
Целевая оценка: **4**. Собственные тесты лежат в `tests_own/`, скрипты в `scripts/`.
|
||||
|
||||
@@ -1,37 +1,173 @@
|
||||
# Отчёт — лабораторная 2
|
||||
# Отчёт по лабораторной работе №2: PostgreSQL, сессии и Valkey
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
## Целевая оценка
|
||||
|
||||
## Запуск из чистого clone
|
||||
**4** (уровень стажёра/джуна): весь уровень 3 плюс Valkey в роли кэша сессий, ограниченный пул и таймауты БД, проверка гонки регистрации и отказов зависимостей, обоснованный индекс истории с `EXPLAIN (ANALYZE, BUFFERS)` на 24 000 сообщений, собственные автотесты.
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
## Архитектура
|
||||
|
||||
## Архитектура и решения
|
||||
```
|
||||
Клиент -> API (FastAPI, uvicorn) -> PostgreSQL 16 (источник истины)
|
||||
-> Valkey 8 (кэш сессий, опциональная зависимость)
|
||||
```
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
| Компонент | Выбор |
|
||||
|---|---|
|
||||
| API | FastAPI, SQLAlchemy 2.0 (async) + asyncpg |
|
||||
| БД | PostgreSQL 16, именованный volume `postgres_data` |
|
||||
| Миграции | Alembic, отдельный одноразовый сервис `migrate` в Compose |
|
||||
| Хеширование паролей | Argon2id (`argon2-cffi`) |
|
||||
| Кэш | Valkey 8 (`valkey/valkey:8.0-alpine`), клиент `redis-py` |
|
||||
|
||||
## Доказательства критериев
|
||||
Состав стенда: `db`, `valkey`, `migrate`, `app` (`docker-compose.yaml`). Порядок запуска: `db` healthy -> `migrate` завершился с кодом 0 -> `app`. `valkey` для `app` мягкая зависимость: API обязан работать и без него.
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
## Схема БД
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
- `users(id uuid PK, username UNIQUE, display_name, password_hash, created_at)`.
|
||||
- `sessions(id uuid PK, user_id FK -> users ON DELETE CASCADE, token UNIQUE, expires_at, created_at)`.
|
||||
- `chats(id uuid PK, title, created_at)`.
|
||||
- `chat_members(chat_id FK, user_id FK, PK(chat_id, user_id))`.
|
||||
- `messages(id uuid PK, chat_id FK, sender_id FK, text, created_at)`, индекс `ix_messages_chat_created_id (chat_id, created_at, id)`.
|
||||
|
||||
## Эксперименты и отказы
|
||||
Миграции версионируются в `alembic/versions/`:
|
||||
1. `d74c0ccadc85`: начальные таблицы;
|
||||
2. `b7e1f3a9c2d4`: составной индекс истории вместо двух одноколоночных.
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
`alembic upgrade head` разворачивает схему с нуля; повторный запуск ничего не дублирует. `DATABASE_URL` берётся из окружения.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
**Транзакционные границы.** Создание чата (проверка участников, `INSERT chats`, `INSERT chat_members`) выполняется в одной транзакции: либо чат и все участники записаны, либо ничего. Регистрация и вход тоже по одной транзакции на запрос.
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
## Аутентификация и сессии
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
- **Регистрация:** `POST /api/v1/users`, пароль 12-128 символов. Хеш Argon2id, пароль в ответах не возвращается. Уникальность username обеспечивает ограничение `UNIQUE`; при гонке второй `INSERT` получает `IntegrityError`, ответ `409`.
|
||||
- **Почему не bcrypt.** bcrypt учитывает только первые 72 байта пароля. Контракт допускает пароль до 128 символов (до 512 байт в UTF-8), поэтому два разных длинных пароля с общим 72-байтным префиксом считались бы одинаковыми. Argon2id учитывает весь пароль. Это проверяет тест `test_long_passwords_not_truncated`.
|
||||
- **Вход:** `POST /api/v1/auth/sessions`, только `Authorization: Basic`. Ответ 201 с opaque-токеном (`secrets.token_urlsafe(32)`, 256 бит), `expires_at` в UTC с `Z`. При неверных данных одинаковый `401` и `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`. Для несуществующего пользователя выполняется проверка по фиктивному хешу, чтобы время ответа не выдавало существование логина.
|
||||
- **Срок жизни:** `SESSION_TTL_SECONDS`, по умолчанию 3600. Срок не продлевается при рестарте.
|
||||
- **Бизнес-эндпоинты:** только `Authorization: Bearer`. Истёкший, отозванный или неизвестный токен даёт `401` с `WWW-Authenticate: Bearer realm="messenger"`. `X-User-Id` игнорируется.
|
||||
- **Logout:** `DELETE /api/v1/auth/sessions/current` удаляет только предъявленную сессию (остальные сессии пользователя остаются), повторный вызов с тем же токеном даёт `401`.
|
||||
- **Доступ к чату:** сначала аутентификация (`401`), затем членство; посторонний получает `404`, существование чужого чата не раскрывается.
|
||||
|
||||
## Роль Valkey
|
||||
|
||||
**Роль: кэш сессий.** Источник истины для сессий таблица `sessions` в PostgreSQL.
|
||||
|
||||
| Вопрос | Решение |
|
||||
|---|---|
|
||||
| Что хранится | `token -> {user_id, username, display_name, created_at, expires_at}` |
|
||||
| Ключ | `sess:<sha256(token)>`, сырой токен в кэше не хранится |
|
||||
| TTL записи | `min(SESSION_CACHE_TTL_SECONDS (по умолчанию 30 с), остаток жизни сессии)`; запись не переживёт сессию |
|
||||
| Инвалидация | при logout сначала `DELETE` в PostgreSQL (commit), затем `DEL` ключа в Valkey |
|
||||
| Чтение | кэш -> при промахе PostgreSQL (`JOIN sessions/users`) -> запись в кэш |
|
||||
| Persistence | не нужен: кэш не единственное хранилище, потеря кэша не теряет сессии |
|
||||
| Отказ Valkey | любая ошибка кэша трактуется как промах, запрос идёт в PostgreSQL; клиентские таймауты 0,5 с |
|
||||
| Анонимный запрос | при любой неисправности остаётся `401`, не принимается как доверенный |
|
||||
|
||||
**Ограничение (окно устаревания).** Если `DEL` не прошёл (Valkey недоступен именно в момент logout), отозванный токен может приниматься до `SESSION_CACHE_TTL_SECONDS` (30 с). Это осознанный компромисс; окно ограничено TTL записи и логируется (`cache delete failed`). Похожий случай: если logout происходит между чтением сессии из PostgreSQL и записью в кэш, запись также проживёт не дольше 30 с.
|
||||
|
||||
**Рестарт Valkey.** Кэш пустой, сессии не теряются, первые запросы читают PostgreSQL и заново наполняют кэш (проверено `make test-persistence` и тестом `test_valkey_down_falls_back_to_db`).
|
||||
|
||||
## Индекс истории и EXPLAIN
|
||||
|
||||
**Запрос истории** (то, что выполняет API):
|
||||
|
||||
```sql
|
||||
SELECT * FROM messages
|
||||
WHERE chat_id = :chat
|
||||
AND (created_at, id) > (:created_at, :id) -- только при продолжении
|
||||
ORDER BY created_at, id
|
||||
LIMIT :limit + 1;
|
||||
```
|
||||
|
||||
**Было:** отдельные индексы по `chat_id` и по `created_at`. Для запроса с фильтром по чату и порядком `(created_at, id)` ни один из них не подходит целиком: одноколоночный по `chat_id` требует отдельной сортировки всех сообщений чата, а по `created_at` не фильтрует по чату.
|
||||
|
||||
**Стало:** составной индекс `ix_messages_chat_created_id (chat_id, created_at, id)`. Колонки идут в порядке «равенство, затем порядок сортировки», поэтому одна и та же структура и ищет границу страницы (сравнение строк), и отдаёт строки сразу в нужном порядке.
|
||||
|
||||
**Данные для проверки** воспроизводимы: `scripts/seed_explain.sql` создаёт 2 чата по 12 000 сообщений (24 000 всего, детерминированные UUID, повторный запуск ничего не дублирует). Снятие плана: `bash scripts/explain_history.sh`; результат в `evidence/explain_history.txt`.
|
||||
|
||||
**Результат «после»** (чат из 12 000 сообщений, `EXPLAIN (ANALYZE, BUFFERS)`):
|
||||
|
||||
| Запрос | План | Buffers | Execution time |
|
||||
|---|---|---|---|
|
||||
| первая страница (51 строка) | `Index Scan using ix_messages_chat_created_id`, `Index Cond: (chat_id = ...)` | shared hit=5 | 0,032 мс |
|
||||
| страница из середины (после 6 000-го сообщения) | `Index Scan using ix_messages_chat_created_id`, `Index Cond: (chat_id = ... AND ROW(created_at, id) > ROW(...))` | shared hit=6 | 0,052 мс |
|
||||
|
||||
Оба плана без шага `Sort`, без `Seq Scan` и без `Bitmap Heap Scan`; страница читает несколько буферов независимо от того, на каком месте истории она находится. Это подтверждает, что пагинация не сканирует всю историю на каждую страницу.
|
||||
|
||||
**Сравнение «до»:** <ВСТАВИТЬ после снятия `evidence/explain_before.txt`: тип плана (Sort / Bitmap / Seq Scan), Buffers и Execution time на старых индексах; если файл не снимался, удалить этот абзац>
|
||||
|
||||
## Надёжность и таймауты
|
||||
|
||||
- **Пул соединений:** `pool_size=10`, `max_overflow=10`, `pool_timeout=3 с`, `pool_pre_ping`, `pool_recycle=1800`.
|
||||
- **Таймауты БД:** подключение 2 с (`timeout`), клиентский таймаут запроса 3 с (`command_timeout`), на сервере `statement_timeout=5000 мс` и `idle_in_transaction_session_timeout=10000 мс`.
|
||||
- **Общий дедлайн запроса:** 8 с (`REQUEST_TIMEOUT_SECONDS`), по истечении `503` в формате ошибки контракта.
|
||||
- **Недоступность БД:** ошибки подключения, таймауты пула и запросов отображаются в `503 unavailable`, а не `500` и не зависание.
|
||||
- **Параметризованные запросы:** весь доступ к данным через SQLAlchemy Core/ORM, строковая конкатенация SQL не используется.
|
||||
- **Гонка регистрации:** решается `UNIQUE (username)`, а не проверкой перед вставкой; из 10 параллельных запросов с одним username ровно один получает `201`, остальные `409` (`test_register_race_one_winner`).
|
||||
|
||||
## Health-проверки
|
||||
|
||||
- `GET /health/live`: только живость процесса.
|
||||
- `GET /health/ready`: `200`, если из пула получено соединение и выполнен `SELECT 1 FROM users LIMIT 1` (заодно подтверждает, что миграции накатаны). Ответ даётся не позднее чем через 2 с; при недоступной БД `503`.
|
||||
- **Критичные зависимости:** PostgreSQL (критична). Valkey не критичен: при его отказе API продолжает работать с обходом кэша.
|
||||
|
||||
## Семантика пагинации и ограничения
|
||||
|
||||
- Курсор непрозрачный (base64 от JSON), содержит полный ключ сортировки `(created_at, id)` и область (чат / пользователь). Курсор от другого чата или повреждённая строка дают `400`.
|
||||
- Порядок по возрастанию `(created_at, id)` как для истории, так и для списка чатов. Последний элемент предыдущей страницы не повторяется; сообщения с одинаковым временем не пропускаются (`test_pagination_with_equal_timestamps`).
|
||||
- `next_cursor = null`, если на момент чтения следующей записи нет.
|
||||
- **Ограничение при конкурентных вставках.** `created_at` назначается приложением до коммита. Если сообщение с более ранним `created_at` будет закоммичено позже, чем читатель уже прошёл эту позицию, при продолжении обхода оно может не попасть в выдачу. Для неизменной истории повторов и пропусков нет; snapshot-изоляция между HTTP-запросами не гарантируется (контракт этого и не требует).
|
||||
|
||||
## Автоматические проверки
|
||||
|
||||
Публичные: `make test` (smoke) и `make test-persistence ACTION_SCRIPT=scripts/restart.sh`.
|
||||
|
||||
Собственные: **`make test-own`** (`scripts/test_own.sh`, `tests_own/`) поднимает стенд и выполняет:
|
||||
|
||||
| Проверка | Тест |
|
||||
|---|---|
|
||||
| неверный пароль, `401` и `WWW-Authenticate` | `test_wrong_password_401` |
|
||||
| длинные пароли с общим 72-байтным префиксом различаются | `test_long_passwords_not_truncated` |
|
||||
| logout отзывает только текущую сессию, повтор даёт `401` | `test_logout_revokes_only_current_session` |
|
||||
| logout сразу инвалидирует кэш | `test_logout_invalidates_cache_immediately` |
|
||||
| гонка регистрации: один победитель | `test_register_race_one_winner` |
|
||||
| дубликаты / неизвестные участники / нет создателя дают `400`, список чатов не изменился | `test_chat_validation_and_rollback` |
|
||||
| повреждённый и чужой курсор дают `400` | `test_cursor_garbage_and_foreign_cursor_400` |
|
||||
| одинаковое `created_at` не теряет сообщения | `test_pagination_with_equal_timestamps` |
|
||||
| полный обход без повторов и в порядке отправки | `test_pagination_full_walk_in_order` |
|
||||
| Valkey остановлен: запросы с токеном работают, аноним получает `401`, после старта работает снова | `test_valkey_down_falls_back_to_db` |
|
||||
| PostgreSQL на паузе: `/health/ready` и бизнес-запрос дают `503`, после `unpause` работа восстанавливается | `test_db_paused_returns_503_and_recovers` |
|
||||
| истечение сессии при `SESSION_TTL_SECONDS=2` (отдельный запуск с коротким TTL) | `test_session_expires` |
|
||||
|
||||
Откат составной операции проверяется на уровне валидации: невалидные запросы создания чата не оставляют частично записанного состояния. Сбой внутри самой транзакции (между вставкой чата и вставкой участников) отдельно не инжектировался: атомарность в этом случае обеспечивает транзакция PostgreSQL.
|
||||
|
||||
## Как запустить
|
||||
|
||||
```bash
|
||||
cp .env.example .env # при необходимости задать POSTGRES_PASSWORD
|
||||
docker compose up -d --build # db -> migrate -> app, плюс valkey
|
||||
curl -f http://localhost:8080/health/ready
|
||||
|
||||
make test
|
||||
make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
make test-own # нужны pytest и httpx: pip install pytest httpx
|
||||
bash scripts/explain_history.sh # EXPLAIN на 24 000 сообщений -> evidence/explain_history.txt
|
||||
```
|
||||
|
||||
Параметры окружения: `DATABASE_URL`, `REDIS_URL`, `SESSION_TTL_SECONDS` (3600), `SESSION_CACHE_TTL_SECONDS` (30), `DB_POOL_SIZE`, `DB_MAX_OVERFLOW`, `DB_POOL_TIMEOUT`, `REQUEST_TIMEOUT_SECONDS`.
|
||||
|
||||
Секреты: пароль БД задаётся через `.env` (в Git не попадает); значение по умолчанию в `docker-compose.yaml` пригодно только для локального изолированного стенда. Basic-аутентификация и HTTP допустимы только для локальной демонстрации с синтетическими данными; при удалённом доступе нужен TLS.
|
||||
|
||||
## Ограничения и известные компромиссы
|
||||
|
||||
- Окно устаревания кэша при неудачном `DEL` (до 30 с), см. раздел про Valkey.
|
||||
- Argon2id используется с параметрами библиотеки по умолчанию, отдельной настройки под нагрузку не выполнялось.
|
||||
- После перехода с bcrypt на Argon2id старые хеши несовместимы: учебный стенд пересоздаётся (`docker compose down -v`).
|
||||
- Истёкшие строки в `sessions` физически не удаляются фоновой задачей (проверка срока идёт при каждом запросе).
|
||||
- Нагрузочное и конкурентное тестирование ограничено перечисленными проверками; исследование для оценки «5» не выполнялось.
|
||||
|
||||
## Ответы на вопросы защиты
|
||||
|
||||
- **Что подтверждает COMMIT и какие гарантии зависят от durability?** COMMIT в PostgreSQL возвращается после записи WAL-записи коммита; при `fsync=on` и `synchronous_commit=on` (значения по умолчанию в используемом образе) подтверждённая транзакция переживает падение процесса и перезагрузку. При `synchronous_commit=off` последние подтверждённые транзакции можно потерять при сбое, при этом целостность БД сохраняется.
|
||||
- **Где хранятся сессии и что будет после flush/restart Valkey?** Сессии хранятся в PostgreSQL; Valkey лишь кэширует их на короткое время. После flush или рестарта Valkey кэш пустой, сессии остаются действительными, запросы временно идут напрямую в PostgreSQL.
|
||||
- **Чем аутентификация отличается от доступа к конкретному чату?** Аутентификация отвечает на вопрос «кто вы» (валидный Bearer-токен, иначе `401`), авторизация на вопрос «можно ли вам это» (членство в чате, иначе `404`, чтобы не раскрывать существование чужого чата). Сначала проверяется первое, затем второе.
|
||||
- **Почему hash пароля и быстрый checksum имеют разные задачи?** Checksum (например SHA-256) должен считаться быстро и проверяет целостность данных; хеш пароля (Argon2id) специально медленный, требует много памяти и использует случайную соль, чтобы перебор по украденной базе был дорогим. Быстрый хеш для паролей позволяет перебирать миллиарды вариантов в секунду.
|
||||
|
||||
+149
@@ -0,0 +1,149 @@
|
||||
# A generic, single database configuration.
|
||||
|
||||
[alembic]
|
||||
# path to migration scripts.
|
||||
# this is typically a path given in POSIX (e.g. forward slashes)
|
||||
# format, relative to the token %(here)s which refers to the location of this
|
||||
# ini file
|
||||
script_location = %(here)s/alembic
|
||||
|
||||
# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
|
||||
# Uncomment the line below if you want the files to be prepended with date and time
|
||||
# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
|
||||
# for all available tokens
|
||||
# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
|
||||
# Or organize into date-based subdirectories (requires recursive_version_locations = true)
|
||||
# file_template = %%(year)d/%%(month).2d/%%(day).2d_%%(hour).2d%%(minute).2d_%%(second).2d_%%(rev)s_%%(slug)s
|
||||
|
||||
# sys.path path, will be prepended to sys.path if present.
|
||||
# defaults to the current working directory. for multiple paths, the path separator
|
||||
# is defined by "path_separator" below.
|
||||
prepend_sys_path = .
|
||||
|
||||
|
||||
# timezone to use when rendering the date within the migration file
|
||||
# as well as the filename.
|
||||
# If specified, requires the tzdata library which can be installed by adding
|
||||
# `alembic[tz]` to the pip requirements.
|
||||
# string value is passed to ZoneInfo()
|
||||
# leave blank for localtime
|
||||
# timezone =
|
||||
|
||||
# max length of characters to apply to the "slug" field
|
||||
# truncate_slug_length = 40
|
||||
|
||||
# set to 'true' to run the environment during
|
||||
# the 'revision' command, regardless of autogenerate
|
||||
# revision_environment = false
|
||||
|
||||
# set to 'true' to allow .pyc and .pyo files without
|
||||
# a source .py file to be detected as revisions in the
|
||||
# versions/ directory
|
||||
# sourceless = false
|
||||
|
||||
# version location specification; This defaults
|
||||
# to <script_location>/versions. When using multiple version
|
||||
# directories, initial revisions must be specified with --version-path.
|
||||
# The path separator used here should be the separator specified by "path_separator"
|
||||
# below.
|
||||
# version_locations = %(here)s/bar:%(here)s/bat:%(here)s/alembic/versions
|
||||
|
||||
# path_separator; This indicates what character is used to split lists of file
|
||||
# paths, including version_locations and prepend_sys_path within configparser
|
||||
# files such as alembic.ini.
|
||||
# The default rendered in new alembic.ini files is "os", which uses os.pathsep
|
||||
# to provide os-dependent path splitting.
|
||||
#
|
||||
# Note that in order to support legacy alembic.ini files, this default does NOT
|
||||
# take place if path_separator is not present in alembic.ini. If this
|
||||
# option is omitted entirely, fallback logic is as follows:
|
||||
#
|
||||
# 1. Parsing of the version_locations option falls back to using the legacy
|
||||
# "version_path_separator" key, which if absent then falls back to the legacy
|
||||
# behavior of splitting on spaces and/or commas.
|
||||
# 2. Parsing of the prepend_sys_path option falls back to the legacy
|
||||
# behavior of splitting on spaces, commas, or colons.
|
||||
#
|
||||
# Valid values for path_separator are:
|
||||
#
|
||||
# path_separator = :
|
||||
# path_separator = ;
|
||||
# path_separator = space
|
||||
# path_separator = newline
|
||||
#
|
||||
# Use os.pathsep. Default configuration used for new projects.
|
||||
path_separator = os
|
||||
|
||||
# set to 'true' to search source files recursively
|
||||
# in each "version_locations" directory
|
||||
# new in Alembic version 1.10
|
||||
# recursive_version_locations = false
|
||||
|
||||
# the output encoding used when revision files
|
||||
# are written from script.py.mako
|
||||
# output_encoding = utf-8
|
||||
|
||||
# database URL. This is consumed by the user-maintained env.py script only.
|
||||
# other means of configuring database URLs may be customized within the env.py
|
||||
# file.
|
||||
sqlalchemy.url = postgresql+asyncpg://app_user:secure_password_123@localhost:5432/messenger_db
|
||||
|
||||
|
||||
[post_write_hooks]
|
||||
# post_write_hooks defines scripts or Python functions that are run
|
||||
# on newly generated revision scripts. See the documentation for further
|
||||
# detail and examples
|
||||
|
||||
# format using "black" - use the console_scripts runner, against the "black" entrypoint
|
||||
# hooks = black
|
||||
# black.type = console_scripts
|
||||
# black.entrypoint = black
|
||||
# black.options = -l 79 REVISION_SCRIPT_FILENAME
|
||||
|
||||
# lint with attempts to fix using "ruff" - use the module runner, against the "ruff" module
|
||||
# hooks = ruff
|
||||
# ruff.type = module
|
||||
# ruff.module = ruff
|
||||
# ruff.options = check --fix REVISION_SCRIPT_FILENAME
|
||||
|
||||
# Alternatively, use the exec runner to execute a binary found on your PATH
|
||||
# hooks = ruff
|
||||
# ruff.type = exec
|
||||
# ruff.executable = ruff
|
||||
# ruff.options = check --fix REVISION_SCRIPT_FILENAME
|
||||
|
||||
# Logging configuration. This is also consumed by the user-maintained
|
||||
# env.py script only.
|
||||
[loggers]
|
||||
keys = root,sqlalchemy,alembic
|
||||
|
||||
[handlers]
|
||||
keys = console
|
||||
|
||||
[formatters]
|
||||
keys = generic
|
||||
|
||||
[logger_root]
|
||||
level = WARNING
|
||||
handlers = console
|
||||
qualname =
|
||||
|
||||
[logger_sqlalchemy]
|
||||
level = WARNING
|
||||
handlers =
|
||||
qualname = sqlalchemy.engine
|
||||
|
||||
[logger_alembic]
|
||||
level = INFO
|
||||
handlers =
|
||||
qualname = alembic
|
||||
|
||||
[handler_console]
|
||||
class = StreamHandler
|
||||
args = (sys.stderr,)
|
||||
level = NOTSET
|
||||
formatter = generic
|
||||
|
||||
[formatter_generic]
|
||||
format = %(levelname)-5.5s [%(name)s] %(message)s
|
||||
datefmt = %H:%M:%S
|
||||
@@ -0,0 +1 @@
|
||||
Generic single-database configuration.
|
||||
@@ -0,0 +1,61 @@
|
||||
import asyncio
|
||||
from logging.config import fileConfig
|
||||
|
||||
from sqlalchemy import pool
|
||||
from sqlalchemy.engine import Connection
|
||||
from sqlalchemy.ext.asyncio import async_engine_from_config
|
||||
|
||||
from alembic import context
|
||||
|
||||
# DATABASE_URL берётся из окружения (см. src/database.py)
|
||||
from src.database import DATABASE_URL, Base
|
||||
from src import models # noqa: F401 нужно, чтобы Alembic "увидел" таблицы
|
||||
|
||||
config = context.config
|
||||
|
||||
if config.config_file_name is not None:
|
||||
fileConfig(config.config_file_name)
|
||||
|
||||
target_metadata = Base.metadata
|
||||
|
||||
# % экранируем, иначе configparser воспримет его как интерполяцию
|
||||
config.set_main_option("sqlalchemy.url", DATABASE_URL.replace("%", "%%"))
|
||||
|
||||
|
||||
def run_migrations_offline() -> None:
|
||||
url = config.get_main_option("sqlalchemy.url")
|
||||
context.configure(
|
||||
url=url,
|
||||
target_metadata=target_metadata,
|
||||
literal_binds=True,
|
||||
dialect_opts={"paramstyle": "named"},
|
||||
)
|
||||
with context.begin_transaction():
|
||||
context.run_migrations()
|
||||
|
||||
|
||||
def do_run_migrations(connection: Connection) -> None:
|
||||
context.configure(connection=connection, target_metadata=target_metadata)
|
||||
with context.begin_transaction():
|
||||
context.run_migrations()
|
||||
|
||||
|
||||
async def run_async_migrations() -> None:
|
||||
connectable = async_engine_from_config(
|
||||
config.get_section(config.config_ini_section, {}),
|
||||
prefix="sqlalchemy.",
|
||||
poolclass=pool.NullPool,
|
||||
)
|
||||
async with connectable.connect() as connection:
|
||||
await connection.run_sync(do_run_migrations)
|
||||
await connectable.dispose()
|
||||
|
||||
|
||||
def run_migrations_online() -> None:
|
||||
asyncio.run(run_async_migrations())
|
||||
|
||||
|
||||
if context.is_offline_mode():
|
||||
run_migrations_offline()
|
||||
else:
|
||||
run_migrations_online()
|
||||
@@ -0,0 +1,28 @@
|
||||
"""${message}
|
||||
|
||||
Revision ID: ${up_revision}
|
||||
Revises: ${down_revision | comma,n}
|
||||
Create Date: ${create_date}
|
||||
|
||||
"""
|
||||
from typing import Sequence, Union
|
||||
|
||||
from alembic import op
|
||||
import sqlalchemy as sa
|
||||
${imports if imports else ""}
|
||||
|
||||
# revision identifiers, used by Alembic.
|
||||
revision: str = ${repr(up_revision)}
|
||||
down_revision: Union[str, Sequence[str], None] = ${repr(down_revision)}
|
||||
branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
|
||||
depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
|
||||
|
||||
|
||||
def upgrade() -> None:
|
||||
"""Upgrade schema."""
|
||||
${upgrades if upgrades else "pass"}
|
||||
|
||||
|
||||
def downgrade() -> None:
|
||||
"""Downgrade schema."""
|
||||
${downgrades if downgrades else "pass"}
|
||||
@@ -0,0 +1,27 @@
|
||||
"""messages history index
|
||||
|
||||
Revision ID: b7e1f3a9c2d4
|
||||
Revises: d74c0ccadc85
|
||||
Create Date: 2026-11-06 12:00:00
|
||||
"""
|
||||
from typing import Sequence, Union
|
||||
|
||||
from alembic import op
|
||||
|
||||
revision: str = "b7e1f3a9c2d4"
|
||||
down_revision: Union[str, Sequence[str], None] = "d74c0ccadc85"
|
||||
branch_labels: Union[str, Sequence[str], None] = None
|
||||
depends_on: Union[str, Sequence[str], None] = None
|
||||
|
||||
|
||||
def upgrade() -> None:
|
||||
# Запрос истории: WHERE chat_id = ? AND (created_at, id) > (?, ?) ORDER BY created_at, id
|
||||
op.create_index("ix_messages_chat_created_id", "messages", ["chat_id", "created_at", "id"])
|
||||
op.drop_index("ix_messages_chat_id", table_name="messages") # префикс нового индекса
|
||||
op.drop_index("ix_messages_created_at", table_name="messages") # для этого запроса бесполезен
|
||||
|
||||
|
||||
def downgrade() -> None:
|
||||
op.create_index("ix_messages_created_at", "messages", ["created_at"])
|
||||
op.create_index("ix_messages_chat_id", "messages", ["chat_id"])
|
||||
op.drop_index("ix_messages_chat_created_id", table_name="messages")
|
||||
@@ -0,0 +1,84 @@
|
||||
"""initial tables
|
||||
|
||||
Revision ID: d74c0ccadc85
|
||||
Revises:
|
||||
Create Date: 2026-11-03 11:36:06.290700
|
||||
|
||||
"""
|
||||
from typing import Sequence, Union
|
||||
|
||||
from alembic import op
|
||||
import sqlalchemy as sa
|
||||
|
||||
|
||||
# revision identifiers, used by Alembic.
|
||||
revision: str = 'd74c0ccadc85'
|
||||
down_revision: Union[str, Sequence[str], None] = None
|
||||
branch_labels: Union[str, Sequence[str], None] = None
|
||||
depends_on: Union[str, Sequence[str], None] = None
|
||||
|
||||
|
||||
def upgrade() -> None:
|
||||
"""Upgrade schema."""
|
||||
# ### commands auto generated by Alembic - please adjust! ###
|
||||
op.create_table('chats',
|
||||
sa.Column('id', sa.UUID(), nullable=False),
|
||||
sa.Column('title', sa.String(length=100), nullable=False),
|
||||
sa.Column('created_at', sa.DateTime(timezone=True), nullable=True),
|
||||
sa.PrimaryKeyConstraint('id')
|
||||
)
|
||||
op.create_table('users',
|
||||
sa.Column('id', sa.UUID(), nullable=False),
|
||||
sa.Column('username', sa.String(length=32), nullable=False),
|
||||
sa.Column('display_name', sa.String(length=100), nullable=False),
|
||||
sa.Column('password_hash', sa.String(length=255), nullable=False),
|
||||
sa.Column('created_at', sa.DateTime(timezone=True), nullable=True),
|
||||
sa.PrimaryKeyConstraint('id')
|
||||
)
|
||||
op.create_index(op.f('ix_users_username'), 'users', ['username'], unique=True)
|
||||
op.create_table('chat_members',
|
||||
sa.Column('chat_id', sa.UUID(), nullable=False),
|
||||
sa.Column('user_id', sa.UUID(), nullable=False),
|
||||
sa.Column('joined_at', sa.DateTime(timezone=True), nullable=True),
|
||||
sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
|
||||
sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
|
||||
sa.PrimaryKeyConstraint('chat_id', 'user_id')
|
||||
)
|
||||
op.create_table('messages',
|
||||
sa.Column('id', sa.UUID(), nullable=False),
|
||||
sa.Column('chat_id', sa.UUID(), nullable=False),
|
||||
sa.Column('sender_id', sa.UUID(), nullable=False),
|
||||
sa.Column('text', sa.Text(), nullable=False),
|
||||
sa.Column('created_at', sa.DateTime(timezone=True), nullable=True),
|
||||
sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
|
||||
sa.ForeignKeyConstraint(['sender_id'], ['users.id'], ondelete='CASCADE'),
|
||||
sa.PrimaryKeyConstraint('id')
|
||||
)
|
||||
op.create_index(op.f('ix_messages_chat_id'), 'messages', ['chat_id'], unique=False)
|
||||
op.create_index(op.f('ix_messages_created_at'), 'messages', ['created_at'], unique=False)
|
||||
op.create_table('sessions',
|
||||
sa.Column('id', sa.UUID(), nullable=False),
|
||||
sa.Column('user_id', sa.UUID(), nullable=False),
|
||||
sa.Column('token', sa.String(length=255), nullable=False),
|
||||
sa.Column('expires_at', sa.DateTime(timezone=True), nullable=False),
|
||||
sa.Column('created_at', sa.DateTime(timezone=True), nullable=True),
|
||||
sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
|
||||
sa.PrimaryKeyConstraint('id')
|
||||
)
|
||||
op.create_index(op.f('ix_sessions_token'), 'sessions', ['token'], unique=True)
|
||||
# ### end Alembic commands ###
|
||||
|
||||
|
||||
def downgrade() -> None:
|
||||
"""Downgrade schema."""
|
||||
# ### commands auto generated by Alembic - please adjust! ###
|
||||
op.drop_index(op.f('ix_sessions_token'), table_name='sessions')
|
||||
op.drop_table('sessions')
|
||||
op.drop_index(op.f('ix_messages_created_at'), table_name='messages')
|
||||
op.drop_index(op.f('ix_messages_chat_id'), table_name='messages')
|
||||
op.drop_table('messages')
|
||||
op.drop_table('chat_members')
|
||||
op.drop_index(op.f('ix_users_username'), table_name='users')
|
||||
op.drop_table('users')
|
||||
op.drop_table('chats')
|
||||
# ### end Alembic commands ###
|
||||
@@ -0,0 +1,68 @@
|
||||
x-app-env: &app-env
|
||||
DATABASE_URL: postgresql+asyncpg://${POSTGRES_USER:-postgres}:${POSTGRES_PASSWORD:-postgres}@db:5432/${POSTGRES_DB:-messenger_db}
|
||||
REDIS_URL: redis://valkey:6379/0
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
SESSION_CACHE_TTL_SECONDS: ${SESSION_CACHE_TTL_SECONDS:-30}
|
||||
|
||||
services:
|
||||
db:
|
||||
image: postgres:16-alpine
|
||||
container_name: lab2_postgres
|
||||
environment:
|
||||
POSTGRES_USER: ${POSTGRES_USER:-postgres}
|
||||
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-postgres}
|
||||
POSTGRES_DB: ${POSTGRES_DB:-messenger_db}
|
||||
ports:
|
||||
- "5433:5432"
|
||||
volumes:
|
||||
- postgres_data:/var/lib/postgresql/data
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U postgres -d messenger_db"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 5
|
||||
|
||||
valkey:
|
||||
image: valkey/valkey:8.0-alpine
|
||||
container_name: lab2_valkey
|
||||
# Кэш сессий: источник истины - PostgreSQL, persistence не нужен.
|
||||
command: ["valkey-server", "--save", "", "--appendonly", "no",
|
||||
"--maxmemory", "64mb", "--maxmemory-policy", "allkeys-lru"]
|
||||
healthcheck:
|
||||
test: ["CMD", "valkey-cli", "ping"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 5
|
||||
|
||||
migrate:
|
||||
build: .
|
||||
image: lab2-app
|
||||
container_name: lab2_migrate
|
||||
command: ["alembic", "upgrade", "head"]
|
||||
environment: *app-env
|
||||
depends_on:
|
||||
db:
|
||||
condition: service_healthy
|
||||
restart: "no"
|
||||
|
||||
app:
|
||||
build: .
|
||||
image: lab2-app
|
||||
container_name: lab2_app
|
||||
environment: *app-env
|
||||
ports:
|
||||
- "8080:8080"
|
||||
depends_on:
|
||||
migrate:
|
||||
condition: service_completed_successfully
|
||||
valkey:
|
||||
condition: service_started # мягкая зависимость: API работает и без кэша
|
||||
restart: unless-stopped
|
||||
healthcheck:
|
||||
test: ["CMD", "curl", "-f", "http://localhost:8080/health/ready"]
|
||||
interval: 10s
|
||||
timeout: 5s
|
||||
retries: 5
|
||||
|
||||
volumes:
|
||||
postgres_data:
|
||||
@@ -0,0 +1,58 @@
|
||||
== 2026-11-06T20:46:24Z ==
|
||||
== версия миграции ==
|
||||
b7e1f3a9c2d4
|
||||
== индексы messages ==
|
||||
Table "public.messages"
|
||||
Column | Type | Collation | Nullable | Default
|
||||
------------+--------------------------+-----------+----------+---------
|
||||
id | uuid | | not null |
|
||||
chat_id | uuid | | not null |
|
||||
sender_id | uuid | | not null |
|
||||
text | text | | not null |
|
||||
created_at | timestamp with time zone | | |
|
||||
Indexes:
|
||||
"messages_pkey" PRIMARY KEY, btree (id)
|
||||
"ix_messages_chat_created_id" btree (chat_id, created_at, id)
|
||||
Foreign-key constraints:
|
||||
"messages_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
|
||||
"messages_sender_id_fkey" FOREIGN KEY (sender_id) REFERENCES users(id) ON DELETE CASCADE
|
||||
|
||||
== сообщений по чатам ==
|
||||
chat_id | count
|
||||
--------------------------------------+-------
|
||||
af3cd510-1663-4fea-8a38-8e15fb90210e | 5
|
||||
858a289c-ea8f-4ffe-9954-e98f015a072c | 3
|
||||
00000000-0000-0000-0000-0000000000c1 | 12000
|
||||
d3a832f7-a587-452e-a61b-8f9fd3651fec | 2
|
||||
00000000-0000-0000-0000-0000000000c2 | 12000
|
||||
36aa67a0-0d47-4047-bb68-3e2781cb5b75 | 2
|
||||
(6 rows)
|
||||
|
||||
== первая страница ==
|
||||
QUERY PLAN
|
||||
-----------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit (cost=0.41..8.36 rows=51 width=65) (actual time=0.013..0.018 rows=51 loops=1)
|
||||
Buffers: shared hit=5
|
||||
-> Index Scan using ix_messages_chat_created_id on messages (cost=0.41..1870.97 rows=12000 width=65) (actual time=0.012..0.015 rows=51 loops=1)
|
||||
Index Cond: (chat_id = '00000000-0000-0000-0000-0000000000c1'::uuid)
|
||||
Buffers: shared hit=5
|
||||
Planning:
|
||||
Buffers: shared hit=107
|
||||
Planning Time: 0.252 ms
|
||||
Execution Time: 0.032 ms
|
||||
(9 rows)
|
||||
|
||||
== страница из середины (keyset, как в API) ==
|
||||
QUERY PLAN
|
||||
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit (cost=0.41..12.80 rows=51 width=65) (actual time=0.016..0.024 rows=51 loops=1)
|
||||
Buffers: shared hit=6
|
||||
-> Index Scan using ix_messages_chat_created_id on messages (cost=0.41..1458.70 rows=6002 width=65) (actual time=0.016..0.022 rows=51 loops=1)
|
||||
Index Cond: ((chat_id = '00000000-0000-0000-0000-0000000000c1'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 01:40:00+00'::timestamp with time zone, '2bd0323e-6c41-2bf3-f433-b3a2ad4a0c44'::uuid)))
|
||||
Buffers: shared hit=6
|
||||
Planning:
|
||||
Buffers: shared hit=106
|
||||
Planning Time: 0.282 ms
|
||||
Execution Time: 0.052 ms
|
||||
(9 rows)
|
||||
|
||||
@@ -0,0 +1,15 @@
|
||||
# Web framework
|
||||
fastapi==0.115.0
|
||||
uvicorn==0.30.6
|
||||
pydantic==2.9.2
|
||||
|
||||
# Database & Migrations
|
||||
sqlalchemy==2.0.35
|
||||
asyncpg==0.30.0
|
||||
alembic==1.13.3
|
||||
|
||||
# Security
|
||||
argon2-cffi==23.1.0
|
||||
|
||||
# Cache (Valkey/Redis)
|
||||
redis==5.2.0
|
||||
@@ -1,54 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Offline structural checks; full schema validation is a separate target."""
|
||||
import ast
|
||||
import json
|
||||
from pathlib import Path
|
||||
import re
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
|
||||
def main():
|
||||
lab = json.loads((ROOT/'lab.json').read_text())['number']
|
||||
spec = json.loads((ROOT/'contracts/openapi.json').read_text())
|
||||
assert spec['openapi']=='3.1.0'
|
||||
assert spec['info']['version']=='1.%d.0'%lab
|
||||
operation_ids = set()
|
||||
def walk(value):
|
||||
if isinstance(value,dict):
|
||||
if '$ref' in value:
|
||||
pointer = value['$ref']
|
||||
assert pointer.startswith('#/'), 'unexpected external reference'
|
||||
target = spec
|
||||
for part in pointer[2:].split('/'):
|
||||
target = target[part.replace('~1','/').replace('~0','~')]
|
||||
for v in value.values():
|
||||
walk(v)
|
||||
elif isinstance(value,list):
|
||||
for v in value:
|
||||
walk(v)
|
||||
walk(spec)
|
||||
for route,methods in spec['paths'].items():
|
||||
placeholders = set(re.findall(r'\{([^}]+)\}',route))
|
||||
for method,op in methods.items():
|
||||
assert op['operationId'] not in operation_ids, 'duplicate operationId'
|
||||
operation_ids.add(op['operationId'])
|
||||
params = {p['name'] for p in op.get('parameters',[]) if p['in']=='path' and p.get('required')}
|
||||
assert placeholders==params, 'path parameter mismatch: '+route
|
||||
for response in op['responses'].values():
|
||||
assert 'X-Request-Id' in response['headers']
|
||||
if lab>=3:
|
||||
assert 'X-Instance-Id' in response['headers']
|
||||
assert ('/api/v1/auth/sessions' in spec['paths']) == (lab>=2)
|
||||
assert ('/api/v1/attachments/{attachment_id}' in spec['paths']) == (lab>=4)
|
||||
for file in list((ROOT/'tests').glob('*.py'))+list((ROOT/'scripts').glob('*.py')):
|
||||
ast.parse(file.read_text(),filename=str(file))
|
||||
for file in ROOT.rglob('*.json'):
|
||||
if any(part in {'.git','.venv','node_modules','vendor','output'} for part in file.parts):
|
||||
continue
|
||||
json.loads(file.read_text())
|
||||
for required in ('README.md','COURSE.md','CONTRIBUTING.md','REPORT.md','contracts/README.md','tests/smoke.py','tests/README.md'):
|
||||
assert (ROOT/required).is_file(), 'missing '+required
|
||||
print('PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.')
|
||||
|
||||
if __name__=='__main__':
|
||||
main()
|
||||
Executable
+26
@@ -0,0 +1,26 @@
|
||||
#!/usr/bin/env bash
|
||||
# Сидирует >=10 000 сообщений и снимает EXPLAIN (ANALYZE, BUFFERS) запроса истории.
|
||||
# Запуск до и после миграции b7e1f3a9c2d4 даёт сравнение "до/после" для REPORT.md.
|
||||
set -euo pipefail
|
||||
cd "$(dirname "$0")/.."
|
||||
mkdir -p evidence
|
||||
OUT="${1:-evidence/explain_history.txt}"
|
||||
PSQL="docker compose exec -T db psql -U postgres -d messenger_db"
|
||||
CHAT="00000000-0000-0000-0000-0000000000c1"
|
||||
|
||||
$PSQL < scripts/seed_explain.sql >/dev/null
|
||||
|
||||
# Курсор из середины истории: сообщение №6000 целевого чата
|
||||
MID=$($PSQL -At -c "SELECT created_at || '|' || id FROM messages WHERE chat_id='$CHAT' ORDER BY created_at, id OFFSET 5999 LIMIT 1")
|
||||
TS="${MID%%|*}"; ID="${MID##*|}"
|
||||
|
||||
{
|
||||
echo "== $(date -u +%FT%TZ) =="
|
||||
echo "== версия миграции =="; $PSQL -At -c "SELECT version_num FROM alembic_version"
|
||||
echo "== индексы messages =="; $PSQL -c "\d messages"
|
||||
echo "== сообщений по чатам =="; $PSQL -c "SELECT chat_id, count(*) FROM messages GROUP BY 1"
|
||||
echo "== первая страница =="
|
||||
$PSQL -c "EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM messages WHERE chat_id='$CHAT' ORDER BY created_at, id LIMIT 51"
|
||||
echo "== страница из середины (keyset, как в API) =="
|
||||
$PSQL -c "EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM messages WHERE chat_id='$CHAT' AND (created_at, id) > ('$TS'::timestamptz, '$ID'::uuid) ORDER BY created_at, id LIMIT 51"
|
||||
} | tee "$OUT"
|
||||
@@ -1,10 +0,0 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
# TODO: copy to restart.sh and implement using YOUR compose/stack services.
|
||||
# Restart API and ALL used state stores (DB, sessions, S3, broker as applicable).
|
||||
# Preserve persistent volumes and schema/data; never down -v / flush / re-seed.
|
||||
# Allow operator unseal if required in lab7; do not print credentials.
|
||||
# Exit 0 only after the intended action; test waits for API readiness separately.
|
||||
printf '%s
|
||||
' 'TODO: implement restart.sh for your infrastructure' >&2
|
||||
exit 2
|
||||
Executable
+14
@@ -0,0 +1,14 @@
|
||||
#!/bin/bash
|
||||
# Скрипт для перезапуска сервисов с сохранением volumes (доказательство работы БД)
|
||||
set -e
|
||||
|
||||
echo "🔄 Перезапускаем сервисы (сохраняя volumes)..."
|
||||
docker compose restart app db
|
||||
|
||||
echo "⏳ Ожидаем восстановления healthcheck (10 секунд)..."
|
||||
sleep 10
|
||||
|
||||
# Проверяем, что сервисы снова healthy
|
||||
docker compose ps | grep -q "healthy" || (echo "❌ Сервисы не стали healthy!" && exit 1)
|
||||
|
||||
echo "✅ Сервисы успешно перезапущены и готовы к работе!"
|
||||
@@ -0,0 +1,25 @@
|
||||
-- Воспроизводимый набор: 2 чата по 12 000 сообщений (24 000 всего). Повторный запуск ничего не дублирует.
|
||||
INSERT INTO users(id, username, display_name, password_hash, created_at)
|
||||
VALUES ('00000000-0000-0000-0000-000000000001', 'explain_user', 'Explain', 'x', now())
|
||||
ON CONFLICT DO NOTHING;
|
||||
|
||||
INSERT INTO chats(id, title, created_at) VALUES
|
||||
('00000000-0000-0000-0000-0000000000c1', 'explain target', now()),
|
||||
('00000000-0000-0000-0000-0000000000c2', 'explain noise', now())
|
||||
ON CONFLICT DO NOTHING;
|
||||
|
||||
INSERT INTO chat_members(chat_id, user_id, joined_at)
|
||||
SELECT c.id, '00000000-0000-0000-0000-000000000001', now()
|
||||
FROM chats c
|
||||
WHERE c.id IN ('00000000-0000-0000-0000-0000000000c1', '00000000-0000-0000-0000-0000000000c2')
|
||||
ON CONFLICT DO NOTHING;
|
||||
|
||||
INSERT INTO messages(id, chat_id, sender_id, text, created_at)
|
||||
SELECT md5(c.id::text || g)::uuid, c.id, '00000000-0000-0000-0000-000000000001',
|
||||
'msg ' || g, timestamptz '2026-01-01 00:00:00+00' + g * interval '1 second'
|
||||
FROM (VALUES ('00000000-0000-0000-0000-0000000000c1'::uuid),
|
||||
('00000000-0000-0000-0000-0000000000c2'::uuid)) c(id),
|
||||
generate_series(1, 12000) g
|
||||
ON CONFLICT DO NOTHING;
|
||||
|
||||
ANALYZE messages;
|
||||
Executable
+39
@@ -0,0 +1,39 @@
|
||||
#!/usr/bin/env bash
|
||||
# Собственные автотесты: auth/TTL/logout/гонки/откат/пагинация/отказы Valkey и БД. Одна команда: make test-own
|
||||
set -euo pipefail
|
||||
cd "$(dirname "$0")/.."
|
||||
export BASE_URL="${BASE_URL:-http://localhost:8080}"
|
||||
PY="${PYTHON:-python3}"
|
||||
|
||||
$PY -c "import pytest, httpx" 2>/dev/null || { echo "pip install pytest httpx"; exit 1; }
|
||||
|
||||
wait_ready() {
|
||||
for _ in $(seq 1 90); do curl -fs "$BASE_URL/health/ready" >/dev/null && return 0; sleep 1; done
|
||||
echo "API not ready"; return 1
|
||||
}
|
||||
wait_healthy() {
|
||||
for _ in $(seq 1 60); do
|
||||
s=$(docker inspect -f '{{.State.Health.Status}}' "$1" 2>/dev/null || echo none)
|
||||
[ "$s" = healthy ] && return 0
|
||||
sleep 1
|
||||
done
|
||||
echo "$1 is not healthy" >&2
|
||||
return 1
|
||||
}
|
||||
|
||||
docker compose up -d --build
|
||||
wait_ready
|
||||
$PY -m pytest tests_own -m "not ttl" -v
|
||||
|
||||
wait_healthy lab2_postgres
|
||||
wait_healthy lab2_valkey
|
||||
|
||||
# Короткий TTL только для проверки истечения сессии
|
||||
SESSION_TTL_SECONDS=2 docker compose up -d --force-recreate app
|
||||
wait_ready
|
||||
$PY -m pytest tests_own -m ttl -v
|
||||
|
||||
# Вернуть TTL по умолчанию
|
||||
docker compose up -d --force-recreate app
|
||||
wait_ready
|
||||
echo "OK"
|
||||
@@ -1,23 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Full OpenAPI and JSON Schema checks; install requirements-dev.txt first."""
|
||||
import json
|
||||
from pathlib import Path
|
||||
from openapi_spec_validator import validate
|
||||
from jsonschema import Draft202012Validator
|
||||
|
||||
root = Path(__file__).resolve().parents[1]
|
||||
spec = json.loads((root/'contracts/openapi.json').read_text())
|
||||
validate(spec)
|
||||
from referencing import Registry, Resource
|
||||
# The base URI resolves local #/components references inside examples.
|
||||
resource = dict(spec, **{'$schema': 'https://json-schema.org/draft/2020-12/schema'})
|
||||
registry = Registry().with_resource('urn:mtusi:openapi', Resource.from_contents(resource))
|
||||
for name, example in json.loads((root/'contracts/examples.json').read_text()).items():
|
||||
schema = {'$ref': 'urn:mtusi:openapi#/components/schemas/' + name}
|
||||
Draft202012Validator(schema, registry=registry).validate(example)
|
||||
for path in (root/'contracts').glob('*.schema.json'):
|
||||
schema = json.loads(path.read_text())
|
||||
Draft202012Validator.check_schema(schema)
|
||||
for example in schema.get('examples',[]):
|
||||
Draft202012Validator(schema).validate(example)
|
||||
print('PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.')
|
||||
+33
@@ -0,0 +1,33 @@
|
||||
import os
|
||||
import secrets
|
||||
from datetime import datetime, timezone, timedelta
|
||||
|
||||
from argon2 import PasswordHasher
|
||||
from argon2.exceptions import VerifyMismatchError, InvalidHashError, VerificationError
|
||||
|
||||
SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
|
||||
|
||||
_ph = PasswordHasher() # Argon2id, параметры по умолчанию
|
||||
# Для выравнивания времени ответа, когда пользователя не существует.
|
||||
DUMMY_HASH = _ph.hash("dummy-password-for-timing")
|
||||
|
||||
|
||||
def hash_password(plain_password: str) -> str:
|
||||
"""Argon2id: учитывает весь пароль (в отличие от bcrypt с лимитом 72 байта)."""
|
||||
return _ph.hash(plain_password)
|
||||
|
||||
|
||||
def verify_password(plain_password: str, hashed_password: str) -> bool:
|
||||
try:
|
||||
return _ph.verify(hashed_password, plain_password) # порядок: hash, password
|
||||
except (VerifyMismatchError, VerificationError, InvalidHashError):
|
||||
return False
|
||||
|
||||
|
||||
def generate_token() -> str:
|
||||
"""Opaque-токен, 256 бит энтропии."""
|
||||
return secrets.token_urlsafe(32)
|
||||
|
||||
|
||||
def get_token_expiry(seconds: int | None = None) -> datetime:
|
||||
return datetime.now(timezone.utc) + timedelta(seconds=seconds or SESSION_TTL_SECONDS)
|
||||
@@ -0,0 +1,51 @@
|
||||
"""Valkey/Redis как КЭШ сессий.
|
||||
|
||||
Источник истины - таблица sessions в PostgreSQL. Запись в кэше живёт
|
||||
min(SESSION_CACHE_TTL_SECONDS, остаток жизни сессии). Любая ошибка кэша
|
||||
приводит к обходу кэша (чтение из PostgreSQL), но не к доверию анониму.
|
||||
"""
|
||||
import hashlib
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
|
||||
import redis.asyncio as redis
|
||||
|
||||
log = logging.getLogger("cache")
|
||||
CACHE_TTL = int(os.getenv("SESSION_CACHE_TTL_SECONDS", "30"))
|
||||
|
||||
_client = redis.from_url(
|
||||
os.getenv("REDIS_URL", "redis://valkey:6379/0"),
|
||||
socket_connect_timeout=0.5,
|
||||
socket_timeout=0.5,
|
||||
decode_responses=True,
|
||||
)
|
||||
|
||||
|
||||
def _key(token: str) -> str:
|
||||
return "sess:" + hashlib.sha256(token.encode()).hexdigest()
|
||||
|
||||
|
||||
async def cache_get(token: str):
|
||||
try:
|
||||
raw = await _client.get(_key(token))
|
||||
return json.loads(raw) if raw else None
|
||||
except Exception as e:
|
||||
log.warning("cache get failed: %s", e)
|
||||
return None
|
||||
|
||||
|
||||
async def cache_set(token: str, payload: dict, ttl: int):
|
||||
if ttl < 1:
|
||||
return
|
||||
try:
|
||||
await _client.set(_key(token), json.dumps(payload), ex=ttl)
|
||||
except Exception as e:
|
||||
log.warning("cache set failed: %s", e)
|
||||
|
||||
|
||||
async def cache_delete(token: str):
|
||||
try:
|
||||
await _client.delete(_key(token))
|
||||
except Exception as e:
|
||||
log.warning("cache delete failed (stale entry lives <= CACHE_TTL): %s", e)
|
||||
@@ -0,0 +1,40 @@
|
||||
import os
|
||||
|
||||
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
|
||||
from sqlalchemy.orm import DeclarativeBase
|
||||
|
||||
DATABASE_URL = os.getenv(
|
||||
"DATABASE_URL",
|
||||
"postgresql+asyncpg://postgres:postgres@localhost:5432/messenger_db",
|
||||
)
|
||||
|
||||
engine = create_async_engine(
|
||||
DATABASE_URL,
|
||||
echo=False,
|
||||
pool_pre_ping=True,
|
||||
pool_size=int(os.getenv("DB_POOL_SIZE", "10")),
|
||||
max_overflow=int(os.getenv("DB_MAX_OVERFLOW", "10")),
|
||||
pool_timeout=float(os.getenv("DB_POOL_TIMEOUT", "3")),
|
||||
pool_recycle=1800,
|
||||
connect_args={
|
||||
"timeout": 2, # установка соединения, сек
|
||||
"command_timeout": 3, # клиентский таймаут запроса, сек
|
||||
"server_settings": {
|
||||
"statement_timeout": "5000",
|
||||
"idle_in_transaction_session_timeout": "10000",
|
||||
},
|
||||
},
|
||||
)
|
||||
|
||||
async_session_maker = async_sessionmaker(
|
||||
engine, class_=AsyncSession, expire_on_commit=False
|
||||
)
|
||||
|
||||
|
||||
class Base(DeclarativeBase):
|
||||
pass
|
||||
|
||||
|
||||
async def get_db():
|
||||
async with async_session_maker() as session:
|
||||
yield session
|
||||
@@ -0,0 +1,77 @@
|
||||
import uuid
|
||||
from dataclasses import dataclass
|
||||
from datetime import datetime, timezone
|
||||
|
||||
from fastapi import Depends, HTTPException, Security
|
||||
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from src.cache import CACHE_TTL, cache_get, cache_set, cache_delete
|
||||
from src.database import get_db
|
||||
from src.models import Session, User
|
||||
|
||||
# auto_error=False: сами контролируем ответ при отсутствии заголовка
|
||||
security = HTTPBearer(auto_error=False)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class CurrentUser:
|
||||
id: uuid.UUID
|
||||
username: str
|
||||
display_name: str
|
||||
created_at: datetime
|
||||
|
||||
|
||||
def _unauthorized(detail: str) -> HTTPException:
|
||||
return HTTPException(
|
||||
status_code=401,
|
||||
detail=detail,
|
||||
headers={"WWW-Authenticate": 'Bearer realm="messenger"'},
|
||||
)
|
||||
|
||||
|
||||
async def get_current_user(
|
||||
credentials: HTTPAuthorizationCredentials = Security(security),
|
||||
db: AsyncSession = Depends(get_db),
|
||||
) -> CurrentUser:
|
||||
if not credentials:
|
||||
raise _unauthorized("Missing authentication credentials")
|
||||
|
||||
token = credentials.credentials
|
||||
now = datetime.now(timezone.utc)
|
||||
|
||||
# 1. Кэш (Valkey). Любая ошибка кэша = промах.
|
||||
cached = await cache_get(token)
|
||||
if cached:
|
||||
if datetime.fromisoformat(cached["expires_at"]) > now:
|
||||
return CurrentUser(
|
||||
uuid.UUID(cached["id"]),
|
||||
cached["username"],
|
||||
cached["display_name"],
|
||||
datetime.fromisoformat(cached["created_at"]),
|
||||
)
|
||||
await cache_delete(token)
|
||||
raise _unauthorized("Token expired")
|
||||
|
||||
# 2. Источник истины - PostgreSQL
|
||||
row = (await db.execute(
|
||||
select(Session, User).join(User, User.id == Session.user_id).where(Session.token == token)
|
||||
)).first()
|
||||
if not row:
|
||||
raise _unauthorized("Invalid or unknown token")
|
||||
|
||||
session, user = row
|
||||
if session.expires_at <= now:
|
||||
raise _unauthorized("Token expired")
|
||||
|
||||
cu = CurrentUser(user.id, user.username, user.display_name, user.created_at)
|
||||
ttl = min(CACHE_TTL, int((session.expires_at - now).total_seconds()))
|
||||
await cache_set(token, {
|
||||
"id": str(cu.id),
|
||||
"username": cu.username,
|
||||
"display_name": cu.display_name,
|
||||
"created_at": cu.created_at.isoformat(),
|
||||
"expires_at": session.expires_at.isoformat(),
|
||||
}, ttl)
|
||||
return cu
|
||||
+315
@@ -0,0 +1,315 @@
|
||||
import asyncio
|
||||
import uuid
|
||||
import os
|
||||
from collections import defaultdict
|
||||
from typing import Optional
|
||||
|
||||
from fastapi import FastAPI, Depends, HTTPException, status, Query, Request, Security
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from fastapi.responses import JSONResponse
|
||||
from fastapi.security import HTTPBasic, HTTPBasicCredentials, HTTPAuthorizationCredentials
|
||||
from sqlalchemy import select, text, delete, tuple_
|
||||
from sqlalchemy.exc import IntegrityError, OperationalError, InterfaceError
|
||||
from sqlalchemy.exc import TimeoutError as SATimeoutError
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
from starlette.concurrency import run_in_threadpool
|
||||
from starlette.middleware.base import BaseHTTPMiddleware
|
||||
|
||||
from src.auth import (hash_password, verify_password, generate_token,
|
||||
get_token_expiry, DUMMY_HASH)
|
||||
from src.cache import cache_delete
|
||||
from src.database import get_db, engine
|
||||
from src.dependencies import get_current_user, security
|
||||
from src.models import User, Session, Chat, ChatMember, Message
|
||||
from src.pagination import encode_cursor, decode_cursor
|
||||
from src.schemas import (UserCreate, UserResponse, SessionResponse,
|
||||
CreateChat, CreateMessage, format_dt)
|
||||
|
||||
app = FastAPI(title="Messenger API", version="2.0.0")
|
||||
|
||||
|
||||
def _error(request: Request, status_code: int, code: str, message: str, headers=None):
|
||||
request_id = getattr(request.state, "request_id", str(uuid.uuid4()))
|
||||
h = dict(headers or {})
|
||||
h["X-Request-Id"] = request_id
|
||||
return JSONResponse(
|
||||
status_code=status_code,
|
||||
content={"error": {"code": code, "message": message, "request_id": request_id}},
|
||||
headers=h,
|
||||
)
|
||||
|
||||
|
||||
@app.exception_handler(RequestValidationError)
|
||||
async def validation_exception_handler(request: Request, exc: RequestValidationError):
|
||||
parts = []
|
||||
for err in exc.errors():
|
||||
field = ".".join(str(x) for x in err.get("loc", []) if x != "body")
|
||||
msg = err.get("msg", "Invalid value")
|
||||
parts.append(f"{field}: {msg}" if field else msg)
|
||||
return _error(request, 400, "invalid_request",
|
||||
", ".join(parts) if parts else "Invalid request payload")
|
||||
|
||||
|
||||
# 1. Middleware для X-Request-Id
|
||||
REQUEST_TIMEOUT = float(os.getenv("REQUEST_TIMEOUT_SECONDS", "8"))
|
||||
|
||||
|
||||
class RequestIDMiddleware(BaseHTTPMiddleware):
|
||||
async def dispatch(self, request: Request, call_next):
|
||||
request_id = str(uuid.uuid4())
|
||||
request.state.request_id = request_id
|
||||
try:
|
||||
# Жёсткий дедлайн: зависшая БД/кэш не должны держать запрос дольше REQUEST_TIMEOUT
|
||||
response = await asyncio.wait_for(call_next(request), timeout=REQUEST_TIMEOUT)
|
||||
except asyncio.TimeoutError:
|
||||
return _error(request, 503, "unavailable", "Service temporarily unavailable")
|
||||
response.headers["X-Request-Id"] = request_id
|
||||
return response
|
||||
|
||||
|
||||
app.add_middleware(RequestIDMiddleware)
|
||||
|
||||
|
||||
# 2. Глобальный обработчик ошибок под формат OpenAPI
|
||||
@app.exception_handler(HTTPException)
|
||||
async def custom_http_exception_handler(request: Request, exc: HTTPException):
|
||||
code_map = {
|
||||
400: "invalid_request", 401: "unauthorized", 403: "unauthorized",
|
||||
404: "not_found", 409: "conflict", 413: "payload_too_large",
|
||||
415: "unsupported_media_type", 429: "rate_limited", 503: "unavailable",
|
||||
500: "internal_error",
|
||||
}
|
||||
message = exc.detail if isinstance(exc.detail, str) else "An error occurred"
|
||||
return _error(request, exc.status_code, code_map.get(exc.status_code, "internal_error"),
|
||||
message, headers=exc.headers)
|
||||
|
||||
|
||||
# 3. Недоступность БД/таймауты -> 503 (а не зависание или 500)
|
||||
async def unavailable_handler(request: Request, exc: Exception):
|
||||
return _error(request, 503, "unavailable", "Service temporarily unavailable")
|
||||
|
||||
|
||||
for _exc in (OperationalError, InterfaceError, SATimeoutError, TimeoutError, OSError):
|
||||
app.add_exception_handler(_exc, unavailable_handler)
|
||||
|
||||
|
||||
# --- Healthcheck ---
|
||||
@app.get("/health/live")
|
||||
async def health_live():
|
||||
return {"status": "ok"}
|
||||
|
||||
|
||||
@app.get("/health/ready")
|
||||
async def health_ready():
|
||||
async def probe():
|
||||
async with engine.connect() as conn:
|
||||
await conn.execute(text("SELECT 1 FROM users LIMIT 1"))
|
||||
|
||||
task = asyncio.create_task(probe())
|
||||
# забираем исключение фоновой задачи, чтобы не было "exception was never retrieved"
|
||||
task.add_done_callback(lambda t: t.cancelled() or t.exception())
|
||||
|
||||
done, _ = await asyncio.wait({task}, timeout=2)
|
||||
if not done:
|
||||
task.cancel() # очистка соединения идёт в фоне и не задерживает ответ
|
||||
raise HTTPException(status_code=503, detail="Database not ready")
|
||||
if task.exception() is not None:
|
||||
raise HTTPException(status_code=503, detail="Database not ready")
|
||||
return {"status": "ok"}
|
||||
|
||||
|
||||
# --- Регистрация ---
|
||||
@app.post("/api/v1/users", status_code=status.HTTP_201_CREATED, response_model=UserResponse)
|
||||
async def create_user(user_data: UserCreate, db: AsyncSession = Depends(get_db)):
|
||||
pw_hash = await run_in_threadpool(hash_password, user_data.password) # не блокируем event loop
|
||||
new_user = User(username=user_data.username,
|
||||
display_name=user_data.display_name,
|
||||
password_hash=pw_hash)
|
||||
db.add(new_user)
|
||||
try:
|
||||
await db.commit()
|
||||
except IntegrityError: # гонка одинакового username решается UNIQUE-ограничением
|
||||
await db.rollback()
|
||||
raise HTTPException(status_code=409, detail="Username already exists")
|
||||
return UserResponse(id=str(new_user.id), username=new_user.username,
|
||||
display_name=new_user.display_name, created_at=new_user.created_at)
|
||||
|
||||
|
||||
# --- Аутентификация ---
|
||||
security_basic = HTTPBasic()
|
||||
|
||||
|
||||
@app.post("/api/v1/auth/sessions", status_code=status.HTTP_201_CREATED,
|
||||
response_model=SessionResponse)
|
||||
async def create_session(credentials: HTTPBasicCredentials = Security(security_basic),
|
||||
db: AsyncSession = Depends(get_db)):
|
||||
user = (await db.execute(
|
||||
select(User).where(User.username == credentials.username))).scalar_one_or_none()
|
||||
|
||||
ok = await run_in_threadpool(verify_password, credentials.password,
|
||||
user.password_hash if user else DUMMY_HASH)
|
||||
if not user or not ok:
|
||||
raise HTTPException(
|
||||
status_code=401,
|
||||
detail="Invalid username or password",
|
||||
headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'},
|
||||
)
|
||||
|
||||
token = generate_token()
|
||||
expires_at = get_token_expiry() # SESSION_TTL_SECONDS
|
||||
|
||||
db.add(Session(user_id=user.id, token=token, expires_at=expires_at))
|
||||
await db.commit()
|
||||
|
||||
return SessionResponse(
|
||||
token=token, token_type="Bearer", expires_at=expires_at,
|
||||
user=UserResponse(id=str(user.id), username=user.username,
|
||||
display_name=user.display_name, created_at=user.created_at),
|
||||
)
|
||||
|
||||
|
||||
# --- Logout: отзывается только предъявленная сессия ---
|
||||
@app.delete("/api/v1/auth/sessions/current", status_code=status.HTTP_204_NO_CONTENT)
|
||||
async def delete_session(credentials: HTTPAuthorizationCredentials = Security(security),
|
||||
current_user=Depends(get_current_user),
|
||||
db: AsyncSession = Depends(get_db)):
|
||||
token = credentials.credentials
|
||||
await db.execute(delete(Session).where(Session.token == token,
|
||||
Session.user_id == current_user.id))
|
||||
await db.commit() # сначала фиксируем отзыв в PostgreSQL ...
|
||||
await cache_delete(token) # ... затем инвалидируем кэш
|
||||
|
||||
|
||||
# --- Текущий пользователь ---
|
||||
@app.get("/api/v1/users/me", response_model=UserResponse)
|
||||
async def get_me(current_user=Depends(get_current_user)):
|
||||
return UserResponse(id=str(current_user.id), username=current_user.username,
|
||||
display_name=current_user.display_name,
|
||||
created_at=current_user.created_at)
|
||||
|
||||
|
||||
# --- Создание чата ---
|
||||
@app.post("/api/v1/chats", status_code=status.HTTP_201_CREATED)
|
||||
async def create_chat(chat_data: CreateChat, current_user=Depends(get_current_user),
|
||||
db: AsyncSession = Depends(get_db)):
|
||||
ids = chat_data.member_ids # уникальность и формат UUID проверены схемой
|
||||
if current_user.id not in ids:
|
||||
raise HTTPException(status_code=400, detail="Creator must be in member_ids")
|
||||
|
||||
found = (await db.execute(select(User.id).where(User.id.in_(ids)))).scalars().all()
|
||||
if len(found) != len(ids):
|
||||
raise HTTPException(status_code=400, detail="Unknown member") # по контракту 400
|
||||
|
||||
new_chat = Chat(title=chat_data.title)
|
||||
db.add(new_chat)
|
||||
await db.flush()
|
||||
db.add_all([ChatMember(chat_id=new_chat.id, user_id=m) for m in ids])
|
||||
await db.commit() # чат и участники - одна транзакция
|
||||
|
||||
return {"id": str(new_chat.id), "title": new_chat.title,
|
||||
"member_ids": [str(m) for m in ids],
|
||||
"created_at": format_dt(new_chat.created_at)}
|
||||
|
||||
|
||||
# --- Список чатов: keyset по (created_at, id) по возрастанию ---
|
||||
@app.get("/api/v1/chats")
|
||||
async def list_chats(limit: int = Query(50, ge=1, le=100),
|
||||
cursor: Optional[str] = Query(None),
|
||||
current_user=Depends(get_current_user),
|
||||
db: AsyncSession = Depends(get_db)):
|
||||
scope = f"chats:{current_user.id}"
|
||||
query = (select(Chat)
|
||||
.join(ChatMember, Chat.id == ChatMember.chat_id)
|
||||
.where(ChatMember.user_id == current_user.id)
|
||||
.order_by(Chat.created_at.asc(), Chat.id.asc())
|
||||
.limit(limit + 1))
|
||||
if cursor:
|
||||
c_ts, c_id = decode_cursor(cursor, scope)
|
||||
query = query.where(tuple_(Chat.created_at, Chat.id) > tuple_(c_ts, c_id))
|
||||
|
||||
chats = (await db.execute(query)).scalars().all()
|
||||
has_next = len(chats) > limit
|
||||
chats = chats[:limit]
|
||||
|
||||
members = defaultdict(list)
|
||||
if chats:
|
||||
rows = await db.execute(select(ChatMember.chat_id, ChatMember.user_id)
|
||||
.where(ChatMember.chat_id.in_([c.id for c in chats])))
|
||||
for cid, uid in rows.all():
|
||||
members[cid].append(str(uid))
|
||||
|
||||
return {
|
||||
"items": [{"id": str(c.id), "title": c.title, "member_ids": members[c.id],
|
||||
"created_at": format_dt(c.created_at)} for c in chats],
|
||||
"next_cursor": (encode_cursor(chats[-1].created_at, chats[-1].id, scope)
|
||||
if has_next else None),
|
||||
}
|
||||
|
||||
|
||||
# --- Получение чата ---
|
||||
@app.get("/api/v1/chats/{chat_id}")
|
||||
async def get_chat(chat_id: uuid.UUID, current_user=Depends(get_current_user),
|
||||
db: AsyncSession = Depends(get_db)):
|
||||
chat = (await db.execute(select(Chat).where(Chat.id == chat_id))).scalar_one_or_none()
|
||||
if not chat:
|
||||
raise HTTPException(status_code=404, detail="Chat not found")
|
||||
|
||||
if not (await db.execute(select(ChatMember).where(
|
||||
ChatMember.chat_id == chat_id,
|
||||
ChatMember.user_id == current_user.id))).scalar_one_or_none():
|
||||
raise HTTPException(status_code=404, detail="Chat not accessible")
|
||||
|
||||
members = [str(r[0]) for r in (await db.execute(
|
||||
select(ChatMember.user_id).where(ChatMember.chat_id == chat_id))).all()]
|
||||
return {"id": str(chat.id), "title": chat.title, "member_ids": members,
|
||||
"created_at": format_dt(chat.created_at)}
|
||||
|
||||
|
||||
# --- Отправка сообщения ---
|
||||
@app.post("/api/v1/chats/{chat_id}/messages", status_code=status.HTTP_201_CREATED)
|
||||
async def send_message(chat_id: uuid.UUID, msg_data: CreateMessage,
|
||||
current_user=Depends(get_current_user),
|
||||
db: AsyncSession = Depends(get_db)):
|
||||
if not (await db.execute(select(ChatMember).where(
|
||||
ChatMember.chat_id == chat_id,
|
||||
ChatMember.user_id == current_user.id))).scalar_one_or_none():
|
||||
raise HTTPException(status_code=404, detail="Chat not accessible")
|
||||
|
||||
msg = Message(chat_id=chat_id, sender_id=current_user.id, text=msg_data.text)
|
||||
db.add(msg)
|
||||
await db.commit()
|
||||
await db.refresh(msg)
|
||||
|
||||
return {"id": str(msg.id), "chat_id": str(msg.chat_id), "sender_id": str(msg.sender_id),
|
||||
"text": msg.text, "created_at": format_dt(msg.created_at)}
|
||||
|
||||
|
||||
# --- История сообщений: keyset по (created_at, id) по возрастанию ---
|
||||
@app.get("/api/v1/chats/{chat_id}/messages")
|
||||
async def list_messages(chat_id: uuid.UUID, limit: int = Query(50, ge=1, le=100),
|
||||
cursor: Optional[str] = Query(None),
|
||||
current_user=Depends(get_current_user),
|
||||
db: AsyncSession = Depends(get_db)):
|
||||
if not (await db.execute(select(ChatMember).where(
|
||||
ChatMember.chat_id == chat_id,
|
||||
ChatMember.user_id == current_user.id))).scalar_one_or_none():
|
||||
raise HTTPException(status_code=404, detail="Chat not accessible")
|
||||
|
||||
scope = f"chat:{chat_id}" # курсор привязан к чату
|
||||
query = (select(Message).where(Message.chat_id == chat_id)
|
||||
.order_by(Message.created_at.asc(), Message.id.asc())
|
||||
.limit(limit + 1))
|
||||
if cursor:
|
||||
c_ts, c_id = decode_cursor(cursor, scope)
|
||||
query = query.where(tuple_(Message.created_at, Message.id) > tuple_(c_ts, c_id))
|
||||
|
||||
rows = (await db.execute(query)).scalars().all()
|
||||
has_next = len(rows) > limit
|
||||
rows = rows[:limit]
|
||||
|
||||
return {
|
||||
"items": [{"id": str(m.id), "chat_id": str(m.chat_id), "sender_id": str(m.sender_id),
|
||||
"text": m.text, "created_at": format_dt(m.created_at)} for m in rows],
|
||||
"next_cursor": (encode_cursor(rows[-1].created_at, rows[-1].id, scope)
|
||||
if has_next else None),
|
||||
}
|
||||
@@ -0,0 +1,76 @@
|
||||
import uuid
|
||||
from datetime import datetime, timezone
|
||||
|
||||
from sqlalchemy import Column, String, DateTime, ForeignKey, Text, Index
|
||||
from sqlalchemy.dialects.postgresql import UUID
|
||||
from sqlalchemy.orm import relationship
|
||||
|
||||
from src.database import Base
|
||||
|
||||
|
||||
def get_now_utc():
|
||||
return datetime.now(timezone.utc)
|
||||
|
||||
|
||||
class User(Base):
|
||||
__tablename__ = "users"
|
||||
|
||||
id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
|
||||
username = Column(String(32), unique=True, nullable=False, index=True)
|
||||
display_name = Column(String(100), nullable=False)
|
||||
password_hash = Column(String(255), nullable=False)
|
||||
created_at = Column(DateTime(timezone=True), default=get_now_utc)
|
||||
|
||||
sessions = relationship("Session", back_populates="user", cascade="all, delete-orphan")
|
||||
chats = relationship("ChatMember", back_populates="user", cascade="all, delete-orphan")
|
||||
messages = relationship("Message", back_populates="sender", cascade="all, delete-orphan")
|
||||
|
||||
|
||||
class Session(Base):
|
||||
__tablename__ = "sessions"
|
||||
|
||||
id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
|
||||
user_id = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
|
||||
token = Column(String(255), unique=True, nullable=False, index=True) # opaque Bearer
|
||||
expires_at = Column(DateTime(timezone=True), nullable=False)
|
||||
created_at = Column(DateTime(timezone=True), default=get_now_utc)
|
||||
|
||||
user = relationship("User", back_populates="sessions")
|
||||
|
||||
|
||||
class Chat(Base):
|
||||
__tablename__ = "chats"
|
||||
|
||||
id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
|
||||
title = Column(String(100), nullable=False)
|
||||
created_at = Column(DateTime(timezone=True), default=get_now_utc)
|
||||
|
||||
members = relationship("ChatMember", back_populates="chat", cascade="all, delete-orphan")
|
||||
messages = relationship("Message", back_populates="chat", cascade="all, delete-orphan")
|
||||
|
||||
|
||||
class ChatMember(Base):
|
||||
__tablename__ = "chat_members"
|
||||
|
||||
chat_id = Column(UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), primary_key=True)
|
||||
user_id = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), primary_key=True)
|
||||
joined_at = Column(DateTime(timezone=True), default=get_now_utc)
|
||||
|
||||
chat = relationship("Chat", back_populates="members")
|
||||
user = relationship("User", back_populates="chats")
|
||||
|
||||
|
||||
class Message(Base):
|
||||
__tablename__ = "messages"
|
||||
|
||||
id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
|
||||
chat_id = Column(UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), nullable=False)
|
||||
sender_id = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
|
||||
text = Column(Text, nullable=False)
|
||||
created_at = Column(DateTime(timezone=True), default=get_now_utc)
|
||||
|
||||
chat = relationship("Chat", back_populates="messages")
|
||||
sender = relationship("User", back_populates="messages")
|
||||
|
||||
# Индекс под keyset-историю: равенство по chat_id, затем порядок (created_at, id)
|
||||
__table_args__ = (Index("ix_messages_chat_created_id", "chat_id", "created_at", "id"),)
|
||||
@@ -0,0 +1,26 @@
|
||||
import base64
|
||||
import json
|
||||
import uuid
|
||||
from datetime import datetime, timezone
|
||||
|
||||
from fastapi import HTTPException
|
||||
|
||||
|
||||
def encode_cursor(created_at: datetime, row_id: uuid.UUID, scope: str) -> str:
|
||||
"""Непрозрачный keyset-курсор: полный ключ сортировки (created_at, id) + область (чат/пользователь)."""
|
||||
raw = json.dumps({"t": created_at.isoformat(), "i": str(row_id), "s": scope},
|
||||
separators=(",", ":"))
|
||||
return base64.urlsafe_b64encode(raw.encode()).decode().rstrip("=")
|
||||
|
||||
|
||||
def decode_cursor(cursor: str, scope: str):
|
||||
try:
|
||||
data = json.loads(base64.urlsafe_b64decode(cursor + "=" * (-len(cursor) % 4)))
|
||||
if data["s"] != scope:
|
||||
raise ValueError("cursor belongs to another resource")
|
||||
ts = datetime.fromisoformat(data["t"])
|
||||
if ts.tzinfo is None:
|
||||
ts = ts.replace(tzinfo=timezone.utc)
|
||||
return ts, uuid.UUID(data["i"])
|
||||
except Exception:
|
||||
raise HTTPException(status_code=400, detail="Invalid cursor")
|
||||
@@ -0,0 +1,70 @@
|
||||
from datetime import datetime
|
||||
from uuid import UUID
|
||||
|
||||
from pydantic import BaseModel, Field, ConfigDict, field_serializer, field_validator
|
||||
|
||||
|
||||
def format_dt(dt: datetime) -> str:
|
||||
"""Форматирует datetime в ISO 8601 с суффиксом Z вместо +00:00"""
|
||||
return dt.isoformat().replace('+00:00', 'Z')
|
||||
|
||||
|
||||
def _not_blank(v: str) -> str:
|
||||
if not v.strip():
|
||||
raise ValueError("must not be blank")
|
||||
return v
|
||||
|
||||
|
||||
class UserCreate(BaseModel):
|
||||
username: str = Field(..., pattern=r"^[a-z0-9_]{3,32}$")
|
||||
display_name: str = Field(..., min_length=1, max_length=100)
|
||||
password: str = Field(..., min_length=12, max_length=128)
|
||||
|
||||
_chk_display = field_validator("display_name")(_not_blank)
|
||||
|
||||
|
||||
class UserResponse(BaseModel):
|
||||
id: str
|
||||
username: str
|
||||
display_name: str
|
||||
created_at: datetime
|
||||
model_config = ConfigDict(from_attributes=True)
|
||||
|
||||
@field_serializer('created_at')
|
||||
def serialize_dt(self, dt: datetime) -> str:
|
||||
return format_dt(dt)
|
||||
|
||||
|
||||
class SessionResponse(BaseModel):
|
||||
token: str
|
||||
token_type: str = "Bearer"
|
||||
expires_at: datetime
|
||||
user: UserResponse
|
||||
model_config = ConfigDict(from_attributes=True)
|
||||
|
||||
@field_serializer('expires_at')
|
||||
def serialize_expires(self, dt: datetime) -> str:
|
||||
return format_dt(dt)
|
||||
|
||||
|
||||
class CreateChat(BaseModel):
|
||||
title: str = Field(..., min_length=1, max_length=100)
|
||||
# TODO: сверить с contracts/openapi.json (maxItems для member_ids)
|
||||
member_ids: list[UUID] = Field(..., min_length=1)
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
|
||||
_chk_title = field_validator("title")(_not_blank)
|
||||
|
||||
@field_validator("member_ids")
|
||||
@classmethod
|
||||
def members_unique(cls, v):
|
||||
if len(set(v)) != len(v):
|
||||
raise ValueError("member_ids must be unique")
|
||||
return v
|
||||
|
||||
|
||||
class CreateMessage(BaseModel):
|
||||
text: str = Field(..., min_length=1, max_length=4000)
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
|
||||
_chk_text = field_validator("text")(_not_blank)
|
||||
@@ -0,0 +1,3 @@
|
||||
def pytest_configure(config):
|
||||
config.addinivalue_line("markers", "ttl: нужен SESSION_TTL_SECONDS=2")
|
||||
config.addinivalue_line("markers", "chaos: останавливает Valkey/PostgreSQL")
|
||||
@@ -0,0 +1,218 @@
|
||||
import os
|
||||
import subprocess
|
||||
import time
|
||||
import uuid
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
|
||||
import httpx
|
||||
import pytest
|
||||
|
||||
BASE = os.getenv("BASE_URL", "http://localhost:8080")
|
||||
API = BASE + "/api/v1"
|
||||
PW = "correct horse battery"
|
||||
|
||||
|
||||
def dc(*a):
|
||||
return subprocess.run(["docker", "compose", *a], check=True, capture_output=True, text=True)
|
||||
|
||||
|
||||
def psql(sql):
|
||||
return dc("exec", "-T", "db", "psql", "-U", "postgres", "-d", "messenger_db",
|
||||
"-v", "ON_ERROR_STOP=1", "-c", sql)
|
||||
|
||||
|
||||
def client():
|
||||
return httpx.Client(timeout=10)
|
||||
|
||||
|
||||
def register(c, username=None, password=PW):
|
||||
username = username or "u" + uuid.uuid4().hex[:12]
|
||||
r = c.post(f"{API}/users", json={"username": username, "display_name": "T", "password": password})
|
||||
assert r.status_code == 201, r.text
|
||||
return r.json()
|
||||
|
||||
|
||||
def login(c, username, password=PW):
|
||||
return c.post(f"{API}/auth/sessions", auth=(username, password))
|
||||
|
||||
|
||||
def auth(tok):
|
||||
return {"Authorization": f"Bearer {tok}"}
|
||||
|
||||
|
||||
def user_with_token(c):
|
||||
u = register(c)
|
||||
return u, login(c, u["username"]).json()["token"]
|
||||
|
||||
|
||||
def make_chat(c, tok, member_ids):
|
||||
r = c.post(f"{API}/chats", json={"title": "t", "member_ids": member_ids}, headers=auth(tok))
|
||||
assert r.status_code == 201, r.text
|
||||
return r.json()
|
||||
|
||||
|
||||
def wait_ready(timeout=30):
|
||||
end = time.time() + timeout
|
||||
while time.time() < end:
|
||||
try:
|
||||
if httpx.get(BASE + "/health/ready", timeout=3).status_code == 200:
|
||||
return
|
||||
except httpx.HTTPError:
|
||||
pass
|
||||
time.sleep(1)
|
||||
raise AssertionError("API not ready")
|
||||
|
||||
|
||||
# ---------- аутентификация ----------
|
||||
def test_wrong_password_401():
|
||||
with client() as c:
|
||||
u = register(c)
|
||||
r = login(c, u["username"], "wrong password!!")
|
||||
assert r.status_code == 401
|
||||
assert r.headers["www-authenticate"].startswith("Basic")
|
||||
|
||||
|
||||
def test_long_passwords_not_truncated():
|
||||
with client() as c:
|
||||
pw = "a" * 72 + "X" * 12
|
||||
u = register(c, password=pw)
|
||||
assert login(c, u["username"], "a" * 72 + "Y" * 12).status_code == 401
|
||||
assert login(c, u["username"], pw).status_code == 201
|
||||
|
||||
|
||||
def test_logout_revokes_only_current_session():
|
||||
with client() as c:
|
||||
u = register(c)
|
||||
t1 = login(c, u["username"]).json()["token"]
|
||||
t2 = login(c, u["username"]).json()["token"]
|
||||
assert c.delete(f"{API}/auth/sessions/current", headers=auth(t1)).status_code == 204
|
||||
assert c.get(f"{API}/users/me", headers=auth(t1)).status_code == 401
|
||||
assert c.get(f"{API}/users/me", headers=auth(t2)).status_code == 200
|
||||
assert c.delete(f"{API}/auth/sessions/current", headers=auth(t1)).status_code == 401
|
||||
|
||||
|
||||
def test_logout_invalidates_cache_immediately():
|
||||
with client() as c:
|
||||
_, tok = user_with_token(c)
|
||||
assert c.get(f"{API}/users/me", headers=auth(tok)).status_code == 200 # прогрели кэш
|
||||
c.delete(f"{API}/auth/sessions/current", headers=auth(tok))
|
||||
assert c.get(f"{API}/users/me", headers=auth(tok)).status_code == 401
|
||||
|
||||
|
||||
@pytest.mark.ttl
|
||||
def test_session_expires():
|
||||
with client() as c:
|
||||
_, tok = user_with_token(c)
|
||||
assert c.get(f"{API}/users/me", headers=auth(tok)).status_code == 200
|
||||
time.sleep(3.5)
|
||||
assert c.get(f"{API}/users/me", headers=auth(tok)).status_code == 401
|
||||
|
||||
|
||||
# ---------- гонки и откат ----------
|
||||
def test_register_race_one_winner():
|
||||
name = "race" + uuid.uuid4().hex[:10]
|
||||
|
||||
def go(_):
|
||||
with client() as c:
|
||||
return c.post(f"{API}/users", json={"username": name, "display_name": "T",
|
||||
"password": PW}).status_code
|
||||
|
||||
with ThreadPoolExecutor(10) as ex:
|
||||
codes = list(ex.map(go, range(10)))
|
||||
assert codes.count(201) == 1 and codes.count(409) == 9, codes
|
||||
|
||||
|
||||
def test_chat_validation_and_rollback():
|
||||
with client() as c:
|
||||
u, tok = user_with_token(c)
|
||||
before = c.get(f"{API}/chats", headers=auth(tok)).json()["items"]
|
||||
for ids in ([u["id"], u["id"]], # дубликат
|
||||
[u["id"], str(uuid.uuid4())], # неизвестный участник
|
||||
[str(uuid.uuid4())]): # нет вызывающего
|
||||
r = c.post(f"{API}/chats", json={"title": "t", "member_ids": ids}, headers=auth(tok))
|
||||
assert r.status_code == 400, (ids, r.text)
|
||||
assert c.get(f"{API}/chats", headers=auth(tok)).json()["items"] == before
|
||||
|
||||
|
||||
# ---------- пагинация ----------
|
||||
def test_cursor_garbage_and_foreign_cursor_400():
|
||||
with client() as c:
|
||||
u, tok = user_with_token(c)
|
||||
c1, c2 = make_chat(c, tok, [u["id"]]), make_chat(c, tok, [u["id"]])
|
||||
for i in range(2):
|
||||
c.post(f"{API}/chats/{c1['id']}/messages", json={"text": f"m{i}"}, headers=auth(tok))
|
||||
assert c.get(f"{API}/chats/{c1['id']}/messages?cursor=garbage", headers=auth(tok)).status_code == 400
|
||||
assert c.get(f"{API}/chats?cursor=garbage", headers=auth(tok)).status_code == 400
|
||||
nxt = c.get(f"{API}/chats/{c1['id']}/messages?limit=1", headers=auth(tok)).json()["next_cursor"]
|
||||
assert nxt
|
||||
assert c.get(f"{API}/chats/{c2['id']}/messages?cursor={nxt}", headers=auth(tok)).status_code == 400
|
||||
|
||||
|
||||
def test_pagination_with_equal_timestamps():
|
||||
with client() as c:
|
||||
u, tok = user_with_token(c)
|
||||
chat = make_chat(c, tok, [u["id"]])
|
||||
vals = ",".join(f"(gen_random_uuid(),'{chat['id']}','{u['id']}','m{i}','2026-01-01T00:00:00Z')"
|
||||
for i in range(3))
|
||||
psql(f"INSERT INTO messages(id,chat_id,sender_id,text,created_at) VALUES {vals}")
|
||||
seen, cursor = [], None
|
||||
for _ in range(5):
|
||||
url = f"{API}/chats/{chat['id']}/messages?limit=1" + (f"&cursor={cursor}" if cursor else "")
|
||||
page = c.get(url, headers=auth(tok)).json()
|
||||
seen += [m["id"] for m in page["items"]]
|
||||
cursor = page["next_cursor"]
|
||||
if not cursor:
|
||||
break
|
||||
assert len(seen) == 3 and len(set(seen)) == 3
|
||||
|
||||
|
||||
def test_pagination_full_walk_in_order():
|
||||
with client() as c:
|
||||
u, tok = user_with_token(c)
|
||||
chat = make_chat(c, tok, [u["id"]])
|
||||
sent = [c.post(f"{API}/chats/{chat['id']}/messages", json={"text": f"m{i}"},
|
||||
headers=auth(tok)).json()["id"] for i in range(5)]
|
||||
got, cursor = [], None
|
||||
while True:
|
||||
url = f"{API}/chats/{chat['id']}/messages?limit=2" + (f"&cursor={cursor}" if cursor else "")
|
||||
page = c.get(url, headers=auth(tok)).json()
|
||||
got += [m["id"] for m in page["items"]]
|
||||
cursor = page["next_cursor"]
|
||||
if not cursor:
|
||||
break
|
||||
assert got == sent
|
||||
|
||||
|
||||
# ---------- отказы зависимостей ----------
|
||||
@pytest.mark.chaos
|
||||
def test_valkey_down_falls_back_to_db():
|
||||
with client() as c:
|
||||
_, tok = user_with_token(c)
|
||||
dc("stop", "valkey")
|
||||
try:
|
||||
assert c.get(f"{API}/users/me", headers=auth(tok)).status_code == 200 # обход кэша
|
||||
assert c.get(f"{API}/users/me").status_code == 401 # аноним не доверенный
|
||||
assert c.get(f"{API}/users/me", headers={"Authorization": "Bearer nope"}).status_code == 401
|
||||
finally:
|
||||
dc("start", "valkey")
|
||||
time.sleep(2)
|
||||
assert c.get(f"{API}/users/me", headers=auth(tok)).status_code == 200
|
||||
|
||||
|
||||
@pytest.mark.chaos
|
||||
def test_db_paused_returns_503_and_recovers():
|
||||
with client() as c:
|
||||
_, tok = user_with_token(c)
|
||||
dc("pause", "db")
|
||||
try:
|
||||
t0 = time.time()
|
||||
r = httpx.get(BASE + "/health/ready", timeout=8)
|
||||
assert r.status_code == 503
|
||||
assert time.time() - t0 < 5
|
||||
assert c.get(f"{API}/users/me").status_code == 401
|
||||
r = httpx.get(f"{API}/chats", headers=auth(tok), timeout=20)
|
||||
assert r.status_code == 503 and r.json()["error"]["code"] == "unavailable"
|
||||
finally:
|
||||
dc("unpause", "db")
|
||||
wait_ready()
|
||||
assert c.get(f"{API}/chats", headers=auth(tok)).status_code == 200
|
||||
Reference in New Issue
Block a user