ЛР 2 - БВТ2303 - Кропивка - на 4 #7
+32
-20
@@ -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
@@ -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"]
|
||||
@@ -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
@@ -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
|
||||
@@ -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
|
||||
@@ -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)
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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.
|
||||
@@ -0,0 +1,2 @@
|
||||
python3 tests/smoke.py --base-url "http://localhost:8080"
|
||||
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
|
||||
@@ -0,0 +1,5 @@
|
||||
statement_timeout
|
||||
-------------------
|
||||
0
|
||||
(1 row)
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
Generic single-database configuration.
|
||||
@@ -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()
|
||||
@@ -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")
|
||||
Executable
+8
@@ -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
|
||||
Executable
+19
@@ -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
|
||||
Executable
+112
@@ -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
@@ -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()
|
||||
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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()
|
||||
@@ -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()
|
||||
Executable
+100
@@ -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()
|
||||
Executable
+127
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user