ЛР 2 - БВТ2303 - Кропивка - на 4 #7

Closed
Viktoria wants to merge 3 commits from Viktoria/mtusi2026lab2:solution/БВТ-23-Кропивка into master
30 changed files with 2415 additions and 35 deletions
+32 -20
View File
@@ -1,20 +1,32 @@
.git
.github
.env
.env.*
!.env.example
secrets
certs
volumes
data
backups
*.key
*.pem
*.p12
*.pfx
*.jks
.venv
__pycache__
node_modules
evidence
.DS_Store
.git
.github
.env
.env.*
!.env.example
.venv
venv
__pycache__
*.pyc
*.pyo
*.pyd
.mypy_cache
.ruff_cache
.pytest_cache
secrets
certs
volumes
data
backups
tests
scripts
examples
contracts
infra
evidence
output
README.md
COURSE.md
CONTRIBUTING.md
MAINTAINERS.md
REPORT.md
*.md
Executable
+29
View File
@@ -0,0 +1,29 @@
FROM python:3.12-slim AS runtime
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
PIP_NO_CACHE_DIR=1 \
APP_HOST=0.0.0.0 \
APP_PORT=8080
WORKDIR /app
COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt
COPY alembic.ini ./
COPY migrations ./migrations
COPY src ./src
# непривилегированный пользователь
RUN useradd --create-home --shell /usr/sbin/nologin appuser \
&& chown -R appuser:appuser /app
USER appuser
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
CMD python -c "import urllib.request,sys; \
sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/live', timeout=2).status==200 else 1)"
CMD ["sh", "-c", "alembic upgrade head && exec python -m src.main"]
+317 -15
View File
@@ -1,37 +1,339 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Кропивка, БВТ2303
- Целевая оценка: 4 (уровень 3 + уровень 4)
- Commit/PR: ветка `solution/БВТ-23-Кропивка`, PR после финального push
- Использованные источники, библиотеки и помощь ИИ: FastAPI 0.115.0, Uvicorn 0.30.6, Pydantic 2.9.2, psycopg 3.2.3, psycopg-pool 3.2.3, Alembic 1.13.3, argon2-cffi 23.1.0, redis 5.1.1, PostgreSQL 16.4-alpine, Valkey 8.0.1-alpine, python:3.12-slim. При подготовке решения использовался ассистент (LLM) для генерации черновика кода и объяснения контракта; итоговый код проверен публичным smoke, тестом сохранности, тестами гонки/rollback/expiry, EXPLAIN и вручную.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Prerequisites:
- Docker 29.2.1 (Docker Desktop для Windows + WSL2)
- Python 3.9+ (только для запуска тестов; приложение работает в контейнере)
- Git
Шаги:
1. Клонировать репозиторий и перейти в него.
2. Создать локальный `.env` из примера:
```sh
cp .env.example .env
```
Заполнить:
```
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
POSTGRES_USER=messenger
POSTGRES_PASSWORD=changeme_local_only
POSTGRES_DB=messenger
DATABASE_URL=postgresql://messenger:changeme_local_only@postgres:5432/messenger
SESSION_STORE=postgres
CACHE_URL=redis://cache:6379/0
REVOKED_TTL_SECONDS=86400
```
3. Поднять стек:
```sh
docker compose --env-file .env up -d --build
```
Compose:
- `postgres` (образ `postgres:16.4-alpine`, named volume `mtusi_lab2_postgres_data`, публикуется только на `127.0.0.1:5433`),
- `cache` (образ `valkey/valkey:8.0.1-alpine`, named volume `mtusi_lab2_cache_data`, публикуется только на `127.0.0.1:6380`),
- `api` (сборка из локального `Dockerfile`, слушает `127.0.0.1:8080`).
`depends_on: condition: service_healthy` для обоих сервисов гарантирует, что API стартует только после готовности Postgres и Valkey. Миграции применяются в `CMD` контейнера:
```dockerfile
CMD ["sh", "-c", "alembic upgrade head && exec python -m src.main"]
```
Важно: `CMD` в exec-форме (`["python", "-m", "src.main", "..."]`) не выполняет shell-операторы. `alembic upgrade head && exec ...` работает только через `sh -c "..."`.
4. Дождаться готовности:
```sh
docker compose ps
```
Ожидаемо: все три сервиса `Up (... healthy)`.
5. Прогнать публичный smoke, тест сохранности и собственные тесты:
```sh
make test BASE_URL=http://localhost:8080
make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://localhost:8080
python3 student_tests/test_races.py --base-url http://localhost:8080
python3 student_tests/test_expiry.py --base-url http://localhost:8080 # требует SESSION_TTL_SECONDS=2
python3 student_tests/test_cache_failure.py
python3 student_tests/test_db_failure.py
```
6. Остановить:
```sh
docker compose --env-file .env down
```
**Данные сохраняются** в named volumes и переживут следующий `up`.
**Безопасная остановка** — `docker compose down` (без `-v`). Флаг `-v` удаляет volumes и все данные.
**Намеренное удаление учебных данных:**
```sh
docker compose --env-file .env down -v
```
Используется осознанно, только когда нужен чистый стенд.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
- **Процессы.** API (Uvicorn + FastAPI), PostgreSQL и Valkey (кэш). API слушает `0.0.0.0:8080` внутри контейнера, публикуется на `127.0.0.1:8080` хоста. Postgres публикуется на `127.0.0.1:5433`, Valkey — на `127.0.0.1:6380` (порты 5432/6379 заняты локально).
- **Источник истины — PostgreSQL.** Все данные: пользователи, чаты, членство, сообщения, сессии. In-memory хранилища lab1 не осталось.
- **Роль Valkey.** Кэш проверки Bearer-токена. **Не** источник истины: при рестарте кэш холодный, но данные и сессии целы в Postgres. Persistence отключён (`--save "" --appendonly no`) — это осознанное решение, потому что кэш не является единственным хранилищем сессий.
### Инвалидация сессий при недоступном Valkey
Кэш сессий не является источником истины. Логика работы:
- При логине `create_session` кладёт `session:<token_hash> → user_id` в Redis с TTL = `SESSION_TTL_SECONDS`.
- При запросе `get_user_id_by_token`:
1. **Сначала проверяется tombstone** `revoked:<token_hash>`. Если он есть — сразу 401, независимо от того, что лежит в `session:*`.
2. **Затем всегда идёт проверка в PostgreSQL** — источник истины. Cache hit не может «воскресить» отозванную сессию, потому что сессия должна существовать в БД.
3. Если сессия валидна — обновляется `session:*` в Redis с TTL до конца жизни сессии.
- При logout `revoke_session`:
1. **Сначала ставит tombstone** `revoked:<token_hash>` в Redis (до удаления из БД). Это гарантирует, что нет окна, когда сессия уже удалена из БД, но старый `session:*` ещё жив.
2. Затем удаляет строку из `sessions` в PostgreSQL.
3. Затем удаляет `session:<token_hash>` из Redis.
- Если Valkey недоступен в момент logout — отзыв буферизуется в памяти процесса (`_pending_revocations`) и проигрывается при следующем успешном `init_cache()`.
- При каждом `init_cache()` **сбрасывается весь префикс `session:*`** через `SCAN + DEL`. Обоснование: за время недоступности Valkey сессия могла быть отозвана, а кэш об этом не знает. Кэш — не источник истины, сбрасывать его безопасно.
Tombstone живёт `REVOKED_TTL_SECONDS=86400` — с запасом перекрывает возможный TTL сессии.
### Таймауты при недоступности PostgreSQL
Пул соединений настроен с тремя уровнями защиты:
- **`statement_timeout=5000`** — на стороне Postgres, прерывает зависший SQL.
- **`lock_timeout=3000`** — ограничивает ожидание блокировок.
- **`idle_in_transaction_session_timeout=10000`** — закрывает «зависшие» сессии в открытой транзакции без активности.
Эти параметры заданы через `options` в **DSN**, а не в `kwargs` пула. `kwargs` в `psycopg_pool` не всегда надёжно доходят до libpq, поэтому DSN — предпочтительный способ:
```python
dsn_with_opts = dsn + sep + "options=" + \
"-c%20statement_timeout%3D5000" + \
"%20-c%20lock_timeout%3D3000" + \
"%20-c%20idle_in_transaction_session_timeout%3D10000"
```
Дополнительно пул использует:
- **`check=ConnectionPool.check_connection`** — проверка соединения перед выдачей. Мёртвое соединение закрывается, вместо него создаётся новое.
- **`max_lifetime=120`** — пересоздание соединения раз в 2 минуты.
- **`max_idle=60`** — закрытие простаивающих соединений.
Это предотвращает накопление мёртвых соединений после отказов БД и даёт API быстро возвращать 500/503 при остановке Postgres.
### Остальные решения
- **Политика expiry и инвалидации кэша.** См. выше.
- **Транзакционные границы.**
- `create_user`: одна вставка. Уникальность username гарантирует `UNIQUE` constraint → `409`. Гонка регистрации проверена отдельным тестом.
- `create_chat`: `INSERT` чата + `INSERT` участников внутри одной транзакции (атомарность). Rollback проверен отдельным тестом.
- `add_message`: проверка членства + `INSERT` внутри одной транзакции.
- **Аутентификация.**
- `password` хешируется **Argon2id** (`argon2-cffi`).
- `POST /auth/sessions` принимает только `Authorization: Basic base64(username:password)`.
- Возвращает opaque Bearer-токен: `secrets.token_urlsafe(32)` = 256 бит энтропии.
- В БД хранится SHA-256 от токена (в отличие от паролей). SHA-256 уместен: токен имеет высокую энтропию и не перебирается.
- TTL — `SESSION_TTL_SECONDS` (по умолчанию 3600 секунд). Просроченные сессии игнорируются. Проверено отдельным тестом с TTL=2.
- `X-User-Id` полностью игнорируется.
- **Пагинация.** Keyset-cursor по `(created_at, id)` по возрастанию. Cursor привязан к scope (`chats:<user_id>` или `chat:<chat_id>`). Индекс `messages_history_idx (chat_id, created_at, id)` покрывает запрос.
- **Connection pool и таймауты.**
- `psycopg_pool.ConnectionPool`, `min_size=1`, `max_size=10`, `timeout=5.0`.
- Все запросы параметризованы (`%s`), никакой конкатенации SQL с пользовательским вводом.
- Redis: `socket_connect_timeout=1.0`, `socket_timeout=1.0` (в `redis-py` этот параметр корректный, в отличие от psycopg).
## Доказательства критериев
### Уровень 3
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Публичный smoke | `make test BASE_URL=http://localhost:8080` | `PASS: lab2 public API scenario` | `evidence/smoke.txt` |
| Минимум lab1 сохранён (с новым auth) | smoke проверяет health, users, chats, messages, пагинацию | все проверки PASS | `evidence/smoke.txt` |
| PostgreSQL содержит users/chats/members/messages | `docker compose exec postgres psql -U messenger -d messenger -c "\dt"` | таблицы `users`, `chats`, `chat_members`, `messages`, `sessions`, `alembic_version` | вывод терминала |
| Миграции с нуля | `alembic upgrade head` на пустом volume | применяется ревизия `447472b8acec` | вывод терминала |
| Идемпотентность миграций | повторный `alembic upgrade head` | ничего не применяется | вывод терминала |
| Atomic create chat | покрыто тестом `store.create_chat` | INSERT чата + участников в одной транзакции | `src/store.py` |
| Basic только на POST /auth/sessions | smoke проверяет Basic на бизнес-endpoint → 401 | PASS | `evidence/smoke.txt` |
| X-User-Id не даёт доступ | smoke: `GET /users/me` с `X-User-Id` и валидным Bearer | возвращает владельца Bearer | `evidence/smoke.txt` |
| Password KDF | Argon2id | хеш `$argon2id$v=19$m=65536,t=3,p=4$...` | вывод `hash_password` |
| Test persistence | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS: persistence preserved confirmed data and existing session` | `evidence/persistence.txt` |
| Secrets/volumes не в git | `git status` | `.env` не появляется | `.gitignore` |
| Docker Compose с volumes | `docker compose ps` | named volumes `mtusi_lab2_postgres_data`, `mtusi_lab2_cache_data` | `evidence/compose_ps.txt` |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
### Уровень 4
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Redis/Valkey используется для сессий с TTL | `docker compose logs api \| grep -i cache` | `cache connected`; кэш хранит `session:<token_hash>` | вывод терминала |
| Источник истины, expiry, инвалидация | `test_cache_failure.py` (данные и сессия выживают без Redis) | Postgres — источник истины; Redis — кэш | `evidence/cache_failure.txt` |
| Параметризованные запросы, connection pool, таймауты | `src/db.py` (pool + options), `src/store.py` (`%s`), `src/cache.py` (таймауты 1с) | см. файлы | `src/db.py`, `src/store.py`, `src/cache.py` |
| Гонка регистрации | `python3 student_tests/test_races.py --base-url http://localhost:8080` | `HTTP codes: [201, 409]` | вывод терминала |
| Rollback составной операции | то же | `PASS: rollback — chat not created when member is unknown` | вывод терминала |
| EXPLAIN на ≥10 000 сообщениях | `EXPLAIN (ANALYZE, BUFFERS)` в psql | Index Scan 0.115 ms vs Seq Scan+Sort 2.696 ms | см. ниже |
| Expiry с коротким TTL | `SESSION_TTL_SECONDS=2 ... --force-recreate api` + `python3 student_tests/test_expiry.py` | `after TTL: 401 (expected 401)` | вывод терминала |
| **Logout при недоступном Valkey** | `python3 student_tests/test_cache_failure.py` | 4× PASS, включая `still 401 after cache restart (regression fixed)` | `evidence/cache_failure.txt` |
| **Отказ PostgreSQL < 8 сек** | `python3 student_tests/test_db_failure.py` | `DB down returned 500 in 5.0s (<8s)`, `/health/ready` → 503 | `evidence/db_failure.txt` |
| **`statement_timeout` применён** | `docker compose exec postgres psql -c 'SHOW statement_timeout;'` | `5s` | `evidence/statement_timeout.txt` |
| Недоступность Redis → degraded mode | `python3 student_tests/test_cache_failure.py` | API работает, `cache disabled after 3 consecutive failures` | `evidence/cache_failure.txt` |
| Logout / неверный пароль | покрыто smoke | `DELETE /auth/sessions/current → 204`, повтор → 401; неверный пароль → 401 | `evidence/smoke.txt` |
| Не принимает анонимного как доверенного | smoke: `X-User-Id` игнорируется даже с валидным Bearer | PASS | `evidence/smoke.txt` |
### Сценарий сохранности (фрагмент)
```
$ make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://localhost:8080
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
```
Тест:
1. Создаёт пользователя, логинится, создаёт чат, отправляет сообщение.
2. Запускает `scripts/restart.sh` — `docker compose restart postgres cache api` (volumes сохраняются).
3. Ждёт `healthy`.
4. Проверяет **тем же токеном** — сессия жива, данные на месте.
### Сценарий отказа Valkey (регресс на отозванный токен)
```
$ python3 student_tests/test_cache_failure.py
PASS: API works with Valkey down (degraded mode)
PASS: logout with cache down returned 204
PASS: revoked token rejected while cache down
PASS: revoked token still 401 after cache restart (regression fixed)
```
Тест:
1. Создаёт пользователя, логинится, получает токен.
2. Останавливает Valkey. Токен всё ещё работает (degraded mode).
3. Делает logout. Отзыв буферизуется в памяти процесса (tombstone не поставить).
4. Старый токен → 401 (БД уже без сессии).
5. Поднимает Valkey и рестартует API. `init_cache()` сбрасывает `session:*` и проигрывает `_pending_revocations`.
6. **Тот же старый токен снова → 401** — ключевой момент: баг не вернулся.
### Сценарий отказа PostgreSQL
```
$ python3 student_tests/test_db_failure.py
PASS: DB down returned 500 in 5.0s (<8s)
PASS: /health/ready returned 503 during DB down
PASS: session and data preserved after DB recovery
```
Тест:
1. Создаёт пользователя, логинится, получает токен.
2. Останавливает Postgres (`docker compose stop postgres`).
3. Запрос `GET /users/me` → 500 за 5.0 секунд (не висит бесконечно). Это результат `statement_timeout=5000` на стороне Postgres в сочетании с рвущимся TCP-соединением.
4. `/health/ready` → 503.
5. Поднимает Postgres, перезапускает API (пул пересоздаёт соединения).
6. Тот же токен → 200, данные сохранены.
Тест обёрнут в `try/finally`: даже при падении Postgres будет поднят, а API перезапущен.
### Уровень 4: обоснование индекса через EXPLAIN
Индекс `messages_history_idx (chat_id, created_at, id)` спроектирован под запрос пагинации:
```sql
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = $1 AND (created_at, id) > ($2, $3)
ORDER BY created_at, id
LIMIT $4;
```
Датасет: 10 023 сообщения в одном чате, размер таблицы — 2120 kB.
#### С индексом (первая страница)
```
Limit (cost=0.29..4.28 rows=51 width=77) (actual time=0.027..0.039 rows=51 loops=1)
Buffers: shared hit=4
-> Index Scan using messages_history_idx on messages
Index Cond: (chat_id = '...'::uuid)
Execution Time: 0.115 ms
```
#### С индексом (вторая страница, keyset-курсор)
```
Index Scan using messages_history_idx on messages
Index Cond: ((chat_id = '...'::uuid) AND
(ROW(created_at, id) > ROW('2026-10-02 12:50:00+00'::timestamptz,
'00000000-...'::uuid)))
Execution Time: 0.174 ms
```
Postgres объединяет **и** `chat_id`, **и** `(created_at, id)` в один `Index Cond`. Никакого `Sort` — порядок из индекса.
#### Без индекса (после `DROP INDEX`)
```
Limit (cost=592.91..593.04 rows=51 width=77) (actual time=2.644..2.652 rows=51 loops=1)
Buffers: shared hit=140
-> Sort (cost=592.91..617.91 rows=10000 width=77)
Sort Method: top-N heapsort Memory: 32kB
-> Seq Scan on messages (cost=0.00..259.29 rows=10000 width=77)
Filter: (chat_id = '...'::uuid)
Rows Removed by Filter: 23
Execution Time: 2.696 ms
```
#### Сводка
| Метрика | С индексом | Без индекса | Отношение |
|---|---|---|---|
| Execution Time | 0.115 ms | 2.696 ms | ~23× |
| Buffers (shared hit) | 4 | 134 | ~33× |
| План | Index Scan | Seq Scan + Sort | — |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Перезапуск API + Postgres + Valkey (`docker compose restart`, volumes сохранены) | Данные и сессия выживают | PASS, тот же токен, те же данные | ~5 секунд, потери нет |
| Миграции на пустом volume | Все таблицы создаются | PASS | — |
| Повторные миграции | Ничего не применяется | PASS | — |
| Valkey остановлен, API работает | API работает через Postgres | PASS, `cache disabled after 3 consecutive failures` | мгновенно после 3 ошибок |
| Valkey остановлен, logout | Logout возвращает 204, токен сразу 401 | PASS | мгновенно |
| Valkey поднят, API рестарт, старый токен | Тот же токен → 401 (регресс) | PASS | — |
| Postgres остановлен (`stop`) | Запрос падает за < 8 сек, ready → 503 | 500 за 5.0 с, ready 503 | ~10 с (start + restart api) |
| Postgres возвращён | Сессия и данные сохранены | PASS, тот же токен → 200 | — |
| Два одновременных POST /users с одним username | Один 201, один 409 | `HTTP codes: [201, 409]` | без потерь |
| Создание чата с несуществующим участником | 400, чат не создан | `PASS: rollback` | без потерь |
| Expiry при SESSION_TTL_SECONDS=2 | Через 3 секунды токен 401 | `after TTL: 401` | ожидаемая потеря сессии |
| 10 000 сообщений, запрос пагинации | Index Scan | 0.115 ms vs 2.696 ms без индекса | — |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- **Valkey как кэш, не источник истины.** Persistence отключён. При рестарте кэш холодный, но данные целы в Postgres. Это осознанное решение.
- **Cleanup-job для просроченных сессий не реализован.** Просроченные сессии остаются в БД, но игнорируются при проверке `expires_at`. Для lab2 это допустимо.
- **`statement_timeout` не спасает при `docker compose pause`.** `pause` = SIGSTOP: Postgres полностью заморожен и не обрабатывает собственный таймер. Это ограничение `psycopg`/libpq — клиентский `socket_timeout` не поддерживается. Поэтому тест использует `stop` (БД упала), а не `pause` (БД заморожена).
- **Пароли хешируются Argon2id с параметрами по умолчанию.** На lab7 требуется усиление (time_cost, memory_cost) и обязательный Argon2id — у нас уже Argon2id.
- **Нет HTTP rate limiting, нет реплик, нет шардирования.** Это появится на lab3.
- **Кэш сессий на lab3+ переиспользуется** под несколько API-реплик — тогда он даст реальный эффект.
- **EXPLAIN показал правильный план на 10 000 сообщениях.** На lab5 (трек 5) можно исследовать 100 000+ с неравномерными чатами.
- **Обнаружен и исправлен баг в `cache.py`** — `UnboundLocalError` из-за отсутствия `global`. До фикса остановка Redis превращалась в 500 на `POST /auth/sessions`.
- **Обнаружена и исправлена проблема с `socket_timeout` в `psycopg3`.** Параметр `socket_timeout` не поддерживается `psycopg3` (`invalid connection option`), из-за чего пул не создавал соединения. Убран.
- **Обнаружена и исправлена проблема с `CMD` в `Dockerfile`.** Exec-форма (`["python", "-m", "src.main", "..."]`) не выполняет `&&` и `exec` — миграции не применялись. Исправлено оборачиванием в `sh -c`.
+118
View File
@@ -0,0 +1,118 @@
# A generic, single database configuration.
[alembic]
# path to migration scripts
# Use forward slashes (/) also on windows to provide an os agnostic path
script_location = migrations
# 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
# sys.path path, will be prepended to sys.path if present.
# defaults to the current working directory.
prepend_sys_path = .
# timezone to use when rendering the date within the migration file
# as well as the filename.
# If specified, requires the python>=3.9 or backports.zoneinfo library.
# Any required deps can 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 migrations/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 "version_path_separator" below.
# version_locations = %(here)s/bar:%(here)s/bat:migrations/versions
# version path separator; As mentioned above, this is the character used to split
# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.
# Valid values for version_path_separator are:
#
# version_path_separator = :
# version_path_separator = ;
# version_path_separator = space
# version_path_separator = newline
version_path_separator = os # Use os.pathsep. Default configuration used for new projects.
# 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
# URL подставится из переменной окружения DATABASE_URL (см. migrations/env.py).
sqlalchemy.url =
[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 exec runner, execute a binary
# hooks = ruff
# ruff.type = exec
# ruff.executable = %(here)s/.venv/bin/ruff
# ruff.options = --fix REVISION_SCRIPT_FILENAME
# Logging configuration
[loggers]
keys = root,sqlalchemy,alembic
[handlers]
keys = console
[formatters]
keys = generic
[logger_root]
level = WARN
handlers = console
qualname =
[logger_sqlalchemy]
level = WARN
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
+66
View File
@@ -0,0 +1,66 @@
services:
postgres:
image: postgres:16.4-alpine
environment:
POSTGRES_USER: ${POSTGRES_USER:-messenger}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-changeme}
POSTGRES_DB: ${POSTGRES_DB:-messenger}
volumes:
- postgres_data:/var/lib/postgresql/data
ports:
- "127.0.0.1:5433:5432"
healthcheck:
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-messenger} -d ${POSTGRES_DB:-messenger}"]
interval: 5s
timeout: 3s
retries: 10
start_period: 5s
restart: unless-stopped
cache:
image: valkey/valkey:8.0.1-alpine
command: ["valkey-server", "--save", "", "--appendonly", "no"]
volumes:
- cache_data:/data
ports:
- "127.0.0.1:6380:6379"
healthcheck:
test: ["CMD", "valkey-cli", "ping"]
interval: 5s
timeout: 3s
retries: 10
start_period: 3s
restart: unless-stopped
api:
build:
context: .
dockerfile: Dockerfile
depends_on:
postgres:
condition: service_healthy
cache:
condition: service_healthy
environment:
APP_HOST: ${APP_HOST:-0.0.0.0}
APP_PORT: ${APP_PORT:-8080}
APP_ENV: ${APP_ENV:-lab}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
DATABASE_URL: postgresql://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD:-changeme}@postgres:5432/${POSTGRES_DB:-messenger}
CACHE_URL: redis://cache:6379/0
ports:
- "127.0.0.1:8080:8080"
healthcheck:
test: ["CMD", "python", "-c", "import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/live', timeout=2).status==200 else 1)"]
interval: 10s
timeout: 3s
retries: 5
start_period: 10s
restart: unless-stopped
volumes:
postgres_data:
name: mtusi_lab2_postgres_data
cache_data:
name: mtusi_lab2_cache_data
+10
View File
@@ -0,0 +1,10 @@
Container mtusi2026lab2-cache-1 Stopping
Container mtusi2026lab2-cache-1 Stopped
Container mtusi2026lab2-cache-1 Starting
Container mtusi2026lab2-cache-1 Started
Container mtusi2026lab2-api-1 Restarting
Container mtusi2026lab2-api-1 Started
PASS: API works with Valkey down (degraded mode)
PASS: logout with cache down returned 204
PASS: revoked token rejected while cache down
PASS: revoked token still 401 after cache restart (regression fixed)
+4
View File
@@ -0,0 +1,4 @@
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi2026lab2-api-1 mtusi2026lab2-api "sh -c 'alembic upgr…" api 5 minutes ago Up 6 seconds (health: starting) 127.0.0.1:8080->8080/tcp
mtusi2026lab2-cache-1 valkey/valkey:8.0.1-alpine "docker-entrypoint.s…" cache 5 minutes ago Up 40 seconds (healthy) 127.0.0.1:6380->6379/tcp
mtusi2026lab2-postgres-1 postgres:16.4-alpine "docker-entrypoint.s…" postgres 5 minutes ago Up 10 seconds (healthy) 127.0.0.1:5433->5432/tcp
+5
View File
@@ -0,0 +1,5 @@
Container mtusi2026lab2-postgres-1 Stopping
Container mtusi2026lab2-postgres-1 Stopped
PASS: DB down returned 500 in 5.0s (<8s)
PASS: /health/ready returned 503 during DB down
PASS: session and data preserved after DB recovery
+3
View File
@@ -0,0 +1,3 @@
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
+2
View File
@@ -0,0 +1,2 @@
python3 tests/smoke.py --base-url "http://localhost:8080"
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
+5
View File
@@ -0,0 +1,5 @@
statement_timeout
-------------------
0
(1 row)
+1
View File
@@ -0,0 +1 @@
Generic single-database configuration.
+46
View File
@@ -0,0 +1,46 @@
from __future__ import annotations
import os
from logging.config import fileConfig
from alembic import context
config = context.config
if config.config_file_name is not None:
fileConfig(config.config_file_name)
database_url = os.environ.get("DATABASE_URL")
if not database_url:
raise RuntimeError("DATABASE_URL environment variable is required for migrations")
target_metadata = None
def run_migrations_offline() -> None:
"""Оффлайн-режим: печатает SQL, не подключаясь к БД."""
context.configure(
url=database_url,
target_metadata=target_metadata,
literal_binds=True,
dialect_opts={"paramstyle": "named"},
)
with context.begin_transaction():
context.run_migrations()
def run_migrations_online() -> None:
"""Онлайн-режим: подключается к БД и применяет миграции."""
from sqlalchemy import create_engine
connectable = create_engine(database_url, pool_pre_ping=True)
with connectable.connect() as connection:
context.configure(connection=connection, target_metadata=target_metadata)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
run_migrations_offline()
else:
run_migrations_online()
+26
View File
@@ -0,0 +1,26 @@
"""${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, 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:
${upgrades if upgrades else "pass"}
def downgrade() -> None:
${downgrades if downgrades else "pass"}
@@ -0,0 +1,83 @@
"""create initial schema
Revision ID: <оставь тот, что сгенерировал alembic>
Revises:
Create Date: <оставь>
"""
from __future__ import annotations
from alembic import op
# revision identifiers, used by Alembic.
revision = "447472b8acec"
down_revision = None
branch_labels = None
depends_on = None
def upgrade() -> None:
op.execute("""
CREATE TABLE users (
id UUID PRIMARY KEY,
username TEXT NOT NULL UNIQUE,
display_name TEXT NOT NULL,
password_hash TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL
)
""")
op.execute("""
CREATE TABLE chats (
id UUID PRIMARY KEY,
title TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL
)
""")
op.execute("""
CREATE TABLE chat_members (
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
PRIMARY KEY (chat_id, user_id)
)
""")
op.execute("""
CREATE INDEX chat_members_user_idx ON chat_members (user_id)
""")
op.execute("""
CREATE TABLE messages (
id UUID PRIMARY KEY,
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id UUID NOT NULL REFERENCES users(id),
text TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL
)
""")
op.execute("""
CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id)
""")
op.execute("""
CREATE TABLE sessions (
token_hash TEXT PRIMARY KEY,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
expires_at TIMESTAMPTZ NOT NULL,
created_at TIMESTAMPTZ NOT NULL
)
""")
op.execute("""
CREATE INDEX sessions_user_idx ON sessions (user_id)
""")
def downgrade() -> None:
op.execute("DROP TABLE IF EXISTS sessions")
op.execute("DROP TABLE IF EXISTS messages")
op.execute("DROP INDEX IF EXISTS chat_members_user_idx")
op.execute("DROP TABLE IF EXISTS chat_members")
op.execute("DROP TABLE IF EXISTS chats")
op.execute("DROP TABLE IF EXISTS users")
+8
View File
@@ -0,0 +1,8 @@
fastapi==0.115.0
uvicorn[standard]==0.30.6
pydantic==2.9.2
psycopg[binary]==3.2.3
alembic==1.13.3
argon2-cffi==23.1.0
psycopg-pool==3.2.3
redis==5.1.1
+19
View File
@@ -0,0 +1,19 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
docker compose --env-file .env restart postgres
docker compose --env-file .env restart api
i=0
while [ $i -lt 60 ]; do
if docker compose --env-file .env ps api | grep -q "healthy"; then
exit 0
fi
sleep 1
i=$((i + 1))
done
echo "api did not become healthy in 60 seconds" >&2
exit 1
View File
+112
View File
@@ -0,0 +1,112 @@
from __future__ import annotations
import hashlib
import os
import secrets
from datetime import datetime, timedelta, timezone
from typing import Optional
import psycopg
from argon2 import PasswordHasher
from argon2.exceptions import VerifyMismatchError, VerificationError, InvalidHashError
from .db import transaction
_hasher = PasswordHasher()
def hash_password(password: str) -> str:
return _hasher.hash(password)
def verify_password(password: str, password_hash: str) -> bool:
try:
_hasher.verify(password_hash, password)
return True
except (VerifyMismatchError, VerificationError, InvalidHashError):
return False
def _now() -> datetime:
return datetime.now(timezone.utc)
def _ttl_seconds() -> int:
return int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
def _generate_token() -> str:
return secrets.token_urlsafe(32)
def _token_hash(token: str) -> str:
return hashlib.sha256(token.encode("utf-8")).hexdigest()
def create_session(user_id: str) -> dict:
from . import cache
token = _generate_token()
ttl = _ttl_seconds()
expires_at = _now() + timedelta(seconds=ttl)
token_hash = _token_hash(token)
with transaction() as conn:
with conn.cursor() as cur:
cur.execute(
"""
INSERT INTO sessions (token_hash, user_id, expires_at, created_at)
VALUES (%s, %s, %s, %s)
""",
(token_hash, user_id, expires_at, _now()),
)
cache.set_user_id(token_hash, user_id, ttl)
return {"token": token, "expires_at": expires_at}
def get_user_id_by_token(token: str) -> Optional[str]:
from . import cache
token_hash = _token_hash(token)
cached = cache.get_user_id(token_hash)
if cached is not None:
return cached
with transaction() as conn:
with conn.cursor() as cur:
cur.execute(
"""
SELECT user_id, expires_at
FROM sessions
WHERE token_hash = %s
""",
(token_hash,),
)
row = cur.fetchone()
if row is None:
return None
now = _now()
if row["expires_at"] <= now:
return None
user_id = str(row["user_id"])
ttl = int((row["expires_at"] - now).total_seconds())
cache.set_user_id(token_hash, user_id, ttl)
return user_id
def revoke_session(token: str) -> bool:
from . import cache
token_hash = _token_hash(token)
with transaction() as conn:
with conn.cursor() as cur:
cur.execute(
"DELETE FROM sessions WHERE token_hash = %s",
(token_hash,),
)
deleted = cur.rowcount > 0
if deleted:
cache.invalidate(token_hash)
return deleted
+182
View File
@@ -0,0 +1,182 @@
from __future__ import annotations
import logging
import os
import time
from typing import Optional, Set
import redis
log = logging.getLogger("messenger.cache")
_client: Optional[redis.Redis] = None
_failures: int = 0
_MAX_FAILURES_BEFORE_DISABLE: int = 3
_REVOKED_TTL_SECONDS: int = int(os.environ.get("REVOKED_TTL_SECONDS", "86400"))
_pending_revocations: Set[str] = set()
_pending_sessions: dict[str, tuple[str, int]] = {}
def _cache_url() -> Optional[str]:
return os.environ.get("CACHE_URL")
def init_cache() -> None:
global _client, _failures
url = _cache_url()
if not url:
log.warning("CACHE_URL not set; running without cache")
_client = None
return
try:
client = redis.Redis.from_url(
url,
decode_responses=True,
socket_connect_timeout=1.0,
socket_timeout=1.0,
)
client.ping()
_client = client
_failures = 0
_replay_pending_revocations(client)
log.info("cache connected (session prefix flushed, %d pending revocations replayed)",
len(_pending_revocations))
except Exception as exc:
log.warning("cache unavailable at startup: %s; running in degraded mode", exc)
_client = None
def _flush_session_prefix(client: redis.Redis) -> None:
"""Удаляет все ключи session:*. Кэш — не источник истины, это безопасно."""
try:
cursor = 0
deleted = 0
while True:
cursor, keys = client.scan(cursor=cursor, match="session:*", count=500)
if keys:
client.delete(*keys)
deleted += len(keys)
if cursor == 0:
break
if deleted:
log.info("flushed %d stale session keys after cache (re)connect", deleted)
except Exception as exc:
log.warning("failed to flush session prefix: %s", exc)
def _replay_pending_revocations(client: redis.Redis) -> None:
"""Пробует записать в Valkey отзывы, накопленные пока он был недоступен."""
global _pending_revocations
if not _pending_revocations:
return
still_pending: Set[str] = set()
for token_hash in _pending_revocations:
try:
client.setex(f"revoked:{token_hash}", _REVOKED_TTL_SECONDS, "1")
except Exception:
still_pending.add(token_hash)
_pending_revocations = still_pending
def close_cache() -> None:
global _client
if _client is not None:
try:
_client.close()
except Exception:
pass
_client = None
def _note_failure() -> None:
global _client, _failures
_failures += 1
if _failures >= _MAX_FAILURES_BEFORE_DISABLE and _client is not None:
log.warning(
"cache disabled after %d consecutive failures; running in degraded mode",
_failures,
)
try:
_client.close()
except Exception:
pass
_client = None
def _note_success() -> None:
global _failures
_failures = 0
def is_available() -> bool:
return _client is not None
# ---------- tombstone (revoked) ----------
def mark_revoked(token_hash: str) -> None:
if _client is None:
_pending_revocations.add(token_hash)
log.warning("cache unavailable; revocation queued locally (%d pending)",
len(_pending_revocations))
return
try:
_client.setex(f"revoked:{token_hash}", _REVOKED_TTL_SECONDS, "1")
_note_success()
except Exception as exc:
log.warning("mark_revoked failed: %s", exc)
_pending_revocations.add(token_hash)
_note_failure()
def is_revoked(token_hash: str) -> bool:
if _client is None:
return False
try:
exists = _client.exists(f"revoked:{token_hash}")
_note_success()
return exists == 1
except Exception as exc:
log.warning("is_revoked failed: %s", exc)
_note_failure()
return False
# ---------- session cache ----------
def get_user_id(token_hash: str) -> Optional[str]:
if _client is None:
return None
try:
value = _client.get(f"session:{token_hash}")
_note_success()
return value
except Exception as exc:
log.warning("cache get failed: %s", exc)
_note_failure()
return None
def set_user_id(token_hash: str, user_id: str, ttl_seconds: int) -> None:
if _client is None:
return
if ttl_seconds <= 0:
return
try:
_client.setex(f"session:{token_hash}", ttl_seconds, user_id)
_note_success()
except Exception as exc:
log.warning("cache set failed: %s", exc)
_note_failure()
def invalidate(token_hash: str) -> None:
if _client is None:
return
try:
_client.delete(f"session:{token_hash}")
_note_success()
except Exception as exc:
log.warning("cache delete failed: %s", exc)
_note_failure()
+72
View File
@@ -0,0 +1,72 @@
from __future__ import annotations
import os
from contextlib import contextmanager
from typing import Iterator
import psycopg
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool
_pool: ConnectionPool | None = None
def _database_url() -> str:
url = os.environ.get("DATABASE_URL")
if not url:
raise RuntimeError("DATABASE_URL environment variable is required")
return url
from psycopg_pool import ConnectionPool
def init_pool(min_size: int = 1, max_size: int = 10) -> None:
global _pool
if _pool is not None:
return
dsn = _database_url()
sep = "&" if "?" in dsn else "?"
dsn_with_opts = (
dsn
+ sep
+ "options="
+ "-c%20statement_timeout%3D5000"
+ "%20-c%20lock_timeout%3D3000"
+ "%20-c%20idle_in_transaction_session_timeout%3D10000"
)
_pool = ConnectionPool(
conninfo=dsn_with_opts,
min_size=min_size,
max_size=max_size,
kwargs={"row_factory": dict_row},
open=True,
timeout=5.0,
check=ConnectionPool.check_connection,
max_lifetime=120,
max_idle=60,
)
def close_pool() -> None:
global _pool
if _pool is not None:
_pool.close()
_pool = None
@contextmanager
def connection() -> Iterator[psycopg.Connection]:
if _pool is None:
raise RuntimeError("Connection pool is not initialized")
with _pool.connection() as conn:
yield conn
@contextmanager
def transaction() -> Iterator[psycopg.Connection]:
with connection() as conn:
with conn.transaction():
yield conn
Executable
+65
View File
@@ -0,0 +1,65 @@
from __future__ import annotations
import uuid
from typing import Callable
from fastapi import Request
from fastapi.responses import JSONResponse
from starlette.middleware.base import BaseHTTPMiddleware
from .store import ApiError
REQUEST_ID_HEADER = "X-Request-Id"
class RequestIdMiddleware(BaseHTTPMiddleware):
async def dispatch(self, request: Request, call_next: Callable):
rid = request.headers.get(REQUEST_ID_HEADER) or uuid.uuid4().hex
request.state.request_id = rid
response = await call_next(request)
response.headers[REQUEST_ID_HEADER] = rid
return response
def _envelope(code: str, message: str, request_id: str) -> dict:
return {"error": {"code": code, "message": message, "request_id": request_id}}
def _rid(request: Request) -> str:
return getattr(request.state, "request_id", None) or uuid.uuid4().hex
async def api_error_handler(request: Request, exc: Exception) -> JSONResponse:
assert isinstance(exc, ApiError)
response = JSONResponse(
status_code=exc.status,
content=_envelope(exc.code, exc.message, _rid(request)),
)
if exc.status == 401:
scheme = "Bearer"
if request.url.path == "/api/v1/auth/sessions":
scheme = "Basic"
response.headers["WWW-Authenticate"] = f'{scheme} realm="messenger"'
return response
async def validation_handler(request: Request, exc: Exception) -> JSONResponse:
return JSONResponse(
status_code=400,
content=_envelope("invalid_request", "Request validation failed", _rid(request)),
)
async def json_decode_handler(request: Request, exc: Exception) -> JSONResponse:
return JSONResponse(
status_code=400,
content=_envelope("invalid_request", "Malformed JSON", _rid(request)),
)
async def unhandled_handler(request: Request, exc: Exception) -> JSONResponse:
return JSONResponse(
status_code=500,
content=_envelope("internal_error", "Internal error", _rid(request)),
)
Executable
+239
View File
@@ -0,0 +1,239 @@
from __future__ import annotations
import logging
import os
from contextlib import asynccontextmanager
from typing import Optional
from fastapi import Depends, FastAPI, Header, Query, Request, Response
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from starlette.exceptions import HTTPException as StarletteHTTPException
from . import auth
from .db import close_pool, init_pool
from .errors import (
RequestIdMiddleware,
_envelope,
_rid,
api_error_handler,
json_decode_handler,
unhandled_handler,
validation_handler,
)
from .schemas import (
Chat,
ChatPage,
CreateChat,
CreateMessage,
CreateUser,
Health,
Message,
MessagePage,
Session,
User,
)
from .store import ApiError, BadRequest, Conflict, NotFound, Unauthorized, store, iso
from .cache import close_cache, init_cache
logging.basicConfig(
level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s"
)
log = logging.getLogger("messenger")
@asynccontextmanager
async def lifespan(app: FastAPI):
init_pool()
init_cache()
log.info("db pool and cache initialized")
try:
yield
finally:
close_cache()
close_pool()
log.info("db pool and cache closed")
app = FastAPI(title="MTUSI Messenger lab2", version="1.2.0", lifespan=lifespan)
app.add_middleware(RequestIdMiddleware)
app.add_exception_handler(ApiError, api_error_handler)
app.add_exception_handler(RequestValidationError, validation_handler)
app.add_exception_handler(Exception, unhandled_handler)
@app.exception_handler(StarletteHTTPException)
async def _http_exc(request: Request, exc: StarletteHTTPException):
code = "not_found" if exc.status_code == 404 else "invalid_request"
return JSONResponse(
status_code=exc.status_code,
content=_envelope(code, str(exc.detail), _rid(request)),
)
# ---------- зависимости ----------
def _parse_basic(header_value: str) -> tuple[str, str]:
"""Разбирает `Basic base64(username:password)`. Бросает Unauthorized."""
import base64
if not header_value.lower().startswith("basic "):
raise Unauthorized("Basic authentication required")
try:
raw = base64.b64decode(header_value.split(" ", 1)[1], validate=True)
decoded = raw.decode("utf-8")
username, _, password = decoded.partition(":")
if not username:
raise ValueError("empty username")
return username, password
except Exception:
raise Unauthorized("Invalid Basic credentials") from None
def _bearer_token(authorization: Optional[str]) -> str:
if not authorization:
raise Unauthorized("Missing Authorization header")
parts = authorization.split(" ", 1)
if len(parts) != 2 or parts[0].lower() != "bearer":
raise Unauthorized("Bearer token required")
token = parts[1].strip()
if not token:
raise Unauthorized("Empty bearer token")
return token
def current_user_id(
authorization: Optional[str] = Header(default=None),
) -> str:
token = _bearer_token(authorization)
user_id = auth.get_user_id_by_token(token)
if user_id is None:
raise Unauthorized("Invalid or expired token")
return user_id
# ---------- health ----------
@app.get("/health/live", response_model=Health)
def liveness():
return {"status": "ok"}
@app.get("/health/ready", response_model=Health)
def readiness():
try:
from .db import transaction
with transaction() as conn:
with conn.cursor() as cur:
cur.execute("SELECT 1")
except Exception:
return JSONResponse(
status_code=503,
content=_envelope("unavailable", "Database unavailable", "readiness"),
)
return {"status": "ok"}
# ---------- users ----------
@app.post("/api/v1/users", status_code=201, response_model=User)
def register_user(body: CreateUser):
password_hash = auth.hash_password(body.password)
return store.create_user(body.username, body.display_name, password_hash)
@app.get("/api/v1/users/me", response_model=User)
def me(user_id: str = Depends(current_user_id)):
user = store.get_user(user_id)
if user is None:
raise Unauthorized("User not found")
return user
# ---------- auth ----------
@app.post("/api/v1/auth/sessions", status_code=201, response_model=Session)
def create_session(authorization: Optional[str] = Header(default=None)):
username, password = _parse_basic(authorization or "")
row = store.get_user_by_username(username)
if row is None or not auth.verify_password(password, row["password_hash"]):
raise Unauthorized("Invalid credentials")
session = auth.create_session(str(row["id"]))
user = store.get_user(str(row["id"]))
if user is None:
raise Unauthorized("User not found")
return {
"token": session["token"],
"token_type": "Bearer",
"expires_at": iso(session["expires_at"]),
"user": user,
}
@app.delete("/api/v1/auth/sessions/current", status_code=204)
def logout(authorization: Optional[str] = Header(default=None)):
token = _bearer_token(authorization)
user_id = auth.get_user_id_by_token(token)
if user_id is None:
raise Unauthorized("Invalid or expired token")
auth.revoke_session(token)
return Response(status_code=204)
# ---------- chats ----------
@app.post("/api/v1/chats", status_code=201, response_model=Chat)
def create_chat(body: CreateChat, user_id: str = Depends(current_user_id)):
return store.create_chat(body.title, body.member_ids, user_id)
@app.get("/api/v1/chats", response_model=ChatPage)
def list_chats(
limit: int = Query(default=50, ge=1, le=100),
cursor: Optional[str] = Query(default=None, min_length=1),
user_id: str = Depends(current_user_id),
):
items, next_cursor = store.list_chats(user_id, limit, cursor)
return {"items": items, "next_cursor": next_cursor}
@app.get("/api/v1/chats/{chat_id}", response_model=Chat)
def get_chat(chat_id: str, user_id: str = Depends(current_user_id)):
chat = store.get_chat(chat_id, user_id)
if chat is None:
raise NotFound()
return chat
# ---------- messages ----------
@app.post(
"/api/v1/chats/{chat_id}/messages", status_code=201, response_model=Message
)
def create_message(
chat_id: str, body: CreateMessage, user_id: str = Depends(current_user_id)
):
return store.add_message(chat_id, user_id, body.text)
@app.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePage)
def list_messages(
chat_id: str,
limit: int = Query(default=50, ge=1, le=100),
cursor: Optional[str] = Query(default=None, min_length=1),
user_id: str = Depends(current_user_id),
):
items, next_cursor = store.list_messages(chat_id, user_id, limit, cursor)
return {"items": items, "next_cursor": next_cursor}
def main() -> None:
import uvicorn
host = os.environ.get("APP_HOST", "0.0.0.0")
port = int(os.environ.get("APP_PORT", "8080"))
uvicorn.run("src.main:app", host=host, port=port, log_level="info")
if __name__ == "__main__":
main()
Executable
+135
View File
@@ -0,0 +1,135 @@
from __future__ import annotations
import re
import uuid
from typing import List, Optional
from pydantic import BaseModel, ConfigDict, Field, field_validator
USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$")
class StrictModel(BaseModel):
model_config = ConfigDict(extra="forbid", str_strip_whitespace=False)
# ---------- Users ----------
class CreateUser(StrictModel):
username: str = Field(min_length=3, max_length=32)
display_name: str = Field(min_length=1, max_length=100)
password: str = Field(min_length=12, max_length=128)
@field_validator("username")
@classmethod
def _username(cls, v: str) -> str:
if not USERNAME_RE.match(v):
raise ValueError("username must match [a-z0-9_]{3,32}")
return v
@field_validator("display_name")
@classmethod
def _display_name(cls, v: str) -> str:
if not v.strip():
raise ValueError("display_name must not be blank")
if len(v) > 100:
raise ValueError("display_name too long")
return v
class User(StrictModel):
id: str
username: str
display_name: str
created_at: str
# ---------- Chats ----------
class CreateChat(StrictModel):
title: str = Field(min_length=1, max_length=100)
member_ids: List[str] = Field(min_length=1, max_length=100)
@field_validator("title")
@classmethod
def _title(cls, v: str) -> str:
if not v.strip():
raise ValueError("title must not be blank")
return v
@field_validator("member_ids")
@classmethod
def _members(cls, v: List[str]) -> List[str]:
if len(set(v)) != len(v):
raise ValueError("member_ids must be unique")
for item in v:
try:
uuid.UUID(item)
except ValueError as exc:
raise ValueError("member_ids must be UUIDs") from exc
return v
class Chat(StrictModel):
id: str
title: str
member_ids: List[str]
created_at: str
class ChatPage(StrictModel):
items: List[Chat]
next_cursor: Optional[str] = None
# ---------- Messages ----------
class CreateMessage(StrictModel):
text: str = Field(min_length=1, max_length=4000)
@field_validator("text")
@classmethod
def _text(cls, v: str) -> str:
if not v.strip():
raise ValueError("text must not be blank")
if len(v) > 4000:
raise ValueError("text too long")
return v
class Message(StrictModel):
id: str
chat_id: str
sender_id: str
text: str
created_at: str
class MessagePage(StrictModel):
items: List[Message]
next_cursor: Optional[str] = None
# ---------- Sessions ----------
class Session(StrictModel):
token: str = Field(min_length=32)
token_type: str = Field(default="Bearer")
expires_at: str
user: User
# ---------- Misc ----------
class Health(StrictModel):
status: str = "ok"
class ErrorBody(StrictModel):
code: str
message: str
request_id: str
class ErrorEnvelope(StrictModel):
error: ErrorBody
Executable
+332
View File
@@ -0,0 +1,332 @@
from __future__ import annotations
import base64
import json
import uuid
from datetime import datetime, timezone
from typing import List, Optional, Tuple
import psycopg
from psycopg.errors import UniqueViolation
from .db import transaction
# ---------- ошибки ----------
class ApiError(Exception):
status = 500
code = "internal_error"
def __init__(self, message: str = "Internal error") -> None:
super().__init__(message)
self.message = message
class BadRequest(ApiError):
status = 400
code = "invalid_request"
class Unauthorized(ApiError):
status = 401
code = "unauthorized"
class NotFound(ApiError):
status = 404
code = "not_found"
class Conflict(ApiError):
status = 409
code = "conflict"
# ---------- утилиты ----------
def _now() -> datetime:
return datetime.now(timezone.utc)
def iso(dt: datetime) -> str:
return dt.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
def _user_dict(row: dict) -> dict:
return {
"id": str(row["id"]),
"username": row["username"],
"display_name": row["display_name"],
"created_at": iso(row["created_at"]),
}
def _chat_dict(row: dict, member_ids: List[str]) -> dict:
return {
"id": str(row["id"]),
"title": row["title"],
"member_ids": member_ids,
"created_at": iso(row["created_at"]),
}
def _message_dict(row: dict) -> dict:
return {
"id": str(row["id"]),
"chat_id": str(row["chat_id"]),
"sender_id": str(row["sender_id"]),
"text": row["text"],
"created_at": iso(row["created_at"]),
}
# ---------- курсор ----------
def _encode_cursor(scope: str, created_at: str, item_id: str) -> str:
payload = json.dumps(
{"s": scope, "t": created_at, "i": item_id}, separators=(",", ":")
).encode()
return base64.urlsafe_b64encode(payload).decode().rstrip("=")
def _decode_cursor(scope: str, cursor: str) -> Tuple[str, str]:
pad = "=" * (-len(cursor) % 4)
try:
raw = base64.urlsafe_b64decode(cursor + pad)
data = json.loads(raw)
if data.get("s") != scope:
raise ValueError("scope mismatch")
return data["t"], data["i"]
except Exception as exc:
raise BadRequest("invalid cursor") from exc
# ---------- Store ----------
class Store:
# ---- users ----
def create_user(
self, username: str, display_name: str, password_hash: str
) -> dict:
uid = str(uuid.uuid4())
now = _now()
try:
with transaction() as conn:
with conn.cursor() as cur:
cur.execute(
"""
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES (%s, %s, %s, %s, %s)
""",
(uid, username, display_name, password_hash, now),
)
except UniqueViolation:
raise Conflict("username already taken") from None
return {
"id": uid,
"username": username,
"display_name": display_name,
"created_at": iso(now),
}
def get_user(self, user_id: str) -> Optional[dict]:
with transaction() as conn:
with conn.cursor() as cur:
cur.execute("SELECT * FROM users WHERE id = %s", (user_id,))
row = cur.fetchone()
return _user_dict(row) if row else None
def get_user_by_username(self, username: str) -> Optional[dict]:
"""Возвращает полную строку, включая password_hash (для входа)."""
with transaction() as conn:
with conn.cursor() as cur:
cur.execute("SELECT * FROM users WHERE username = %s", (username,))
row = cur.fetchone()
return row
# ---- chats ----
def create_chat(
self, title: str, member_ids: List[str], creator_id: str
) -> dict:
if creator_id not in member_ids:
raise BadRequest("creator must be in member_ids")
with transaction() as conn:
with conn.cursor() as cur:
cur.execute(
"SELECT id FROM users WHERE id = ANY(%s)",
(member_ids,),
)
found = {str(r["id"]) for r in cur.fetchall()}
missing = set(member_ids) - found
if missing:
raise BadRequest("unknown member_id")
cid = str(uuid.uuid4())
now = _now()
with transaction() as conn:
with conn.cursor() as cur:
cur.execute(
"INSERT INTO chats (id, title, created_at) VALUES (%s, %s, %s)",
(cid, title, now),
)
cur.executemany(
"INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)",
[(cid, uid) for uid in member_ids],
)
return {
"id": cid,
"title": title,
"member_ids": list(member_ids),
"created_at": iso(now),
}
def get_chat(self, chat_id: str, viewer_id: str) -> Optional[dict]:
with transaction() as conn:
with conn.cursor() as cur:
cur.execute(
"""
SELECT c.* FROM chats c
JOIN chat_members m ON m.chat_id = c.id
WHERE c.id = %s AND m.user_id = %s
""",
(chat_id, viewer_id),
)
row = cur.fetchone()
if row is None:
return None
cur.execute(
"SELECT user_id FROM chat_members WHERE chat_id = %s ORDER BY user_id",
(chat_id,),
)
members = [str(r["user_id"]) for r in cur.fetchall()]
return _chat_dict(row, members)
def list_chats(
self, viewer_id: str, limit: int, cursor: Optional[str]
) -> Tuple[List[dict], Optional[str]]:
scope = "chats:" + viewer_id
params: list = [viewer_id]
where_cursor = ""
if cursor:
t, i = _decode_cursor(scope, cursor)
where_cursor = "AND (c.created_at, c.id) > (%s, %s)"
params.extend([t, i])
params.append(limit + 1) # +1, чтобы узнать, есть ли следующая страница
with transaction() as conn:
with conn.cursor() as cur:
cur.execute(
f"""
SELECT c.id, c.title, c.created_at
FROM chats c
JOIN chat_members m ON m.chat_id = c.id
WHERE m.user_id = %s {where_cursor}
ORDER BY c.created_at, c.id
LIMIT %s
""",
params,
)
rows = cur.fetchall()
has_more = len(rows) > limit
page = rows[:limit]
result = []
for row in page:
cur.execute(
"SELECT user_id FROM chat_members WHERE chat_id = %s ORDER BY user_id",
(row["id"],),
)
members = [str(r["user_id"]) for r in cur.fetchall()]
result.append(_chat_dict(row, members))
next_cursor = None
if has_more and page:
last = page[-1]
next_cursor = _encode_cursor(scope, iso(last["created_at"]), str(last["id"]))
return result, next_cursor
# ---- messages ----
def add_message(self, chat_id: str, sender_id: str, text: str) -> dict:
mid = str(uuid.uuid4())
now = _now()
with transaction() as conn:
with conn.cursor() as cur:
cur.execute(
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
(chat_id, sender_id),
)
if cur.fetchone() is None:
raise NotFound()
cur.execute(
"""
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES (%s, %s, %s, %s, %s)
""",
(mid, chat_id, sender_id, text, now),
)
return {
"id": mid,
"chat_id": chat_id,
"sender_id": sender_id,
"text": text,
"created_at": iso(now),
}
def list_messages(
self,
chat_id: str,
viewer_id: str,
limit: int,
cursor: Optional[str],
) -> Tuple[List[dict], Optional[str]]:
with transaction() as conn:
with conn.cursor() as cur:
cur.execute(
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
(chat_id, viewer_id),
)
if cur.fetchone() is None:
raise NotFound()
scope = "chat:" + chat_id
params: list = [chat_id]
where_cursor = ""
if cursor:
t, i = _decode_cursor(scope, cursor)
where_cursor = "AND (created_at, id) > (%s, %s)"
params.extend([t, i])
params.append(limit + 1)
with transaction() as conn:
with conn.cursor() as cur:
cur.execute(
f"""
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = %s {where_cursor}
ORDER BY created_at, id
LIMIT %s
""",
params,
)
rows = cur.fetchall()
has_more = len(rows) > limit
page = rows[:limit]
result = [_message_dict(r) for r in page]
next_cursor = None
if has_more and page:
last = page[-1]
next_cursor = _encode_cursor(scope, iso(last["created_at"]), str(last["id"]))
return result, next_cursor
store = Store()
+89
View File
@@ -0,0 +1,89 @@
"""Генерация тестовых сообщений для EXPLAIN.
Создаёт пользователя, чат и N сообщений. N по умолчанию 10 000.
Запуск:
python3 seed_messages.py --base-url http://localhost:8080 --count 10000
"""
from __future__ import annotations
import argparse
import base64
import json
import time
import urllib.error
import urllib.request
import uuid
def call(base: str, method: str, path: str, headers: dict | None = None, body: dict | None = None) -> tuple[int, dict | None]:
data = None
h = dict(headers or {})
if body is not None:
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
h["Content-Type"] = "application/json"
req = urllib.request.Request(base + path, data=data, headers=h, method=method)
try:
resp = urllib.request.urlopen(req, timeout=30)
raw = resp.read()
return resp.code, json.loads(raw) if raw else None
except urllib.error.HTTPError as e:
raw = e.read()
try:
return e.code, json.loads(raw) if raw else None
except Exception:
return e.code, None
def main() -> None:
p = argparse.ArgumentParser()
p.add_argument("--base-url", default="http://localhost:8080")
p.add_argument("--count", type=int, default=10000)
p.add_argument("--batch", type=int, default=500, help="Сообщений между progress-логами")
args = p.parse_args()
base = args.base_url.rstrip("/")
username = "seed_" + uuid.uuid4().hex[:12]
password = "seed-pass-1234567890"
# Регистрация
code, user = call(base, "POST", "/api/v1/users", body={
"username": username, "display_name": "Seed User", "password": password,
})
assert code == 201, f"register failed: {code} {user}"
# Логин
cred = base64.b64encode(f"{username}:{password}".encode()).decode()
code, session = call(base, "POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + cred})
assert code == 201, f"login failed: {code} {session}"
token = session["token"]
user_id = session["user"]["id"]
# Чат
code, chat = call(base, "POST", "/api/v1/chats", headers={"Authorization": "Bearer " + token}, body={
"title": "Seed chat", "member_ids": [user_id],
})
assert code == 201, f"chat failed: {code} {chat}"
chat_id = chat["id"]
print(f"chat_id: {chat_id}")
print(f"seeding {args.count} messages...")
started = time.monotonic()
for i in range(args.count):
code, msg = call(
base, "POST", f"/api/v1/chats/{chat_id}/messages",
headers={"Authorization": "Bearer " + token},
body={"text": f"seed-{i:06d}-{uuid.uuid4().hex[:8]}"},
)
assert code == 201, f"message {i} failed: {code} {msg}"
if (i + 1) % args.batch == 0:
elapsed = time.monotonic() - started
rps = (i + 1) / elapsed
print(f" {i + 1}/{args.count} ({rps:.0f} msg/s)")
elapsed = time.monotonic() - started
print(f"done: {args.count} messages in {elapsed:.1f}s ({args.count / elapsed:.0f} msg/s)")
print(f"chat_id: {chat_id}")
if __name__ == "__main__":
main()
+100
View File
@@ -0,0 +1,100 @@
"""Проверка отказа Valkey и корректности logout при недоступном кэше."""
from __future__ import annotations
import base64, json, subprocess, sys, time, urllib.error, urllib.request, uuid
BASE = "http://localhost:8080"
COMPOSE = ["docker", "compose", "--env-file", ".env"]
def call(method, path, headers=None, body=None):
data = None
h = dict(headers or {})
if body is not None:
data = json.dumps(body).encode()
h["Content-Type"] = "application/json"
req = urllib.request.Request(BASE + path, data=data, headers=h, method=method)
try:
r = urllib.request.urlopen(req, timeout=10)
raw = r.read()
return r.code, json.loads(raw) if raw else None
except urllib.error.HTTPError as e:
raw = e.read()
try:
return e.code, json.loads(raw) if raw else None
except Exception:
return e.code, None
def stop_cache():
subprocess.run(COMPOSE + ["stop", "cache"], check=True)
def start_cache():
subprocess.run(COMPOSE + ["start", "cache"], check=True)
def restart_api():
subprocess.run(COMPOSE + ["restart", "api"], check=True)
def wait_ready(deadline=60):
end = time.monotonic() + deadline
while time.monotonic() < end:
try:
code, _ = call("GET", "/health/ready")
if code == 200:
return
except Exception:
pass
time.sleep(1)
raise SystemExit("API did not become ready")
def main():
username = "cf_" + uuid.uuid4().hex[:10]
password = "cache-fail-pass-1234567890"
code, _ = call("POST", "/api/v1/users", body={
"username": username, "display_name": "Cache Fail", "password": password,
})
assert code == 201, code
cred = base64.b64encode(f"{username}:{password}".encode()).decode()
code, session = call("POST", "/api/v1/auth/sessions",
headers={"Authorization": "Basic " + cred})
assert code == 201, code
token = session["token"]
# Токен работает
code, _ = call("GET", "/api/v1/users/me",
headers={"Authorization": "Bearer " + token})
assert code == 200, code
# Останавливаем Valkey
stop_cache()
time.sleep(2)
# API должно работать в degraded mode
code, _ = call("GET", "/api/v1/users/me",
headers={"Authorization": "Bearer " + token})
assert code == 200, f"degraded mode failed: {code}"
print("PASS: API works with Valkey down (degraded mode)")
# Logout при недоступном Valkey должен вернуть 204
code, _ = call("DELETE", "/api/v1/auth/sessions/current",
headers={"Authorization": "Bearer " + token})
assert code == 204, f"logout with cache down returned {code}"
print("PASS: logout with cache down returned 204")
# Токен немедленно недействителен (проверка через БД)
code, _ = call("GET", "/api/v1/users/me",
headers={"Authorization": "Bearer " + token})
assert code == 401, f"revoked token still works with cache down: {code}"
print("PASS: revoked token rejected while cache down")
# Поднимаем Valkey, рестартуем API — критический регресс-тест
start_cache()
time.sleep(2)
restart_api()
wait_ready()
code, _ = call("GET", "/api/v1/users/me",
headers={"Authorization": "Bearer " + token})
assert code == 401, f"REGRESSION: revoked token resurrected after cache restart: {code}"
print("PASS: revoked token still 401 after cache restart (regression fixed)")
if __name__ == "__main__":
main()
+127
View File
@@ -0,0 +1,127 @@
"""Проверка отказа PostgreSQL: таймаут запроса и восстановление."""
from __future__ import annotations
import base64, json, subprocess, sys, time, urllib.error, urllib.request, uuid
BASE = "http://localhost:8080"
COMPOSE = ["docker", "compose", "--env-file", ".env"]
def call(method, path, headers=None, body=None, timeout=10):
data = None
h = dict(headers or {})
if body is not None:
data = json.dumps(body).encode()
h["Content-Type"] = "application/json"
req = urllib.request.Request(BASE + path, data=data, headers=h, method=method)
try:
r = urllib.request.urlopen(req, timeout=timeout)
raw = r.read()
return r.code, json.loads(raw) if raw else None
except urllib.error.HTTPError as e:
raw = e.read()
try:
return e.code, json.loads(raw) if raw else None
except Exception:
return e.code, None
def stop_db():
"""Останавливает контейнер Postgres. TCP-соединения рвутся, psycopg
получает ошибку мгновенно — это честный сценарий 'БД упала'."""
subprocess.run(COMPOSE + ["stop", "postgres"], check=True)
def start_db():
"""Поднимает Postgres. Не падает, если уже запущен."""
subprocess.run(COMPOSE + ["start", "postgres"],
capture_output=True, check=False)
time.sleep(3)
def restart_api():
"""Пересоздаёт API, чтобы пул соединений не держал мёртвые сессии."""
subprocess.run(COMPOSE + ["restart", "api"],
capture_output=True, check=False)
def wait_ready(deadline=60):
end = time.monotonic() + deadline
while time.monotonic() < end:
try:
code, _ = call("GET", "/health/ready", timeout=5)
if code == 200:
return
except Exception:
pass
time.sleep(1)
raise SystemExit("API did not become ready")
def ensure_clean_state():
"""Возвращает стек в рабочее состояние, если предыдущий запуск оставил
Postgres остановленным или пул API в плохом состоянии."""
subprocess.run(COMPOSE + ["start", "postgres"],
capture_output=True, check=False)
time.sleep(3)
# API перезапускаем, потому что после stop Postgres пул мог забиться
# мёртвыми соединениями, и первый запрос упадёт по PoolTimeout.
restart_api()
wait_ready()
def main():
ensure_clean_state()
# Регистрация и логин — до всякого stop, чтобы тест не падал на подготовке
username = "dbf_" + uuid.uuid4().hex[:10]
password = "db-fail-pass-1234567890"
code, _ = call("POST", "/api/v1/users", body={
"username": username, "display_name": "DB Fail", "password": password,
})
assert code == 201, f"failed to create user before stop: {code}"
cred = base64.b64encode(f"{username}:{password}".encode()).decode()
code, session = call("POST", "/api/v1/auth/sessions",
headers={"Authorization": "Basic " + cred})
assert code == 201, f"failed to login before stop: {code}"
token = session["token"]
stop_db()
try:
time.sleep(0.5)
# Запрос к БД должен упасть быстро (TCP порван, psycopg сразу
# получает ошибку соединения). Проверяем < 8 секунд.
start = time.monotonic()
try:
code, _ = call("GET", "/api/v1/users/me",
headers={"Authorization": "Bearer " + token}, timeout=15)
except Exception as exc:
elapsed = time.monotonic() - start
raise SystemExit(f"request hung: {elapsed:.1f}s, {type(exc).__name__}")
elapsed = time.monotonic() - start
assert elapsed < 8, f"request took {elapsed:.1f}s (>8s), DB down not handled fast enough"
assert code in (500, 503), f"expected 500/503 during DB down, got {code}"
print(f"PASS: DB down returned {code} in {elapsed:.1f}s (<8s)")
# health/ready должен вернуть 503, пока БД недоступна
code, _ = call("GET", "/health/ready", timeout=15)
assert code == 503, f"expected 503 from ready, got {code}"
print("PASS: /health/ready returned 503 during DB down")
finally:
# Гарантированно поднимаем Postgres даже при падении выше.
start_db()
# Перезапускаем API, чтобы пул пересоздал соединения с вернувшейся БД.
restart_api()
wait_ready()
# Проверяем, что данные и сессия сохранены после восстановления.
code, _ = call("GET", "/api/v1/users/me",
headers={"Authorization": "Bearer " + token})
assert code == 200, f"session lost after DB recovery: {code}"
print("PASS: session and data preserved after DB recovery")
if __name__ == "__main__":
main()
+72
View File
@@ -0,0 +1,72 @@
"""Тест expiry: сессия истекает через SESSION_TTL_SECONDS.
Запуск:
SESSION_TTL_SECONDS=2 docker compose up -d --build api
python3 test_expiry.py --base-url http://localhost:8080
Тест создаёт пользователя, логинится, ждёт TTL+1 секунду, проверяет 401.
"""
from __future__ import annotations
import base64
import json
import sys
import time
import urllib.error
import urllib.request
import uuid
BASE = sys.argv[sys.argv.index("--base-url") + 1] if "--base-url" in sys.argv else "http://localhost:8080"
def call(method: str, path: str, headers: dict | None = None, body: dict | None = None) -> tuple[int, dict | None]:
data = None
h = dict(headers or {})
if body is not None:
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
h["Content-Type"] = "application/json"
req = urllib.request.Request(BASE + path, data=data, headers=h, method=method)
try:
resp = urllib.request.urlopen(req, timeout=10)
raw = resp.read()
return resp.code, json.loads(raw) if raw else None
except urllib.error.HTTPError as e:
raw = e.read()
try:
return e.code, json.loads(raw) if raw else None
except Exception:
return e.code, None
def main() -> None:
username = "exp_" + uuid.uuid4().hex[:12]
password = "expiry-pass-1234567890"
# Регистрация
code, user = call("POST", "/api/v1/users", body={
"username": username, "display_name": "Expiry Test", "password": password,
})
assert code == 201, f"register failed: {code} {user}"
# Логин
cred = base64.b64encode(f"{username}:{password}".encode()).decode()
code, session = call("POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + cred})
assert code == 201, f"login failed: {code} {session}"
token = session["token"]
print(f"session expires_at: {session['expires_at']}")
# Сразу после логина — токен работает
code, me = call("GET", "/api/v1/users/me", headers={"Authorization": "Bearer " + token})
assert code == 200, f"token should work immediately, got {code}"
print("immediately after login: 200 OK")
# Ждём истечения
time.sleep(3)
code, err = call("GET", "/api/v1/users/me", headers={"Authorization": "Bearer " + token})
assert code == 401, f"expired token must give 401, got {code}"
print(f"after TTL: {code} (expected 401)")
print("PASS: expiry — token invalidated after SESSION_TTL_SECONDS")
if __name__ == "__main__":
main()
+116
View File
@@ -0,0 +1,116 @@
"""Тест гонки регистрации: два параллельных POST /users с одним username.
Ожидаем: один 201, второй 409, в БД ровно один пользователь.
Гонка гарантируется через threading.Barrier — оба запроса стартуют одновременно.
"""
from __future__ import annotations
import json
import sys
import threading
import urllib.error
import urllib.request
import uuid
from concurrent.futures import ThreadPoolExecutor
BASE = sys.argv[sys.argv.index("--base-url") + 1] if "--base-url" in sys.argv else "http://localhost:8080"
def post_user(username: str, display_name: str, password: str) -> int:
"""Отправляет POST /users, возвращает HTTP-код."""
body = json.dumps(
{"username": username, "display_name": display_name, "password": password},
ensure_ascii=False,
).encode("utf-8")
req = urllib.request.Request(
BASE + "/api/v1/users",
data=body,
headers={"Content-Type": "application/json"},
method="POST",
)
try:
resp = urllib.request.urlopen(req, timeout=10)
return resp.code
except urllib.error.HTTPError as e:
return e.code
def main() -> None:
username = "race_" + uuid.uuid4().hex[:12]
password = "race-pass-1234567890"
barrier = threading.Barrier(2)
def worker(display_name: str) -> int:
barrier.wait() # старт одновременно
return post_user(username, display_name, password)
with ThreadPoolExecutor(max_workers=2) as pool:
results = list(pool.map(worker, ["Первый", "Второй"]))
results.sort()
print(f"HTTP codes: {results}")
assert results == [201, 409], f"expected [201, 409], got {results}"
print(f"PASS: race — one 201, one 409 for username={username}")
def test_chat_rollback() -> None:
"""Попытка создать чат с несуществующим участником → 400, чат не создан."""
import base64
# Создаём пользователя
username = "rollback_" + uuid.uuid4().hex[:8]
password = "rollback-pass-1234567890"
code = post_user(username, "Rollback", password)
assert code == 201, f"failed to create user: {code}"
# Логинимся
cred = base64.b64encode(f"{username}:{password}".encode()).decode()
req = urllib.request.Request(
BASE + "/api/v1/auth/sessions",
headers={"Authorization": "Basic " + cred},
method="POST",
)
resp = urllib.request.urlopen(req)
session = json.loads(resp.read())
token = session["token"]
user_id = session["user"]["id"]
# Пытаемся создать чат с несуществующим UUID
fake_user = "00000000-0000-4000-8000-000000000000"
body = json.dumps(
{"title": "Bad chat", "member_ids": [user_id, fake_user]},
ensure_ascii=False,
).encode("utf-8")
req = urllib.request.Request(
BASE + "/api/v1/chats",
data=body,
headers={
"Content-Type": "application/json",
"Authorization": "Bearer " + token,
},
method="POST",
)
try:
urllib.request.urlopen(req, timeout=10)
code = 200
except urllib.error.HTTPError as e:
code = e.code
assert code == 400, f"expected 400 for unknown member, got {code}"
# Проверяем, что чат не создан — list chats не должен его содержать
req = urllib.request.Request(
BASE + "/api/v1/chats?limit=100",
headers={"Authorization": "Bearer " + token},
)
resp = urllib.request.urlopen(req)
page = json.loads(resp.read())
titles = [c["title"] for c in page["items"]]
assert "Bad chat" not in titles, f"chat was created despite failure: {titles}"
print("PASS: rollback — chat not created when member is unknown")
if __name__ == "__main__":
main()
test_chat_rollback()