ЛР 2 - БВТ2304 - Осипов Артём - на 4 #146

Open
Art wants to merge 2 commits from Art/mtusi2026lab2:master into master
31 changed files with 1708 additions and 209 deletions
+2
View File
@@ -18,3 +18,5 @@ __pycache__
node_modules
evidence
.DS_Store
.venv
venv
+29
View File
@@ -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"]
+3
View File
@@ -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
+10 -98
View File
@@ -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/`.
+160 -24
View File
@@ -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
View File
@@ -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
+1
View File
@@ -0,0 +1 @@
Generic single-database configuration.
+61
View File
@@ -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()
+28
View File
@@ -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 ###
+68
View File
@@ -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:
+58
View File
@@ -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)
+15
View File
@@ -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
-54
View File
@@ -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()
+26
View File
@@ -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"
-10
View File
@@ -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
+14
View File
@@ -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 "✅ Сервисы успешно перезапущены и готовы к работе!"
+25
View File
@@ -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;
+39
View File
@@ -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"
-23
View File
@@ -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
View File
@@ -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)
+51
View File
@@ -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)
+40
View File
@@ -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
+77
View File
@@ -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
View File
@@ -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),
}
+76
View File
@@ -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"),)
+26
View File
@@ -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")
+70
View File
@@ -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)
+3
View File
@@ -0,0 +1,3 @@
def pytest_configure(config):
config.addinivalue_line("markers", "ttl: нужен SESSION_TTL_SECONDS=2")
config.addinivalue_line("markers", "chaos: останавливает Valkey/PostgreSQL")
+218
View File
@@ -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